Establish the three-control behavior contract · Useful, appropriately qualified planning report: defaults, selection limits, discard-counter semantics, atomic rejection, and draft-only reset are grounded in the supplied excerpts. It does not yet establish the milestone's complete behavior contract. No implementation or test execution is demonstrated.

The source resolves the discard-lifecycle disagreement: dealNewHand() calls reset(), which replenishes remaining discards from the configured allowance. Adopt Builder’s explicit “Apply and deal new hand” as the proposed application boundary, not mid-hand mutation. Reviewer’s scoring concern remains material: playHandSize both caps selection and determines straight/flush length; setting it to one can make those detectors match a single card. Neither deck capacity nor the cheat values establish safe input ranges. The next milestone is therefore a bounded behavior contract, not panel implementation. Inspect evaluation, dealing and available tests, then specify supported settings and rejection behavior. Readiness here covers that investigation only. Keep scoring expansion, persistence, additional controls and unrelated refactoring out of scope. Unlicense is listed; maintainer acceptance and permission to merge remain unestablished.

I withdraw my earlier discard-lifecycle objection: `dealNewHand()` calls `reset()`, which restores remaining discards from the configured allowance. Scout and Builder are right that an explicit “Apply and deal new hand” action fits the existing lifecycle. However, I would challenge treating `playHandSize <= handSize` and deck capacity as sufficient validation. `updateControls()` permits evaluating any nonempty selection up to `playHandSize`, while straight and flush detection require exactly that many cards. With `playHandSize` set to one, those detectors can match a single card. Whether that produces an acceptable result depends on evaluation precedence in the still-unsupplied `PokerHand.js`; numeric validity alone cannot establish supported gameplay. The next review should inspect that evaluator and existing tests, specifically comparing selections below and at the configured limit, including one-card settings. This should distinguish intentionally hackable behavior from unsupported combinations without expanding scoring scope. The hard-coded `cheat()` values do not establish safe bounds. Builder’s atomic rejection and draft-only reset remain useful proposed guarantees, not demonstrated properties. Unlicense is listed; maintainer acceptance and permission to merge remain unestablished.

Scout’s source trace resolves the earlier lifecycle disagreement: `dealNewHand()` already calls `reset()`, rebuilding the deck and restoring the configured discard allowance. A proposed “Apply and deal new hand” action would therefore fit the existing lifecycle rather than introduce replenishment mid-hand. My Builder refinement is to make that action explicit instead of silently queuing changes. Keep edits separate from active rules, validate the whole draft before mutation, and make “Reset fields” restore only the draft defaults: five held cards, five playable cards and one discard. Invalid submissions should leave both rules and the current hand untouched; these are proposed guarantees, not established implementation behavior. I also agree that “playable-card limit” needs explanatory text: `playHandSize` caps selection but also sets the required length for straights and flushes. A numeric maximum alone would conceal that consequence. The next useful step is checking `PokerHand.js`, `Deck.js` and available tests for a defensible initial input range, then targeting rejection-without-mutation and apply-on-new-deal cases. The cheat values are not evidence of safe bounds. Scoring expansion stays outside this slice. Unlicense is listed; maintainer acceptance and permission to merge remain unestablished.

The supplied source resolves Reviewer’s discard-lifecycle concern: `dealNewHand()` calls `reset()`, which rebuilds the deck and copies the configured discard allowance into the remaining counter. Replenishing discards on a new deal is existing behavior, not a new panel policy. Builder’s proposed new-hand application boundary therefore has concrete support, though atomic application remains unverified. The unfinished opportunity is making the rules understandable, not merely exposing three numbers. `GameRules.js` defaults to five held cards, five playable cards and one discard. Crucially, `playHandSize` both caps selection in `game.js` and determines the required length for straights and flushes. Calling it only a “playable-card limit” would hide a scoring consequence. I would next inspect `PokerHand.js`, `Deck.js` and existing tests to determine which combinations can be offered without scoring expansion. A useful check is whether a proposed setting preserves coherent dealing, selection and evaluation—not just whether it fits numeric bounds. The hard-coded `cheat()` values demonstrate intended experimentation, not validated limits. Unlicense is listed; maintainer acceptance and permission to merge remain unestablished.

The README supports a hack panel, but these three controls are only a first slice of its broader roadmap. I agree with Reviewer’s challenge to applying changes at every new hand: that could replenish discards if their allowance belongs to a round or run. We should not select that boundary without tracing the source. The next milestone is a source-backed behavior contract, not panel implementation. Retain Builder’s draft-and-apply approach as a proposal: edits remain inactive, invalid submissions preserve state, and reset restores draft defaults only. Confirm whether the existing architecture can support those guarantees before adopting them. Scope excludes scoring expansion, additional controls, persistence and unrelated refactoring. Unlicense is listed; maintainer acceptance and permission to merge remain unestablished.

I support the focused slice, but challenge Builder’s proposed “new hand” boundary: if discard allowances belong to a longer-lived round or run, applying them each hand could replenish a consumed resource. The supplied file listing cannot establish that lifecycle. Inspect GameRules.js and game.js before selecting an application boundary or promising state-preserving behavior. The README explicitly requests a hack panel, but it does not specify these three controls, their bounds, or reset semantics. Its flexible-scoring roadmap also makes a conventional five-card cap an unsafe assumption; “up to 10 cards or so” is an aspiration, not a validated limit. The next review should trace configured defaults, remaining counters, selection limits, and scoring support. Then assess whether draft-and-apply can reject unsupported combinations without partial mutation. Reset also needs a clear distinction between restoring draft fields and restoring active rules. Those observations should determine proposed boundary and interaction tests, rather than tests encoding assumptions prematurely. Unlicense is listed. Maintainer permission to merge or endorsement of this scope has not been established; the roadmap is evidence of interest in a panel, not acceptance of this implementation.

The README explicitly names a hack panel, but its scope is all available parameters; these three controls would be a useful first slice, not completion of that roadmap item. I agree with Scout that numeric validation alone is insufficient. My builder preference is a draft-and-apply panel: editing fields should not mutate gameplay, and applying an invalid combination should preserve both the current rules and game state. To avoid ambiguous mid-hand changes, I would explore applying accepted settings when starting a new hand, with that timing stated beside the controls. One concrete distinction matters: “discards” should label a configured allowance, not silently overwrite a remaining counter. Likewise, “Reset fields” should restore documented default settings without implying that it restarts play. Those semantics need checking against GameRules.js and game.js; their contents were not supplied. The next useful step is inspecting that rules-to-game boundary before choosing constraints or writing tests. Candidate checks are rejected input preserving state, accepted settings taking effect at the stated boundary, and reset restoring defaults—not claims of executed tests. The snapshot lists Unlicense, but maintainer acceptance and write access are not established.

The unfinished opportunity is explicit: the README’s roadmap calls for a hack panel to replace browser-console editing. A panel for hand size, discards and playable-card limits is a focused slice, not fulfillment of the broader “all available parameters” goal. My Scout concern is that validation cannot stop at numeric inputs. These settings may interact: reducing hand size could leave an existing selection invalid, and changing discards could mean changing either a configured allowance or the remaining count. The supplied snapshot lists GameRules.js and game.js but does not expose their contents, so those behaviors remain unverified. I would explore when changes should take effect—immediately or on a new hand—and what reset restores before settling the panel’s behavior. A useful success check would be that accepted settings leave gameplay coherent, rejected combinations explain the problem without altering state, and reset restores documented defaults. Boundary and interaction cases would then give the proposed tests a concrete purpose. The repository is listed as Unlicense; maintainer permission or interest in accepting this contribution has not been established.