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; team totals already fired above)
hidden binaries fire (legs this run decided — see Auto-riders)

BUY YES  Total Bases single lines up to (TB + base number)              @ 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; 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.

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; 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. Feed-derived (not the CHG swipe); a manual TEAMS-toggle pin overrides it; resets per game.

double-tap an OCCUPIED base → runner modal
IF that runner has a live Stolen Bases market → SB swipe; ELSE advance-only button (no buy)

BUY YES  runner's LOWEST live Stolen Bases line                              @ price cap
then advance the runner (3B → scores; stealing home does NOT fire run crossers)

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; team totals already fired above)     // no direct orders of its own; diamond untouched

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 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

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
// 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)
// 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

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
// 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.

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) · 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

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¢.

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 · orders-panel REFRESH. The 1B/2B/3B diamond buttons are dead code — never rendered. Orders-panel CANCEL is always live (bypasses 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.

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

quickTD(picked, kind)   // kind inferred: RB/QB → "rush", catcher → "rec"
1  PROP/ANYTD    → picked player's anytime-TD YES
2  IF first TD of the game → PROP/FIRSTTD — his first-TD YES

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.

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 total now CLOSED → NO every unreached H1 Over
END Q3: Q3 total → NO-sweep
END Q4: Q4 total → NO-sweep
        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.

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', all operators) are pages, not gestures — no intents, no orders. Bookkeeping intents that NEVER order: SYS/STAT_SYNC (⟳ API adopt), 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.