IF Dev mode ON        → every order becomes a [DEV] log row. Nothing sent.
ELSE IF Trading OFF   → every order becomes a [SIM] log row.
ELSE                  → real Kalshi limit order at the leg's cap.

The "game lines" toggle only stops the run-crosser ladders and RFI YES auto-fire. Sliders, batter props, K, SB, pitcher change, and moneyline all fire with it off. Order CANCEL buttons bypass every switch — a cancel is always sent live.

Every button gets ONE pool of BET CAP contracts per activation; every leg it fires drains
that same pool in the button's listed order. Pool empty → later legs skip "budget drained".
EXCEPTION: moneyline sizes from its own ML STAKE setting and ignores the pool.

Caps (the limit price IS the cap; ask above cap → leg skipped, never chased):
  PRICE CAP (profile setting)  → EVERYTHING except moneyline: props, K, SB, pitcher chg, RFI,
                                 all settlement sliders, all crossers, all hidden binaries.
                                 NO hardcoded caps anywhere (ruling 2026-07-17 — the old hard-99¢
                                 limits on Top-9 / Bot-9 / F3/F7 / team totals were REMOVED).
  ML cap / model buy_limit     → moneyline legs only (shadow / v8-live)

IF displayed batter has ≥ 1 live batter-prop market → visible

BUY YES  Hits — ONLY the rung this hit newly decided (hits + 1)  @ price cap
BUY YES  Total Bases — ONLY the newly-decided rung (TB + 1)       @ price cap
// buys the rungs floor < line ≤ target only (floor = pre-play tally); a
// batter's 2nd hit buys 2+ ALONE, never re-buys the already-won 1+.
// Multi-rung spans fire HIGHEST line first, down to lowest (RBI 3+ → 2+ → 1+).

IF moneyline armed → moneyline pair (one-shot, see Auto-riders)
team totals fire (SCORING team — right after moneyline, first claim ahead of props/RFI/game totals)  @ price cap
IF inning == 1 AND RFI unfired → BUY YES every Run-in-1st market      @ price cap
BUY YES  Hits+Runs+RBIs — ONE line: (H+R+RBI) + N                       @ price cap
BUY YES  RBIs — ONE line: (RBI) + N                                     @ price cap
game-total crossers fire (F5 + Total Runs + Inning Total — see Run crossers; team totals already fired above)
hidden binaries fire (legs this run decided — see Auto-riders)

BUY YES  Total Bases single lines up to (TB + 2)                        @ price cap

Done / backdrop buys nothing — it finalizes the diamond, advances the lineup, re-arms the ML pre-sample.

same gate as HIT — batter has ≥ 1 live prop market

 1  IF moneyline armed → moneyline pair, runs = scored + 1   (one-shot)
 2  game-total crossers fire (F5 Total + Total Runs + Inning Total; scored + 1 runs, HIGHEST line first)  @ price cap
 3  IF inning == 1 AND RFI unfired → BUY YES every Run-in-1st market                @ price cap
 4  team totals fire (SCORING team, HIGHEST rung first)                              @ price cap
 5  BUY YES  Home Runs — newly-decided rungs (HR floor < line ≤ HR+1)                @ price cap
 6  BUY YES  Hits — newly-decided rungs (hits floor < line ≤ hits+1)                 @ price cap
 7  hidden binaries fire (legs these runs decided — see Auto-riders)
 8  BUY YES  Hits+Runs+RBIs — newly-decided rungs (HRR floor < line ≤ HRR+3+scored)  @ price cap
 9  BUY YES  Total Bases — newly-decided rungs (TB floor < line ≤ TB+4)              @ price cap
10  BUY YES  RBIs — newly-decided rungs (RBI floor < line ≤ RBI+1+scored)            @ price cap
// Order set 2026-07-20 (operator ruling) and UNIQUE to the HR swipe. The batter-prop
// ladder is deliberately split: Home Runs + Hits (5,6) fire BEFORE the hidden binaries (7),
// then HRR + Total Bases + RBIs (8,9,10) after. 1B/2B/3B · WALK · +RUN keep the default order
// (team totals right after the moneyline, then props, then RFI/game totals/hidden binaries).
// "newly-decided" = floor < line ≤ target (pre-play tally): a multi-run play buys the whole
// crossed span at once (HIGHEST line first), but a rung an earlier play won is never re-bought.

IF bases loaded (1B+2B+3B occupied) → gold WALK · RUN IN swipe (drag ←, walk button's slot)
    // a loaded-bases walk always forces a run → fires the FULL run basket below,
    // so the tap is upgraded to a slider — an accidental tap can't buy anything
ELSE → plain WALK tap button (unchanged)

forced = runners pushed home by the walk chain
IF forced == 0 → NO BUYS — diamond + lineup only
ELSE:
    IF moneyline armed → moneyline pair, runs = forced   (one-shot)
    team totals fire (SCORING team — right after moneyline, first claim ahead of props/RFI/game totals)  @ price cap
    IF inning == 1 AND RFI unfired → BUY YES every Run-in-1st market  @ price cap
    BUY YES  Hits+Runs+RBIs — newly-decided rungs (HRR floor < line ≤ HRR+forced) @ price cap
    // HRR is the ONLY batter prop a walk buys — no Hits, TB, or RBIs series
    // floor = pre-play HRR: never re-buys a rung an earlier play already won;
    // multi-rung spans fire HIGHEST line first, down to lowest
    game-total crossers fire (forced runs, F5 + Total Runs + Inning Total; team totals already fired above)
    hidden binaries fire (legs the forced runs decided — see Auto-riders)

IF pitcher has a live Strikeouts market AND pitcher Ks ≥ (lowest live line − 1)
   AND (card NOT pinned to the remaining starter OR that starter is the live pitcher on the mound) → visible

BUY YES  ONE Strikeouts market — wheel-selected line, else lowest live line   @ price cap
ALWAYS advance the lineup, even when the buy skips

Pitcher card pins to the remaining starter once the other is pulled. Normally the card rotates each half between the two starters. When the MLB feed shows a team's starter replaced by a reliever (live pitcher ≠ roster index-0 starter), that starter's Strikeouts contract is closed, so the card stops rotating and shows ONLY the other team's starter — the last open contract — in both halves. The K swipe is then withheld on the pinned starter's off-mound half (reliever pitching) so it can't fire a strikeout buy while that starter is sitting. And as of 2026-08-13: during the pinned starter's OWN team's at-bats (he's in the dugout, the opposing reliever on the mound has no contracts) the pitcher card AND its Strikeouts ladder hide entirely — both return the next half when he retakes the mound. Follows the DISPLAYED batting team — the batter TEAMS toggle is now the ONLY team switch (the pitcher-card TEAMS button was REMOVED 2026-08-13); flipping to the opposing lineup brings the pinned pitcher back up. Feed-derived (not the CHG swipe); resets per game (the pitcher-card TEAMS toggle was removed 2026-08-13 — the batter TEAMS button drives the whole view; FIXED 2026-08-15 after Steve's 8/14 report: with both starters in, the batter TEAMS flip now actually flips the pitcher card to the team that faces the displayed lineup — it used to stay stuck on the live mound pitcher, so CHG for the other side was unreachable).

double-tap an OCCUPIED base → runner modal
IF that runner has a live Stolen Bases market → STOLEN BASE tap opens the
    catcher-throw question (2026-08-25): "Did the catcher throw to {base}?"
ELSE advance-only button (no buy, no question)

YES · THROW (slide ← to fire) — throw = official stolen base:
    BUY YES  runner's LOWEST live Stolen Bases line                          @ price cap
    then advance the runner (3B → scores; stealing home does NOT fire run crossers)
NO THROW (single tap) — likely defensive indifference, no SB credited:
    advance the runner only — NO BUY (logged `SB no throw`)
Cancel / backdrop → nothing (runner stays put)

LEAD runner (highest occupied base: 3B → 2B → 1B) removed from the diamond  // 2026-08-25:
    the swipe asserts they crossed home — no second gesture; bases empty → nothing cleared
IF moneyline armed → moneyline pair, runs = 1   (one-shot)
team totals fire (SCORING team — right after moneyline, first claim ahead of RFI/game totals)  @ price cap
IF inning == 1 AND RFI unfired → BUY YES every Run-in-1st market       @ price cap
game-total crossers fire (+1 run, F5 + Total Runs + Inning Total; team totals already fired above)     // no direct orders of its own

IF the displayed pitcher is the STARTER (boxscore index 0) → visible

FOR EACH Strikeouts line > pitcher's current K count (lowest first):
    BUY NO                                                              @ price cap
// bets the pulled starter never reaches those lines. Nothing bought for the reliever.

IF inning == 1 AND half == Bottom AND score 0–0 AND neither RFI YES nor NO fired AND an RFI market exists

BUY NO on EVERY active Run-in-1st-Inning market                          @ price cap
+ INTEGRATED END-OF-INNING (2026-08-25): NO both inning-1 Inning Total lines
  (Over 0.5 + Over 1.5) — marks inning 1 swept, generic END swiper never re-offers

IF inning == 5 AND half == Top AND home > away (strictly) AND unfired AND F5 home Winner exists

BUY YES  HOME F5 Winner          @ price cap
BUY NO   AWAY F5 Winner          @ price cap
BUY NO   TIE  F5 Winner          @ price cap
BUY NO   AWAY −1.5 F5 Spread     @ price cap
BUY NO   AWAY −2.5 F5 Spread     @ price cap
IF home leads by ≥2 → BUY YES HOME −1.5 F5 Spread   @ price cap
IF home leads by ≥3 → BUY YES HOME −2.5 F5 Spread   @ price cap
// the swipe asserts the top half is done — home only ADDS runs, so the
// margin is the segment floor (operator ruling 2026-08-22). Speculative by
// design — away still bats this half. Tickers shared with Bot-5 dedup.

IF inning == 5 AND half == Bottom AND not fired AND an F5 market exists → visible
// no outs gate, no stages — the swipe itself ASSERTS the first five are final (F3/F7 law)

IF home > away      → BUY YES HOME Winner · NO AWAY · NO TIE
ELSE IF away > home → BUY YES AWAY Winner · NO HOME · NO TIE
ELSE (tied)         → BUY YES TIE Winner  · NO HOME · NO AWAY
FOR L in {1.5, 2.5}, each team: BUY YES if final margin > L, ELSE BUY NO   (all 4 rungs resolve)
FOR EACH F5 Total Over: IF total < count → BUY NO   (cleared Overs skipped, never Over YES)
+ INTEGRATED END-OF-INNING (2026-08-25): NO every inning-5 Inning Total line the
  inning's runs didn't cross — marks inning 5 swept (generic END swiper never re-offers)
// per-ticker dedup vs Top-5 (shared f5BoughtTickers) — nothing bought twice

Every leg buys at the operator's set price cap — deliberately NOT the hard-99¢ limit the 9th/F3/F7 sweeps use (operator ruling 2026-07-16). The swipe is the operator's assertion that the segment ended: swiping mid-inning buys a full settlement basket on an unfinished segment. Feed outs are logged for forensics only.

IF inning ≥ 9 AND half == Top AND home > away AND unfired AND Winner market exists
// NO outs gate — "the game is over" is the operator's judgment

BUY YES HOME Winner · BUY NO AWAY Winner · BUY NO Tie (if listed)
FOR EACH Total Runs Over:  IF total < count → BUY NO   (achieved Overs skipped)
FOR EACH Team Total Over (both teams): IF team runs < count → BUY NO
FOR EACH Spread: plus-lines skipped · home YES if margin covers ELSE NO · away always NO

IF inning ≥ 9 AND half == Bottom AND away > home AND unfired AND Winner market exists
// hides itself if home ties or walks it off; no outs gate

BUY YES AWAY Winner · BUY NO HOME Winner · BUY NO Tie (if listed)
Totals + Team Totals identical to Top-9 · Spreads: away covers → YES ELSE NO · home always NO
+ INTEGRATED END-OF-INNING (2026-08-25): NO the leftover inning-9 Inning Total lines

TOP:    IF inning == N AND half == Top AND home > away AND unfired
BOTTOM: IF inning == N AND half == Bottom AND home ≤ away AND unfired  (tie counts)

TOP:                      BUY YES HOME · NO AWAY · NO TIE
BOTTOM, away leading:     BUY YES AWAY · NO HOME · NO TIE
BOTTOM, tied:             BUY YES TIE  · NO HOME · NO AWAY
B3/B7 only, + INTEGRATED END-OF-INNING (2026-08-25): NO the leftover inning-3 / inning-7
  Inning Total lines (tops never — the inning isn't over at the top)
// the swipe asserts the segment's FINAL OUT was just recorded — that is the operator's call

IF inning == N AND half == Top AND home == away (TIED) AND away F(N) Winner market exists AND unfired

BUY NO   F(N) AWAY Winner
// tied game, away bats last in its half of the segment inning: if it doesn't score in
// the top, it can no longer WIN the segment (home bats last → can only tie or take the lead).
// Home YES + Tie stay LIVE (home still bats). NEVER a home/tie leg, never a ladder.

Mutually exclusive with the home-led T3/T7 and the Top-of-5th lock-in (those gate on a lead; this on a tie), so they never co-occur. The swipe asserts the top-half final out was recorded still tied. One-shot per segment; ticker dedup via the shared hbBoughtTickers set.

IF half == Bottom AND inning N ≤ 9 AND live leftover Inning Total lines exist
AND inning N not already swept
AND NO settlement slider for this inning is on screen:
    N=1 RFI NO · N=3 B3 · N=5 Bottom-5 sweep · N=7 B7 · N=9 Bot-9
    // when one of those IS visible it carries these legs itself and this swiper hides —
    // every bottom half shows exactly ONE control for the inning lines.
    // Bottoms of 2/4/6/8 (no settlement slider exists) always use this swiper.

FOR EACH inning-N Inning Total line: IF runs-this-inning < count → BUY NO   @ price cap
0 runs → NO Over 0.5 + NO Over 1.5 · 1 run → NO Over 1.5 only · 2+ runs → nothing left (hidden)
// crossed lines are never touched (their YES was bought live by the run crossers)

The play's runs are walked ONE AT A TIME — each run is its own margin event.
Segment members are BOTTOM-half only (a top-half run decides nothing; home still answers).

#6 TIE-TOTAL — IF any run makes the game TIED (any inning, EITHER half):
    BUY YES full-game Total Runs Over (new_total + 0.5)     // ONE line, GAME total only
    // a game cannot end tied ⇒ the next run is guaranteed before it scores
    // never on a go-ahead · never a ladder · never team totals

IF half == Bottom:
  #1/#7 — IF inning == 3 or 7 AND the run TIES it:
      BUY NO  F3/F7 AWAY Winner       // away is done batting the segment. TIE stays LIVE
  #2/#8 — IF inning == 3 or 7 AND the run puts HOME AHEAD:
      BUY YES F3/F7 HOME Winner · BUY NO F3/F7 AWAY Winner · BUY NO F3/F7 TIE
  #3 — IF inning == 5, per run, whenever away's lead can no longer reach a spread line:
      IF (away − home) ≤ L → BUY NO AWAY −L F5 Spread    // away 3–0, 2-run shot ⇒ both rungs die
  #4 — IF inning == 5 AND the run TIES it:
      BUY NO F5 AWAY Winner (+ any remaining away-spread rung via #3)   // F5 TIE stays LIVE
  #5 — IF inning == 5 AND the run puts HOME AHEAD:
      BUY YES F5 HOME Winner · BUY NO F5 AWAY Winner · BUY NO F5 TIE
      // F5 TOTALS stay LIVE — home can keep scoring
  #9 WALKOFF — IF inning ≥ 9 AND the play flips home from not-leading to leading:
      the game ends on the play — the WHOLE BOARD settles at the play's FINAL score:
      Winner: YES HOME · NO AWAY (· NO Tie if listed)
      Game totals: reached Overs YES · unreached NO
      Team totals: BOTH teams — reached rungs YES · unreached NO
      Spreads: home rung YES if final margin clears it ELSE NO · away rungs NO · plus-lines skipped
      // PLAYER PROPS EXCLUDED by ruling · multi-run walkoffs judged at the FINAL margin

EXCLUSION LAW: no spread-shrink in the 9th/extras — a tie there reopens unlimited innings,
so nothing is capped until the game actually ends. A B9 equalizer fires ONLY the tie-total.

All legs at the set price cap, sharing the run swipe's click pool. Per-ticker dedup both ways: F5 legs share f5BoughtTickers with the Top-5/Bot-5 sliders; everything else shares hbBoughtTickers with the F3/F7 and 9th settlement sweeps — a binary fire followed by a slider swipe (or vice versa) skips instead of doubling. An equalizer is also a tying run, so #1/#4/#7 naturally fire together with the tie-total. AUTO-FIRE means a mistaken run swipe places these orders instantly — the run swipe is no longer a pure signal.

rides every scoring action · IF game lines ON AND inning == 1 AND unfired
→ BUY YES every Run-in-1st-Inning market                                 @ price cap
// firing it permanently hides the RFI NO swipe

ride every run (+RUN, HR, forced WALK, hit-flow taps, diamond scores) · IF game lines ON:

TEAM TOTALS FIRST — fired right after the moneyline, BEFORE batter props / RFI /
game totals / hidden binaries (ruling 2026-07-20 — first claim on the shared pool):
    SCORING team only, defending team never touched:
    FOR EACH Over rung ≤ team's new run count, unfired → BUY YES     @ set price cap
    HR sorts HIGHEST rung first; back-fills all reached rungs (decided binaries)

THEN game-total crossers (inside onRunsScored) · FOR EACH run (post-play total):
    IF inning ≤ 5 AND F5 Total line crossed, unfired  → BUY YES F5 Total    @ price cap
    IF Total Runs line crossed, unfired                → BUY YES Total Runs  @ price cap
    INNING TOTAL (2026-08-25, KXMLBINNINGTOTAL) — current inning N ≤ 9:
        the run crosses inning line runs-this-inning+1 (1st run → Over 0.5, 2nd → Over 1.5)
        IF line unfired for inning N → BUY YES "Inn N Over x.5"    @ price cap
        3rd+ run of an inning: no market exists (silent) · dedup per inning per line
        runs-this-inning = (feed total + optimistic) − baseline snapshotted at each
        inning change; BOTH halves count — the market settles on the whole inning

armed via Profile toggle · fires on the next scoring action · stake = ML STAKE (not bet cap)
the arm is consumed IMMEDIATELY — even if both legs skip, re-arm from Profile
BUY YES scoring team's full-game Winner · BUY NO opponent's Winner   (independent legs)
price: v8 model ON → model buy_limit (backend re-prices; no-trade → skip)
       shadow      → skip if ask > ML cap, else limit = ML cap
exit: backend sell ladder arms on the real fill

LOCK CHIP V2 — two states, ONE gesture (no long-press, no pin, no app_reentry class):
GREEN (machine): chip shows LIVE batting-team mid + standing crystal (✓/⚠ + age) + card caps
TAP → YELLOW (operator): the DISPLAYED number becomes THE pre for EVERY fire while held —
    including multiple scoring plays. Releases on: batter change (EXCEPT through a swiped
    hit's popup — dismissal releases), HR-timer baseline, or tap again.
FIRE CARD — every anchor (auto crystal or tap) immediately prices BOTH outcomes
    (next-run + HR at runners+1) into ready payloads; regenerates on every state change.
    The swipe indexes and sends — ZERO pricing on the hot path (chip shows "46¢ · R53 H61").
NO FIRE-TIME REFEREE — anchor health is guaranteed at LOCK time only (coherence gate +
    mid-anchoring + operator lock); a diverged anchor still fires. The per-fire skew line
    (anchor vs live, logging only) is the postmortem record.
Coherence gate: ask-sum 98–105 (105 since 2026-07-27, histogram-calibrated), spread ≤ 5¢.

Positions tab now mimics Kalshi: OPEN CONTRACTS only (no order history, no day picker, no pager).
Each open-position card: price input (CENTS, 1–99 — type "45" for 45¢, no dot; ".45" also accepted) + SELL ALL button.

IF no price typed / out of 1–99¢   → SELL button stays DISABLED (red border on bad entry)
ELSE IF Dev mode ON             → [DEV] log row, nothing sent
ELSE IF Trading OFF             → [SIM] log row, nothing sent
ELSE → backend re-fetches the EXACT open count from Kalshi (never trusts the card),
       FLOORS fractional positions (34.7ct → 34 — overselling would OPEN the other side),
       then places ONE limit order: sell <whole count> <held side> @ typed price,
       GOOD-TILL-CANCELED. No crossability check — resting is the point. Crosses the
       book if it can; otherwise RESTS until filled or canceled.

YES position → sells YES at the typed YES price; NO position → sells NO at the typed NO price. Cards with resting orders show an "N resting" chip + ✕ CANCEL RESTING (cancels every active order on that market — bypasses dev/SIM like all cancels). Strategy tag position_sell in order_log + loghub. The 10s UNDO toast still appears when an order rests.

ML lock chip (tap = yellow operator lock / release — an ANCHOR control, it never places an order itself) · screen-lock swipe · market rows & prop wheel (selection only — no tap-to-buy exists) · dev controls (display state only) · BET CAP input · Positions-page REFRESH and price inputs (typing never sends — only the SELL ALL button does). The 1B/2B/3B diamond buttons are dead code — never rendered. Inning+outs stack (scoreboard): DOUBLE-TAP = advance one half-inning — ASSUMES the displayed batter made the last out (their team's next at-bat opens on the FOLLOWING batter), flips batting/pitching teams (releases TEAMS pins), resets the batter selection, clears outs to 0 AND clears the base runners (a back-step can't restore chips — re-place them after a mis-tap); clamped to ONE half ahead of the MLB feed, auto-clears when the feed catches up. SINGLE TAP = step back a half, ONLY when ahead of the MLB feed (undoes the double-tap, rolls the batter pointer back; at the live feed it does nothing; fires on a 350ms delay so a double-tap's first tap never triggers it). The game-state modal was retired with this (ruling 2026-08-13, third revision same day). Changes the v8 model's inputs but never places an order itself. Positions-page ✕ CANCEL RESTING and UNDO cancels are always live (bypass dev/SIM).

IF sandbox-lobby game        → intent tagged sandbox:true → order-free engine. Nothing sent.
ELSE IF ticker ≠ the actively-selected game → REFUSED  // game-lock: a prop buy can never hit the wrong game
ELSE IF SLYDER_LIVE_ARM ≠ ARMED → "WOULD PLACE" log row only. Nothing sent.
ELSE IF count > per-swipe cap (1) → REFUSED — never clamped
ELSE IF operator's DEMO MODE is ON (settings; default ON when unset) →
    SIMULATED at the signing relay: validated like a real order, answered with a
    Kalshi-shaped fill (order_id demo-…), logged to activity as 🧪 DEMO BUY. No
    signing, no money — enforced SERVER-side per operator, independent of arm state.
ELSE                          → real Kalshi limit order, signed with the OPERATOR'S OWN key
Session cap: 20 order attempts/session (reserved synchronously — burst-proof).

One gesture = one pool. A single spot confirm may cross SEVERAL rungs (a 40-yard catch clears 2+ receiving lines at once) — all fire from that activation's cap pool, HIGHEST rung first. The limit price IS the cap: ask above cap → that rung skips, never chased. Untagged intents route to the SANDBOX engine (default-deny); navigation (LOBBY/LIVE/SQUAD/STATS) fires no intents at all.

floor  = the player's PRE-PLAY cumulative total
target = the player's POST-PLAY cumulative total
BUY YES only the rungs where  floor < line ≤ target,  HIGHEST line first.
A rung an earlier play already won is NEVER re-bought.

A single play fires props in TWO STAGES — different gestures, different jobs:
STAGE 1 — FLOOR ("at least N")  → buy what a +N minimum already GUARANTEES,
                                   the instant it's certain. NO playOver.
STAGE 2 — DOWN AT (precise spot) → buy ONLY the remainder beyond the floor,
                                   then close the play (playOver:true → book may requote).
// per-player, per-rung dedup runs ACROSS both stages. Each player tracks an
// INDEPENDENT total: passer's passing line ≠ receiver's receiving line.
// Identical discipline to baseball's batter-prop ladder; the difference is
// football yardage is CONTINUOUS, so the instigator is the spot confirm.

on the board, to commit a minimum gain BEFORE logging the precise spot

new_floor = player_pre_total + N
BUY YES every rung where  player_pre_total < line ≤ new_floor,  HIGHEST first:
  1  PROP/PASS_YARDS_OVER  → passer's guaranteed passing rungs     (note: "floor +N")
  2  PROP/RUSH_YARDS       → ball-carrier's guaranteed rushing rungs
  3  PROP/REC_YARDS_OVER   → receiver's guaranteed receiving rungs (pass play)
// NO playOver — the play isn't terminal; the precise spot still follows.
// The guaranteed rungs are certain the instant the minimum is — they fire NOW,
// ahead of the market, not at the spot confirm.

after any offensive play, to log where the ball actually ended (side + tens/ones odometer + team arrows)

precise net yards = pre-snap spot → play-final spot
target = player_pre_total + precise_yards       (each involved player, own total)
BUY YES ONLY rungs the floor did NOT already cover:  prev_bought < line ≤ target, HIGHEST first
  1  PROP/PASS_YARDS_OVER   2  PROP/RUSH_YARDS   3  PROP/REC_YARDS_OVER
// carries playOver:true — the play is terminal (also the maker's requote cue).
// No floor committed first? DOWN AT buys the WHOLE ladder pre_total → target.
// Floor committed? Only the top-up — never re-buys a rung the floor won.
// "QB goes over his passing yards" resolves across BOTH stages.

GENERIC POSITION SLOTS — "SEA Dummy QB" / "SEA Dummy RB" style stand-ins (renamed 2026-09-06) so gestures survive an
injury: always offered in the rusher/QB swap pickers (the Pass/Run rooms' COMPLETED
PASS/RUN and the TD picker's no-listed-scorer rows are the same idea). A generic slot
fires every TEAM-level leg (winner book, totals sweep incl. team total, NTH_TD, spot
entry) and SUPPRESSES every player-specific prop leg (yardage floors/finals,
receptions/completions mirrors) — each suppression leaves a SYS PROP_SKIP row
("generic player — prop skipped") so the audit trail shows it was considered.
LOUD FAILURES (2026-09-06, Steve's Stevenson session) — a player leg is NEVER
dropped silently: a generic carrier's yardage floor/precise/TD-final leaves a SYS
PROP_SKIP row naming the market; a NAMED player whose gesture finds no mapped Kalshi
tickers leaves a ⏭ SKIP ("no mapped prop tickers"); a family-level intent drop (zero
open markets) leaves a SYS row too. ML lock and every team leg still fire.
CONTRACTS-AWARE RUSHER DEFAULT (2026-09-06) — the designated-rusher row used to
HIDE when the depth-chart RB had no listed books (taking its double-tap swap with it,
SEA: Charbonnet dark while Price #8 held live contracts): the default now picks the
deepest RB WITH books; none at all → the generic RB slot. The row always renders; an
explicit operator pick is honored regardless of contracts.
DOUBLE-TAP SWAP, ALL POSITIONS — dbl-tap the RB rush block (existing), the QB rush
slider, or ANY receiver pill → swap picker (bench room for that position + the "Dummy" row —
2026-09-06: picking it swaps IN a rendered "SEA Dummy WR/TE" slider that tracks the ball
like a real player, fires team legs, and never fires player contracts; double-tap the
dummy to swap a real player back in). Radio semantics: incoming IN, outgoing benches; outgoing player's fired
props STAND and his tallies freeze; incoming tracks his own cumulative (zero if
untouched). Every swap logs a SYS SWAP row. Downstream consumers (rush slider,
pass mirrors, TD pills) re-aim automatically.

PROP/RECEPTIONS_OVER   → the newly-decided receptions rung for that receiver
PROP/COMPLETIONS_OVER  → the newly-decided completions rung for the passer
IF the catch's yards also cross a receiving-yards rung → PROP/REC_YARDS_OVER
// count entries do NOT carry playOver — not play-terminal

PROP/RUSH_YARDS → fires for the ACTIVE QB at the play-final spot, newly-crossed rushing rungs
// the active QB is the squad-page IN QB (a swappable member) — swap the QB and
// RUSH_YARDS re-aims to the new number

IF UPGRADE (more yards than logged)  → fire the corrected PROP finals for the newly-crossed rungs
IF DOWNGRADE (fewer yards)          → fix the player's stat/total ONLY;
                                       prop buys already fired STAND — never unwound
// mirrors baseball: corrections are authoritative replacement of the total,
// but a won prop is never clawed back

per-player TD pills in the TD suite (rush-TD for RB/QB, receiving-TD per catcher), formation-first

1  THE FIELD-DEFINING MARKET FIRST (whichever is live):
     IF game's FIRST TD              → PROP/FIRSTTD — the scorer's first-TD YES
     ELSE IF next-TD series listed   → PROP/NEXTTD  — the scorer's next-TD YES
2  PROP/ANYTD    → the scorer's anytime-TD YES        // deepest, most-traded NFL book
3  TOTALS SWEEP  → the Over lines the TD's CONCRETE +6 crosses (see Auto-riders —
                   buys through +6 ONLY, never the 6.5/7 line: the PAT hasn't happened)
4  FIELD NO-SWEEP → BUY NO the SAME field market for EVERY OTHER listed player
// order: the field market moves fastest on a specific scorer (1), anytime-TD is
// deep/liquid (2), point totals a beat slower (3), field NOs are near-certain
// settled contracts and not running away (4).
// RUSH TD / REC TD route to the SAME markets — "kind" tags the stat, not the market.
// Return/defensive TDs are winner-book events, NOT offensive-player prop gestures
// (the scorer's ANYTD still counts, via its own gesture).
// Real ticker shape: KXNFLANYTD-<date><away><home>-<TEAM><SCORER>
//   e.g. KXNFLANYTD-26JAN04WASPHI-PHITMCKEE16

The game's FIRST TD decides every KXNFLFIRSTTD contract. At scorer attribution (never
before): BUY YES the scorer's contract (first claim on the pool) + BUY NO every other
listed player's contract. ONE-SHOT per game — later TDs never touch the series. An
UNATTRIBUTED first TD (picker closed, defensive/return TD) fires NOTHING and logs
"first TD unattributed — basket held": the mystery scorer might be one of the listed
players, so the field's NOs are not certain. Relay: allowlist 26 series; the ask fence
admits KXNFLFIRSTTD (the app never holds YES on a market it NOs).

ON THE SWIPE — before the picker even opens (the +6 is certain, the scorer isn't):
    winner-book TD intent ("scorer pending") · NTH_TD stub · full totals basket
    (game / H1 / quarter / 2H / team crossers — same sweep as every score) · +6 on the
    board · PAT overlay armed
THEN the "Who scored?" picker — attribution ONLY (kind inferred: RB/QB → "rush",
    catcher → "rec"): the catch + QB completion mirror, receiving/rushing-yards finals,
    passing-yards mirror, TD stat bumps. Closing the picker WITHOUT a pick skips
    attribution only — the money already went. Nothing double-fires on the pick.

TEAM-TOTAL FIX (2026-09-05, Steve's confirmed wrong-side leg): the team filter matched
the team code anywhere in the ticker — the EVENT suffix ("…SEANE…") contains BOTH codes, so
the opening SEA score built the NE ladder keyed to SEA's points (bet_cap 1 was the only
thing that kept it off the book). The filter now requires the code in the ticker's MARKET
segment ("-NE4") — scoring team only, its own cumulative, each line once.

points = the CERTAIN value of the score ONLY:
  TD = 6   (NOT 7 — the PAT has not happened)   FG = 3   SAFETY = 2
  PAT good = +1 · 2PT good = +2   (their OWN gestures, later)

new_total(segment) = segment_points_before + points
for EACH live totals line in the segment: IF line ≤ new_total AND unbought → BUY YES Over (HIGHEST first)

Segments swept, all by the same points:
  the CURRENT quarter total (Q1–Q4)  ·  the H1 total (ONLY in Q1/Q2)  ·  the full-game total
  the SCORING TEAM'S team total       // only that team advances — never the other side

NEVER buy a total the score only reaches WITH a not-yet-happened PAT/2PT.
A TD makes the segment +6, CERTAIN → buy every Over ≤ (before + 6).
DO NOT buy (before + 6.5) or (before + 7) — that 7th point needs the unkicked PAT.
When the PAT is actually good, the PAT gesture fires +1 and buys the 6.5/7 line THEN.
// the scoring analog of the yardage doctrine: buy what already happened,
// never a milestone that depends on a future event

Only ONE player can win the field — the moment the scorer takes it, every OTHER leg is CERTAIN: NO.
for EVERY listed player EXCEPT the scorer:
    BUY NO that player's field-market YES (first-TD, or the current next-TD leg)
FIRST-TD: one-shot — fires once, on the game's first TD only.
NEXT-TD:  fires per TD, then the series advances to the following leg.
// fires FOURTH, after the scorer's YES legs are secured — the NOs are near-certain
// and not running away. The scorer himself NEVER gets a NO — he took the YES.
// The football analog of baseball's hidden-binary field settlement.

Next-TD legs fire ONLY IF the series actually lists on Kalshi. KXNFLNEXTTD was NOT a 2025-season market and still does not exist as of 2026-08-09 — the backend probes it on every market resolve and reports it via unavailable (the weekly re-check, automated). The ENGINE owns this gate: never fire next-TD legs against a market that doesn't exist.

Every quarter / 2H number is measured from the score at the START of that segment,
NOT the running game score. The baseline is registered by whichever comes first:
    clock hits 0:00 · ESPN advances the period · the operator picks a quarter in the
    clock editor · THIS swipe
Idempotent — two signals for the same quarter can't double-advance or re-snapshot.
The swipe now also registers the boundary and moves the board to the next quarter.
END-OF-QUARTER PROMPT (2026-08-28): any score entered inside the FINAL MINUTE pops
    "End of quarter?" — accepting runs THIS settle (score included: it applied to state
    first; same estimated-baseline confirm). FG / safety → prompt immediately; a TD holds
    the prompt until the PAT/2-pt entry resolves (untimed down — the conversion belongs
    inside the settled segment). Declining does nothing; the swipe stays available.
CATCH→TD COUNT FIX (2026-08-28): the rungs "TD ›" finish no longer re-fires the
    reception/completion counted at catch entry — one catch that ends in the end zone is
    exactly 1 reception + 1 completion.
IF the baseline was only ESTIMATED (board jumped quarters with no real boundary)
    → the swipe first asks the operator to CONFIRM the points scored in that quarter;
      nothing is bought until they do. Live quarter/2H total sweeps hold off too
      (⏭ SKIP · reason "baseline estimated"). Game + team totals are cumulative and
      keep firing normally.
// 08/26: the clock editor's quarter picker advanced the board WITHOUT a baseline,
// so every segment read current−0 = the cumulative score — Q3 settled on "margin -2"
// (true segment 9-0) and bought the wrong side of LAR -7.5 with real money.

SPREADS (2026-08-24 — YES side added): quarter (and H1/H2 on Q2/Q4) spread ladders
  winner's lines the margin CLEARED (floor < margin, e.g. −2.5 at +3) → BUY YES
  lines ABOVE either team's margin → BUY NO   (tie margin 0 → NO everything)
MONEYLINE: winner YES · others NO (tied segment → TIE YES · both NO)
segment_final = points scored IN that segment (now locked)
END Q1: Q1 total → BUY NO every Over line ABOVE segment_final
END Q2: Q2 total → same NO-sweep  ·  H1 books now CLOSED → same spread/ML/total settle on H1
END Q3: Q3 total → NO-sweep
END Q4: Q4 total → NO-sweep  ·  H2 books CLOSED → same spread/ML/total settle on H2
        IF regulation ends here (no OT) → full-game total CLOSED → NO every unreached FG Over
                                          BOTH team totals CLOSED → NO every unreached team-total Over
        ELSE (OT) → game + team totals STAY LIVE into overtime
// mirrors baseball's F3/F5/F7 settlement: reached Overs were already taken live
// by the TOTALS SWEEP as points scored; the slider cleans up the NO side the
// boundary just made concrete.

Clock editor — quarter picker (2026-08-27): picking a LATER quarter now asks for the score AT THE START of that quarter (prefilled with the live score, i.e. "this quarter just started"), because every quarter/2H total, spread and moneyline is measured from it. Confirming fires a CLOCK_SYNC bookkeeping intent only — no orders. Picking an EARLIER quarter (a mis-tap correction) reuses the baseline already recorded and never rewrites it.

Navigation fires nothing: the bottom nav (LOBBY / LIVE / SETTINGS / ACTIVITY — SQUAD + STATS moved to header chips on the board, 2026-08-09) is proven intent-free in the ship gate — returning to the lobby mid-game keeps the session live (the running game shows ▶ IN PROGRESS). SETTINGS (per-operator BET CAP + PRICE CAP, server-synced, blur-commit) and ACTIVITY (this central feed, app='nfl' — since 2026-08-22 scoped to the SIGNED-IN operator's own rows; the admin #activity page keeps the all-operators view; SKIPPED legs now log too — ⏭ amber SKIP rows (kind nfl-order-skipped) for every leg the executor evaluated but did not place, with reason budget drained / session cap, so a swipe's FULL intended basket is visible) are pages, not gestures — no intents, no orders. Bookkeeping intents that NEVER order: SYS/STAT_SYNC (⟳ API adopt — 2026-08-21: now also adopts the ESPN score + quarter (max-only / never walks the board backwards) AND the game clock (exact, live-only, skipped when the feed's period trails the board quarter) AND the ball spot — down/distance/yardline/possession from the current drive's last play-end. AUTO-SYNC (same day): all of the above now applies AUTOMATICALLY on every feed poll (5s cadence, was 12s) for the whole game — same doctrines; ball spot/down/distance/possession hold a 15s gesture-grace so the trailing feed never reverts a just-swiped play; ⟳ API remains the manual grace-ignoring full adopt, and rebuilds the settle-swiper quarter baselines from ESPN linescores when the quarter jumps), CLOCK_SYNC, GAME_SELECT (repoints the engine's allow-list — refused engine-side while it holds exposure or resting quotes, and requires live-game provenance). Out of this section's scope (documented when their phase ships): the winner-book reprice legs of TD/FG/safety/turnover, the maker layer (@ · HIKE · REQUOTE · box quoting · LIFT) — maker UI BUILT and deliberately HIDDEN 2026-08-10 (MM toggle + @ button exist in the app behind the single flag MM_UI_ENABLED; flip it when the market-making update ships — do not rebuild these), NTH_TD, and the winner-book reprice legs. TEST BUY panel REMOVED 2026-08-10: the app now has ZERO order-capable emitters (structurally asserted in the ship gate — no type:BUY exists in the bundle); the engine's order path is unreachable from the UI until the prop-execution phase ships.