138 Commits

Author	SHA1	Message	Date
builtbykev	7ac6aa73e3	Layer 2: multi-axis archetype classifier; the FLEX fallback is gone ... A player is a blend across independent axes, not one label. Skubal is a STARTER and a strikeout arm and a ground-ball arm and a control arm — four true things at once, and single-label classification threw three of them away. AXIS INDEPENDENCE WAS MEASURED, NOT ASSUMED. Correlations over the live store (467 batters, 531 pitchers); anything |r| >= 0.70 is one underlying trait and was collapsed so we never show one trait as two archetypes. Batter k% ~ whiff% +0.89, hard-hit% ~ exit velo +0.88, chase% ~ swing% +0.87, chase% ~ bb% -0.72; pitcher k% ~ whiff% +0.76, gb% ~ fb% -0.73 — all collapsed. The survivors are genuinely orthogonal, and one result is worth stating: pitcher velocity correlates +0.14 with K%, +0.07 with whiff% and +0.07 with GB%. Velocity is NOT a proxy for missing bats — a hard thrower who misses no bats is a real distinct type, so CANNON earns its own axis rather than being folded into STRIKEOUT. Pitcher K% ~ GB% is -0.10, so PUNCHOUT and SINKER are independent, which is exactly the multi-axis thesis. Cut-lines are the measured p75 (distinctive) and p90 (elite), per role where the tails differ even when the medians agree: reliever GB% p90 is 54.1 against a starter's 48.9, both with a median of 42.5. THE FALLBACK IS DELETED. classify() used to return FLEX (mlb) / SHIELD (wnba) / CONNECTOR (nba) at weight 1.0 when nothing scored — "could not classify" rendered as a fully-confident classification of a real archetype, with descriptive education copy attached. 8 of 18 MLB players carried it, and FLEX could never be earned because its only scoring input had zero writers. Every sport now does what MMA already did: unclassified is absent. Induced on real players. Skubal: STARTER, throws L, WHIFF + SEAM + PINPOINT, all elite. Judge: BOMBER + GRINDER + WHIFF RISK — elite power, patient, strikes out, three true things. Kwan: SURGEON + SNIPER + SLASH with NO power claimed (0.4 barrel% is absent, not "low power"). Josh Bell, who used to classify as DRIVER: empty blend, "No standout profile — league-average across every measured axis." Alan Roden, who was FLEX at weight 1.0 on 21 PA: every axis absent, "Not enough plate appearances yet — no profile claimed." Per-axis honest-absence holds: a velo-less pitcher keeps every other axis, and NO DATA is distinguishable from LEAGUE-AVERAGE rather than collapsing into one shrug. The full vector is stored for Layer 3; only the top three distinctive traits surface. Three existing tests asserted the fallback and were updated to assert absence. One of them surfaced a real robustness gap: classify(sport, null) threw, because an explicit null does not trigger a default parameter and every scorer dereferences its argument. Guarded. Every baseball name is accounted for in docs/ARCHETYPE-AXES.md — built, alias, tier, or shelved with its unlock condition. Zero orphans; cross-sport names left for their sport. Tests 3601 passed / 293 suites. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VCNgGSt5qvcLxaeQqa7Zpj	2026-07-20 22:38:32 -04:00
builtbykev	1265c23305	Tier-A joins: handedness, true role, and the velo fix ... Three Layer-2 prerequisites, each one free call. HANDEDNESS — statsapi /sports/1/players carries batSide, pitchHand AND primaryPosition for every player: 1,316/1,316 in the live probe. Batter handedness was 100% absent, which made every platoon or switch-flavour archetype unbuildable; it is now populated from the same call that gives pitchers theirs, with statsapi as the authority and the movement feed as the fallback. ROLE — statsapi season pitching with playerPool=ALL returns 751 rows (the default returns only the ~57 qualified). Real usage: gamesStarted, gamesPitched, gamesFinished, saves, holds. roleDetail derives starter/closer/setup/reliever from that instead of the season-IP proxy, which drifts all year as innings accumulate and left 32 pitchers in a 60-80 IP trough. VELO — recovered from 53% to 99% (721/729 pitchers). The movement feed carries only each pitcher's PRIMARY pitch, so matching by position could never do better than one pitch each. The wide pitch-arsenals feed has one column per pitch type, matched BY TYPE: Skubal now has velo on all 5 of his pitches. Velo archetypes are therefore buildable rather than shelved. Migration 032 applied. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VCNgGSt5qvcLxaeQqa7Zpj	2026-07-20 22:30:12 -04:00
builtbykev	a49959867d	Statcast: take the full arsenal, not each pitcher's primary pitch ... Caught by spot-checking a real row after the backfill landed: Skubal stored with one pitch. The pitch-movement endpoint with an empty pitch_type returns ONE row per pitcher — their primary offering — so 677 rows for ~700 pitchers, and a five-pitch arsenal was being recorded as a one-pitch one. Not a fabrication, but a silent under-representation of the single most important pitcher-mechanism field, which is worse than useless for Layer 2: it would have classified every pitcher as a one-pitch arm. Mix now comes from pitch-arsenal-stats (3,205 rows = pitcher x pitch type) carrying usage%, whiff%, K%, put-away% and run value per 100 for every pitch. Movement still supplies velo, break and handedness, folded onto the primary pitch; a pitcher present only in the movement feed keeps his handedness and his one measured pitch rather than being dropped. Velo on non-primary pitches is null — absent, not guessed. Skubal now stores 5 pitches, throws L, FF first by usage with velo 96.7. Tests 3583 passed / 292 suites. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VCNgGSt5qvcLxaeQqa7Zpj	2026-07-20 21:53:32 -04:00
builtbykev	a011ae79fe	Statcast: role belongs in the key (two-way players) ... Found by inducing the real job on the server, not by review: the first chunk wrote, the second failed with 'ON CONFLICT DO UPDATE command cannot affect row a second time'. A player can legitimately appear in BOTH the batter and the pitcher feeds — two-way players, position players who pitch, pitchers who bat — so (sport, season, source_id) collapsed two real profiles into one key and a single batch hit the same row twice. Ohtani has a real batter profile and a real pitcher profile. Merging them would invent one player out of two genuinely different sets of measurements, so role goes in the primary key rather than one profile winning. Migration 031 applied; conflict target updated; a two-way case is now a test. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VCNgGSt5qvcLxaeQqa7Zpj	2026-07-20 21:49:53 -04:00
builtbykev	528cb1a6d0	Layer 1: Statcast mechanism-data ingestion (backfill + nightly refresh) ... The data foundation for the archetype and projection layers, built as the pattern every sport inherits. Layers 2 and 3 are not touched. PHASE 0 GATE — both match rates measured live, both 100%. Batters 40/40; PITCHERS 66/66 across five real rosters (CLE, DET, MIN, NYY, LAD) joined by MLBAM id against the 713-pitcher Savant feed. Zero honest-absent on identity, because the join is an integer both systems use natively — and the snapshot pipeline already stores it per graded row. SOURCE — five Baseball Savant CSV leaderboards, free and public, pulled with axios and the CSV parser savantAdapter already runs in prod. pybaseball is deliberately NOT used: it is an MIT wrapper over these same URLs, and adding it would reintroduce a Python runtime in a stack where the existing Python service is already offline. min=1 on every feed, not Savant's default min=q, so the long tail arrives and OUR minimum-sample gate decides what is thin — explicit and testable rather than silently dropped upstream. Measured: 1,354 rows per season (604 batters, 750 pitchers), all five feeds in about five seconds. Pitcher mechanism includes arm angle, GB/FB/LD, chase and whiff; batters get exit velo, launch angle, barrel and hard-hit, chase and z-swing. Handedness rides in free on the movement feed (677 pitchers); batter handedness stays absent pending a roster join rather than being guessed. BACKFILL AND REFRESH ARE THE SAME CALL — a full re-pull upserted on (sport, season, source_id). Idempotent and self-healing: a missed night self-corrects on the next run, with no incremental who-played bookkeeping to drift out of sync. At 1,354 rows the simple thing is also the robust one. HONESTY RULES, each with a test: a metric the feed did not carry is null and never 0; a thin sample is STORED and flagged rather than dropped or inflated, because thin and missing are different claims; an unjoined player is stored with a null player_key and joins later; and if every feed comes back empty the job REFUSES to write, so a bad night can never blank a good table. Freshness is treated as a truth property. updated_at on every row, and the scheduler pages on a failed run AND on silent staleness — a job that stops being scheduled never produces a failure, so staleness has to alarm on its own. Never-built is deliberately not stale: different condition, different fix, and paging on a fresh install teaches the operator to ignore the alarm. Nightly at STATCAST_HOUR_UTC (default 11 UTC, after every game is final), kill switch STATCAST=0, and induce-able at POST /api/internal/statcast/refresh with a freshness probe at /statcast/status — we verify a refresh by running it, not by waiting for the slot. Migration 030 applied. Promoted columns for the classification-critical metrics plus a metrics JSONB carrying every raw field, so Layer 2 can reach something we did not promote without a re-ingest. Raw per-pitch stays out of Postgres on purpose: one season is ~0.85 GB against a 500 MB plan ceiling, and it is re-pullable from the free source if Layer 3 ever needs it. Pattern documented in docs/MECHANISM-DATA.md for NBA tracking and NFL Next Gen. Tests 3581 passed / 292 suites, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VCNgGSt5qvcLxaeQqa7Zpj	2026-07-20 21:37:30 -04:00
builtbykev	aaa41134d4	Close the second leak path: /api/hero-prop bypassed the snapshot gate ... The landing hero reads the snapshot from Redis DIRECTLY via heroPropService, so it never passed through routes/snapshot.js and was still serving model_odds, ev_pct, value and takeable to anonymous visitors after the first fix. Same strip, same tier resolution, same private-cache rule for authenticated callers; the Next proxy now forwards the bearer token. PRODUCT CONSEQUENCE, FLAGGED RATHER THAN BURIED: the landing hero is served to anonymous visitors, so it now renders BOOK and FAIR with the model leg LOCKED instead of the full triplet it showed this morning. That follows the stated free-tier rule exactly, but it does trade a strong marketing moment (VALUE +21.1% VS FAIR on the shop window) for consistency of the gate. Reversing is one line — add 'model_price' to the free tier in src/config/tiers.js, or special-case the hero route — and is a product call, not a correctness one. Tests 3557 passed / 291 suites, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VCNgGSt5qvcLxaeQqa7Zpj	2026-07-20 19:52:00 -04:00
builtbykev	fbcb00b7b1	Close the public model-price leak; wire the read card's price layer ... PHASE 0.5 GATE — the three checks, and one correction. `fairLine` does not exist. Zero hits across src/ and web/src. Option A as written had no referent, but it resolves better than feared: `fair_odds` is already a real de-vigged American price on every graded snapshot row, so there is nothing to derive. Gate 1 (is it a price): PASS. fair_odds is American odds from impliedProbToAmerican inside devigTwoWay; fair_prob is the probability. Both distinct from `line`, the stat threshold. Gate 2 (numeric match): PASS, 8/8 exact. Recomputed fair_odds and fair_prob independently from the stored raw over/under prices; every value matched the stored one to the integer and to 3dp. Same de-vig, same numbers the component was proven against. Gate 3 (poison independence): PASS, and proven on the quarantined cohort itself. devigTwoWay's inputs are (over_odds, under_odds) — market prices only, no model term is reachable. The 8 rows recomputed above are all wrong_opponent_grade rows, and their fair prices reproduce exactly from the market. The poison is in the grade, not the price. Quarantine therefore suppresses the MODEL leg only; the fair leg stands, as designed. THE LEAK WAS REAL AND ALREADY LIVE. GET /api/snapshot/:sport is public and unauthenticated, and it was serving model_odds, p_win, ev_pct, value and takeable to anonymous callers on every graded row — 25 of 25 on the live wnba board. The Session-66 gate on /api/analyze was bypassed entirely by this endpoint. The strip covers more than model_odds, because model_odds is not the only way to read the model price: p_win IS the price in another base, and ev_pct is INVERTIBLE — ev is a function of p_win and book_odds, and book_odds is public, so leaving ev behind hands the price over. All five model-derived fields go. book_odds, fair_odds, fair_prob, overround and devig_method stay on every tier: the fair leg is never the paywall. Rows that keep a book+fair pair are stamped model_price_locked so a gated price is never mistaken for a missing one. Tier comes from resolveTierFromRequest, which reads a bearer token when one is present and otherwise returns 'free'. It FAILS CLOSED on every error path, so a resolution failure can only ever withhold the price. The response now varies by entitlement, so the /:sport handler downgrades Cache-Control to private for authenticated callers and the browser proxy forwards the bearer token — otherwise a CDN could hand a paid payload to an anonymous viewer, or every request would look anonymous and paid users would lose the leg. READ CARD — a manual scan carries no market. The request is {player, stat, line, direction}, so the engine has no over/under prices to de-vig and book_odds/fair_odds are legitimately absent from its response; that is why the triplet was hidden there. lookupSnapshotPrices recovers them from the pre-graded snapshot via the same cache-only read this route already performs for locked odds and team. The join is exact on player + stat + line + side (fair_odds is side-specific), and returns nothing unless book and fair are BOTH present — a user-chosen line the board never graded has no market attached, so the triplet stays hidden rather than borrowing another line's price. FAIR-LEG ABSENCE, measured before shipping: 636 graded rows, 636 with book, 636 with fair, 0 one-sided. Absence rate 0.0%. The hero number is not a sometimes-number on current data. Tests 3556 passed / 291 suites, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VCNgGSt5qvcLxaeQqa7Zpj	2026-07-20 19:47:42 -04:00
builtbykev	8cf9cbfc26	Price-layer token foundation + the price triplet, built natively on it ... PHASE 0 finding, reported before building: the token layer this order asked me to establish ALREADY EXISTS and already matches HANDOFF.md exactly. web/src/app/globals.css :root carries the design's surfaces, borders, text ramp, fonts and grade colours byte-for-byte (aligned 2026-07-16), and lib/colorContract.js already encodes the green-is-edge-only and glow-is-A-tier-only laws with a test enforcing them. The stack is Tailwind v4 CSS-first (no config file) with components styled by inline style={{}} reading var(--x) — 1,916 such reads — so CSS custom properties are the only vehicle the stack natively consumes. Creating a second parallel layer would have meant two competing sources of truth, so this EXTENDS the existing one. PHASE 1 — additive only. globals.css gains one colour the system did not have, the priced-out blue (#8fb2de + tints), plus a tokenized A-tier glow and the fair-leg tints. The block writes the LAWS into the token layer itself — green = takeable edge only, glow = A-tier only, amber = caution + the fair leg, red = miss/negative only, blue = edge priced out, JetBrains Mono = all data — and a test asserts every newly-declared name is new (zero collisions, zero overrides). No existing hardcoded style was touched and no live surface was migrated: the diff over existing files is 149 insertions, 0 deletions. PHASE 2 — lib/valueState.js is the single verdict function; the component renders what it returns and never re-derives one. VALUE fires only on ev >= 2 AND a takeable price, mirroring src/config/valueEngine.js with a test that cross-checks both files and fails on drift. Five states: VALUE (green), EDGE-NOT-TAKEABLE (blue), NO EDGE (grey, stated at full voice), QUARANTINE (model leg withheld, book+fair stand), REFUSAL (nothing rendered). Free tier is gated at the wire — tierGating strips model_odds and sets model_price_locked, so the lock is real rather than a blur over data already sent; book and fair pass through on every tier because the fair leg is never the paywall. Wired into the landing hero (data was already on /api/hero-prop) and the read card, where the projection block reads first and the triplet sits beside it, not in place of it. Ledger and public profile are out of scope — no fair-odds columns exist there. PHASE 3 — induced all six states in a real browser and read back computed styles, not just markup. Green resolves on VALUE alone: rgb(0,212,160) on the model leg and verdict; the +11.7%-EV-at-210 row renders rgb(143,178,222) blue and a white model leg; quarantine shows MODEL "—" with book and fair intact; refusal renders no legs at all; free tier renders a lock bar with book -120 and fair -104 still honest. Landing hero on live data: book -153, fair -129, model -343, VALUE +21.1% vs fair at +28.1% EV. At a real 390px column the three legs hold at 117px each with no horizontal overflow and fair no smaller than its neighbours. Induction caught a real bug that markup review would not have: the "VS FAIR" figure compared BOOK to fair, printing "VALUE · -6.5% VS FAIR" — a contradiction on screen. The design's own two worked examples pin the formula as MODEL minus FAIR in implied-probability percentage points; modelVsFair now reproduces both exactly (+2.9 and -1.8) and a test locks them. The figure is shown only when its sign agrees with the verdict, so a row that clears the EV bar on the book price while our price sits level with fair leads with the EV instead of a number that reads as a contradiction. Tests 3539 passed / 290 suites, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VCNgGSt5qvcLxaeQqa7Zpj	2026-07-20 18:22:00 -04:00
builtbykev	f5156dd16d	Un-claim CLV on the public profile; un-fabricate player-page FORM ... Two Truth-Law fixes found by auditing the product logged-out. FIX 1 — /u/[handle] claimed a "CLV-verified record" with "closing-line value included" while ZERO closing-line value renders there. Verified live: GET /api/profiles/vyndr returns beat_close_pct null (gated behind CLV_CAPTURE_RELIABLE, unset while C4 is open). Eight instances found — two of them (the OG + portrait "CLV-VERIFIED RECORD · 30D" eyebrows) only by the post-removal residual sweep; two more printed the claim in exactly the no-record branch. Copy now describes what the page shows. The gated CLV-VERIFIED badge and the BEAT CLOSE figure are removed from the public profile, OG card and portrait card. DISPLAY ONLY: beat_close_pct, clvCaptureReliable() and the whole CLV data path are untouched, and the earned directional badge stays Analyst+Desk. The claim returns when CLV genuinely renders here. Also fixes the doubled "· VYNDR · VYNDR" title (layout's '%s · VYNDR' template already supplies the suffix); verified on composed output by serving the build and reading the real HTML, not on source. FIX 2 — the player page's FORM was `70 + 4 × (count of tonight's graded props)`. Nothing on the HTTP path ever sets stats.form, so that fallback WAS the live number: Josh Bell's "74" is 70 + 4×1 prop, confirmed against his live payload. MATCHUP was gradeFromForm(that number), with a hardcoded 'B' on the no-archetype branch — both fabricated letters with no opponent input on the path. Systemic: buildIntel is the unconditional path for every player and sport. FORM and MATCHUP now render "—" (kind 'plain', so no bar width or colour is computed off a null). gradeFromForm is deleted and the prop count is no longer passed into buildIntel. computeFormScore's hardcoded 75 now returns undefined. Induced across MLB/NBA/WNBA: all render cleanly, and real values (USAGE 3.6 AB/G, REST B2B) still render. Neither form value feeds the grade — engine1 reads raw l5_avg/l20_avg against the line and never a form key; buildIntelFields decorates the already-graded object. Grade inputs are byte-identical. Held (needs a per-sport headline-stat design call): a real player-level form metric + label disambiguation. Tests 3491 passed / 289 suites, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VCNgGSt5qvcLxaeQqa7Zpj	2026-07-20 17:05:04 -04:00
builtbykev	da8bfdf1db	Render directional-CLV badge — Analyst+Desk, server-gated, receipt-bearing ... CARD BADGE ONLY. Ticker-CLV explicitly DEFERRED (named, not lost). PHASE 1 — SERVER-SIDE GATE AT THE DATA LAYER. A Free request never RECEIVES dclv data: the CLV columns are appended to the SELECT only behind canAccess(tier,'clv_badge') (new capability, analyst+desk), and responses are ALSO stripped as defence in depth so a future SELECT change cannot quietly leak. No CSS/client gate — data that reaches the browser has left the building. dclv_fair_lock/fair_close are de-vig internals and are never sent at all. SURFACE AUDIT, all six channels, each test-locked to contain no CLV: public profile (share link), snapshot/card feed, ticker feed, share card/OG, embeddable widget, newsletter. A test also asserts no ledger_entries read uses select('*') — a star would auto-leak every new column, which is exactly how a gate becomes theatre. PHASE 2 — IMMUTABLE ONCE COMPUTED. A settle can re-run (stat correction, protested game) and a badge that flips positive->negative AFTER a user saw or screenshotted it is a credibility failure. First computation wins: dclv is only computed when dclv_computed_at is null, so a re-settle can never rewrite a shown badge. Same discipline as the locked grade. PHASE 3 — RENDER, test-first, ABSENCE IS HONEST. unknown / flat / null / missing-receipt all render NOTHING — no element, no placeholder, no "pending". Proven on an ALL-NULL board (today: 0 badges) and a MIXED board (tomorrow: 1 of 4 badged, badge-less cards clean). Binary states only: positive -> MOVED TOWARD US "graded -110 · closed -145" negative -> MOVED AWAY "graded -110 · closed +120" The RECEIPT is the persuasive part, so a badge with no numbers is suppressed rather than shown as a bare claim. Negative is neutral context and NEVER touches the locked grade — no back-door re-grading. NO aggregate, count or rollup exists by construction: the module exports exactly {clvBadge, fmtPrice} and a badge payload carries exactly {tone,label,receipt} — asserted by test, because an on-screen tally would be the held aggregate claim through the side door. Build gotcha hit and fixed: clvBadge is CommonJS (allowJs) with no TS types, so the .tsx needed an explicit cast at the call site — the build worker exits 1 on type errors even though compilation "succeeds". Suite 288/3473 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 13:37:52 -04:00
builtbykev	dcdad60896	Directional CLV — per-read signal, side-bound, with a real compute trigger ... PER-READ ONLY. No aggregate CLV stat, no CLV marketing un-held. PHASE 0 FINDING THAT SHAPED THE BUILD: the LOCK end must come from model_snapshots, NOT ledger_entries. The ledger stores only the graded side's locked_odds (694 rows, single-side) which CANNOT be de-vigged. model_snapshots retains BOTH side prices on 520/520 graded rows AND an already-de-vigged fair_prob on 520/520 — produced by the same devig.devigTwoWay the close uses, so "same method both ends" holds by construction rather than by convention. THE COMPUTE TRIGGER is the SETTLE PASS (ledgerService.settleLedger). At settle the game is final, so the close has landed and the read is final — the only moment both ends of the comparison exist. Grade and locked prices are written hours earlier and the close at lock, so without this trigger a correct CLV function would simply never populate. JOIN INHERITS THE PROVEN KEY: (sport, player_key, stat, side, game_date), WITHOUT line — a close that moved off the graded line is the entire point. Verified clean earlier: 164 identity groups, zero ambiguity. Rows whose capture refused (missed/ambiguous/one-sided) are UNKNOWN for CLV, matching the capture layer's own honesty. SIGN IS SIDE-BOUND and proven by test before the logic existed — the badge-inverting trap. Same market move: OVER-graded -> positive clv +0.0800 (fair .500 -> .580) UNDER-graded -> negative clv -0.0800 (fair .500 -> .420) exact mirrors. FLAT is a PROBABILITY-space threshold always (1.5pp): a 40-cent price move on a deep favourite reads flat, correctly, because price space lies about magnitude. UNKNOWN is a first-class state, never 0 — zero asserts "the market did not move", which is a claim; a missing close asserts nothing. describe() returns null for unknown so a badge can never render for it. migration 030 adds dclv/dclv_state/dclv_fair_lock/dclv_fair_close/ dclv_computed_at as NEW columns rather than reusing the C4 clv fields — conflating a verified per-read signal with a known-broken one would be the worst kind of quiet lie. Caught pre-deploy: the trigger call passed `deps`, which is not in scope in settleLedger (it uses `opts`) — a ReferenceError at the call site, outside the helper's try/catch, which broke two settlement suites. Suite 286/3447 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 13:17:34 -04:00
builtbykev	63302d194e	Wire MLB opp_rank_stat into live features (consumption path verified) ... featureCache.teamFeatures now derives MLB opp_rank_stat from statsapi team pitching splits when the ESPN path yields nothing — which for MLB is always, because ESPN's MLB team endpoint carries no defensive metric at all. mlbStatsAdapter.getTeamPitchingStats fetches all 30 teams in one free unauthenticated call, cached at the season TTL. CONSUMPTION PATH VERIFIED before wiring, not assumed: featureCache.teamFeatures sets out.opp_rank_stat (line 338) -> engine1.computeFactors READS features.opp_rank_stat (lines 96-102) -> fires weak_opponent_defense (>=0.70) / top_opponent_defense (<=0.30) So teamFeatures is the correct insertion point: the grader reads exactly the field we populate. A value written anywhere else would have been a dead end — computed, retained, and still not affecting the grade. Contract preserved: the derived value goes into the SAME field with the SAME 0-1 scale and the SAME high=weak polarity WNBA uses, so engine1 reads one field with one meaning across sports. Isolated and best-effort — a derivation failure leaves the field ABSENT (honest null), never a guessed rank. Only fills when the ESPN path produced nothing, so WNBA behaviour is untouched. Suite 285/3435 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 12:49:13 -04:00
builtbykev	55157b3288	Close-capture retry (lock-walled) + MLB opp_rank_stat derivation ... PHASE 1 — CLOSE-CAPTURE RETRY, test-first. The closing capture gets a retry the snapshot path deliberately does not: a snapshot re-runs at the next slot, but a MISSED CLOSE IS PERMANENT, and the feed flaked once on a dry induce. Three hard rules, each driven by a test written before the logic: - BOUNDED attempts (default 3) with short backoff so every attempt fits inside the window. Never infinite. - HARD LOCK-WALL: inside lockWallMinutes of first pitch (or past it) it stops and records missed_close. A price captured AT or AFTER lock is NOT a close; storing one would fabricate the CLV baseline. - NO BOUND LOCK TIME -> refuse immediately, never burn retries on a prop whose close cannot be timed. On exhaustion it records missed_close with NO price — never a stale, mid-day or post-lock line. PHASE 3 — MLB opp_rank_stat DERIVED, contract-locked. MLB previously had no opponent metric at all (ESPN's MLB team endpoint carries none), so engine1's +/-1.0 opponent factor never fired for the sport carrying most of our volume. Derived from data we already ingest: statsapi team pitching splits, all 30 teams in ONE free unauthenticated call. THE SHARED CONTRACT is documented and TESTED, not assumed: 0-1 scale, HIGH (>=0.70) = WEAK opponent, LOW (<=0.30) = TOUGH — identical to WNBA's live semantics. Polarity is the highest-risk part: backwards polarity does not fail loudly, it silently adjusts every MLB grade the wrong way. A test asserts MLB polarity EQUALS WNBA polarity using engine1's own thresholds. PROVEN AGAINST THE LIVE FEED: Colorado Rockies BAA .286 -> opp_rank 0.983 (weak, fires weak_opponent) LA Dodgers BAA .215 -> opp_rank 0.017 (tough, fires top_opponent) POLARITY HOLDS: true HONEST NULLS, tested: thin league baseline, thin opponent sample, unmapped stat, unknown opponent, or a missing field all return NULL with a reason — we are FIXING a silent null, so it is never replaced by a confident guess off three games. opponentStrengthHealth pages on an empty source AND on derived-null-for-a-sport-we-expect-to-derive. Suite 285/3435 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 12:27:47 -04:00
builtbykev	77a58e4113	Arm harness on our scheduler + start closing-line capture (capture only) ... PART A — HARNESS ARMED ON OUR OWN INFRA. snapshotScheduler now runs the nightly backtest at HARNESS_HOUR_UTC (default 14), appends to harness_results, and pages via opsWatch.harnessStaleAlarm — a validator that stops running looks exactly like one that keeps passing. No external dependency: the join is plain SQL through the service client and the harness is a pure function. POST /api/internal/harness/run induces the same code path on demand, because a scheduled mechanism is verified by inducing it, never by waiting for a slot. PART B PHASE 0 — GATE PASSED for what is capturable: - C4 diagnosed: closing_line is ONE overwritable field with no timestamp and no provenance. captureClosing writes the current line and, when a prop fails to match, silently leaves the earlier value (= the lock) in place — so "captured a real close" is indistinguishable from "never updated". It is 92% equal, not 100%: 56 rows DID record movement, so the defect is provenance, not the value. - Feeds: normalized props already carry BOTH raw side prices per book, with game_time, and the intraday refresh polls every ~20 min during slate hours — so the last observable pre-lock line is available. - SHARP close: pinnacle is in ALLOWED_BOOKS -> a no-vig reference is capturable ("beat the market"). - ODAWA: NOT capturable. 'odawa' exists only as a UI preference option in onboarding/settings; it is in no adapter, no ALLOWED_BOOKS, no feed. An un-capturable source is a finding, not a gap to paper over. - JOIN: must drop `line` from the natural key, because a close that MOVED off the graded line is the entire point of CLV. Verified safe — all 164 current identity groups have exactly ONE line per (sport, player_key, stat, side, game_date). Zero ambiguity. PART B PHASE 1 — CAPTURE ONLY, built test-first. The refusal was proven before the capture logic existed: unbound game_time, doubleheader ambiguity, a missed pre-lock window, or a one-sided price all record missed_reason with NO price. A stale or mid-day line substituted for a close would manufacture a CLV proof from a number that was never the close. migration 029 closing_captures: append-only, never overwritten (that is the provenance C4 lacked), BOTH raw side prices so the existing de-vig engine can compute a fair closing probability later, sharp vs book line types kept distinct. Wired into the intraday refresh with a capture-rate alarm — a missed close is unrecoverable. NO CLV metric built, as ordered. This starts the clock. Suite 284/3417 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 12:05:16 -04:00
builtbykev	e809a0eb3c	Backtest harness — the validator, built refusal-first ... Phase 0 gate PASSED: the join is clean. No FK exists; the natural key (sport, player_key, stat, line, side, game_date) yields 283 clean 1:1 joins with ZERO ambiguity. game_id is NOT usable — 400/550 snapshot rows carry UNK@UNK because home/away names weren't threaded into the grader until Order 1.6. Non-joining rows are EXPECTED, not errors: retention stores both sides plus refusals; the ledger keeps only the graded side. Outcomes are NOT denormalized — ledger_entries stays the source of truth. BUILT TEST-FIRST, and the first property proven is the REFUSAL, not the math. Below threshold the harness emits INSUFFICIENT with n and the shortfall and NO rate anywhere in the payload, so a downstream renderer cannot surface one by accident. A test asserts the payload contains no hit_rate number at all. - Wilson intervals (correct at the n we actually have, unlike the normal approximation which emits negative lower bounds). - Strata NEVER mix sport or model_version. - Denominator excludes quarantined, void, unrecoverable, pending, push — asserted by test. - Monotonicity refuses to RANK buckets whose intervals overlap; it reports "not distinguishable on this sample". - Probability calibration (Brier + reliability) also respects the threshold: a thin sample returns status INSUFFICIENT and a NULL score. - Replay seam reads the STORED feature vector only. A row whose input was never retained is UN-BACKTESTABLE, never scored with substituted current data. Identity replay reproduces the live prediction exactly. The tests caught a real bug in my own code: `Number(null) === 0` let a null p_win through as a confident 0% forecast — this codebase's signature fabrication bug, inside the harness whose entire purpose is refusing invented numbers. Fixed with a strict null guard. FIRST LIVE RUN — the correct, passing output: VERDICT: INSUFFICIENT_HISTORY (can_validate=false) 283 joined -> 35 scored (120 quarantined, 124 pending, 4 terminal) C n=18 (short by 2), B n=17 (short by 3) strata: mlb 7, wnba 28 — never mixed migration 028 adds harness_results (append-only trend log; INSUFFICIENT rows are expected and correct) and opsWatch.harnessStaleAlarm pages if the harness stops running — a validator that isn't running looks exactly like one that keeps passing. Suite 283/3403 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 11:31:48 -04:00
builtbykev	b33612675d	Heal execute: quarantine markers, re-enable DNP voiding, two exclusion scopes ... Order 2 Phases 2 + 4. Pre-heal rollback point secured first: vyndr-20260720-093821.dump (856,890 bytes) VERIFIED ON THE BOX, not just exit 0. MIGRATION 027 — two DISTINCT exclusion scopes, deliberately separate: - quarantine_reason: the row's GRADE is untrustworthy (wrong_opponent_grade). The row REMAINS a real public settled result — the bet happened, the outcome is real — but it must never train or validate, so getModelAggregate now excludes it from the denominator alongside void/unrecoverable. - analysis_flags: the row is VALID for settlement and the record but unattributable for PER-GAME analysis (doubleheader dates). Explicitly NOT filtered from aggregates. Collapsing these would either wrongly drop 166 doubleheader rows from the record or wrongly keep 25 wrong-opponent grades inside model validation. Tests assert both directions, including that analysis_flags is NOT filtered. Also adds re_settled_at + settlement_source to model_snapshots. DNP VOIDING RE-ENABLED — reversing my own Order 1.5 disable, with scrutiny, because its premise was FALSE. Order 1.5 assumed a missing player row meant the row's DATE was wrong. The Phase 0 dry-run disproved it: across every bindable row the stored date matched a real game (MIS-DATED: 0), and the players I had cited as counter-evidence were genuine DNPs on their true dates (Freeman 07-18; Kwan/Hedges/Davis 07-17 — their teams played, they did not). The evidence is positive: games FINAL + no line in a full-season log = no bet existed. I got this wrong twice tonight in opposite directions; the dry-run is what caught it. Recording the reasoning in the code so the next reader sees why the flag flipped back. Suite 282/3386 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 05:41:41 -04:00
builtbykev	6415751f2e	Grading binds opponent features to the REAL game, not ESPN's "today" ... Order 1.6 Phase 1. This is a MODEL-OUTPUT fix, not bookkeeping. computeFeatures.lookupTodayGame called the ESPN scoreboard with NO date param and took whatever ESPN calls "today". Renamed to lookupGameOnDate and now sends ?dates=YYYYMMDD from the prop's BOUND game — the same game the ledger, retention and settlement use, so all four finally agree. PROVEN against live ESPN (before/after, same instant): dateless "today" CLE->PIT NYY->LAD LAD->NYY (Jul 19 card) bound to 2026-07-20 CLE->MIN NYY->PIT LAD->PHI (the real games) bound to 2026-07-19 CLE->PIT NYY->LAD LAD->NYY (reproduces OLD) Every opponent was wrong. opponentAbbr feeds opp_rank_stat (a +/-1.0 factor) and isHome feeds home_away (+0.5), so late-slot grades were scored against the wrong matchup. Note the window is WIDER than the 01:00/03:00 UTC slots: this ran at 07:5x UTC = 03:5x ET and ESPN's dateless scoreboard was STILL returning the previous day's card. HONEST DEGRADATION: with no bound game date the grader does NOT fall back to a dateless lookup — it records 'no_bound_game_date' and leaves opponentAbbr/isHome/gameId null, so engine1 simply omits the opponent and home/away factors rather than scoring a wrong matchup. Tests assert both directions. Same class of bug fixed alongside: the Tank01 augmentation used TODAY's UTC date for its cache key; it now uses the bound game date. gradeSlateService threads game_date/game_time/home_team/away_team into the grader so the binding reaches computeFeatures at all. Audited the rest of the feature path for dateless/"today" lookups — none remain (weather is current-conditions by venue, park/pace are static). Suite 282/3383 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 03:50:07 -04:00
builtbykev	1bcdd8b305	Fix the ROOT: bind props to their real game, never date by the grade clock ... Order 1.5 Phase 1. PropLine emits NO commence_time (grep-verified: zero hits in proplineAdapter), so ledgerService's `dateET(prop.game_time) || dateET(gradedTs)` always fell through to the GRADE timestamp — and a 01:00/03:00 UTC snapshot is 21:00/23:00 ET the PREVIOUS day. Tonight's props were filed under yesterday, settlement correctly found no game there, and Order 1's void logic turned that into 64 destroyed results. gameBinder.attachGameTimes() now matches every prop to a scheduled game by TEAMS across the plausible ET window (grade date, +1, -1) and attaches the GAME'S OWN time/date/id. It runs in snapshotService before grading and before the ledger write, so ledger, retention and settlement all inherit the correct date from one place. HARD CONTRACT: an unbindable prop returns NOTHING. ledgerService no longer has a grade-clock fallback — a row with no real game time is SKIPPED and counted, because a mis-dated row is fabricated data and the ledger holds real values or nothing. A slate that binds nothing pages. DOUBLEHEADERS are reported, never guessed: two games with the same teams on one date mark the binding `ambiguous` so settlement can decline rather than attribute a prop to the wrong game. (Real example already in the data: mlb:2026-07-11:MilwaukeeBrewers@PittsburghPirates(Game1).) Also fixes retention, which had the SAME bug from last night — I had dated model_snapshots rows with the snapshot clock. Rows now take the ET date of the bound game_time. Suite 282/3381 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 03:25:01 -04:00
builtbykev	270c4db47a	STOP voiding on player-absence — it destroyed real results ... Correctness fix to code I shipped minutes ago. The induced live settle pass voided 64 rows as 'player_dnp' and a large share of them are WRONG: the Jul 18 set is everyday starters (Freeman, Bellinger, Tucker, Chisholm, Conforto). They played. ROOT CAUSE — and my Phase 0 diagnosis was wrong. It is not DNP. The ledger row's game_date is WRONG. ledgerService derives game_date from the GRADE timestamp when the feed carries no game_time, and a 01:00/03:00 UTC snapshot is 21:00/23:00 ET the PREVIOUS day, so rows get labelled with the previous ET date. Verified against fresh season logs (cache disabled, so not staleness; found:true, so not name resolution): Freddie Freeman played Jul 17 and Jul 19 (x2, doubleheader) — NOT Jul 18 Steven Kwan played Jul 18 (x2) and Jul 19 — NOT Jul 17 Settlement was correct to find no game on the labelled date. My void logic then converted a data-labelling bug into destroyed results. FIX: never void on player-absence alone. Voiding now requires POSITIVE evidence — the games themselves postponed/cancelled. Absence returns 'unknown' (reason player_absent_unconfirmed), so the row retries and ages out to 'unrecoverable' at the cap. We cannot distinguish "did not play" from "mislabelled date", so we must not claim DNP. Both terminal states are excluded from the record denominator either way. Window-decay remains genuinely fixed (full season log vs a rolling window), and terminal states still prevent immortal rows. NOT DONE HERE: the 64 wrong voids are still in the table, and the game_date derivation is still wrong at the source. Both are reported for the table — no healing in this order. Suite green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 03:10:34 -04:00
builtbykev	d4a6170ffa	Settlement fix forward: date-targeted resolution + terminal states ... Order 1 of 2. Push scoring UNTOUCHED — it is correct. No healing here. PHASE 1 — DATE-TARGETED FETCH replaces the rolling window for settlement. settleSource.resolveOutcome() resolves the SPECIFIC DATE and, when the player is absent, reads GAME STATE to learn what the absence MEANS: game final + player has a line -> SETTLE (a partial game is a real result, never a void) game final + player absent -> VOID (confirmed DNP) postponed / cancelled -> VOID scheduled / in progress / SUSPENDED -> PENDING (a suspended game resumes; voiding it would destroy a real bet) player played, stat missing -> unknown, NEVER void a real appearance This is FREE for MLB: mlbStatsAdapter.getPlayerGameLog already returned the full season log and getPlayerStats was discarding it with .slice(-10). Settlement now reads fullLog — same request, same cache — which removes window-decay entirely (the verified failure was a Jul 12 game outside a last10 starting Jul 6). Projections keep using last10, unchanged. PHASE 2 — TERMINAL STATES (migration 026 applied). outcome CHECK widened to hit/miss/push/void/unrecoverable; added settle_attempts, settlement_source, settlement_version, model_version. A row that cannot be resolved after SETTLE_ATTEMPT_CAP (4) date-targeted attempts becomes 'unrecoverable' rather than pending forever. CRITICAL: getModelAggregate now EXCLUDES void and unrecoverable from the settled selection — it used .not('outcome','is',null), so without this a void would have counted as a settled row and silently moved the public record. Verified in the record calc, not just the settle path. PHASE 3 — SETTLEMENT-RATE ALARM. zeroSettleAlarm only caught a TOTAL zero while ~30% of a slate failed quietly (Jul 17: 57/86). opsWatch .settlementRateAlarm pages when resolved/attempted falls below SETTLE_RATE_FLOOR (0.8). Voids count as RESOLVED — a void is a legitimate terminal state — so healthy voiding never pages. Third silent-failure surface of the night, now closed. PHASE 4 — VERSION STAMPING. src/config/modelEras.js defines the cutoff ONCE (2026-07-19T22:50:00Z); migration 026 backfilled pre-cutoff rows as 'pre-retention-unknown' (naming the uncertainty, not implying knowledge); new rows carry model_version. Regression caught pre-deploy: getScheduleFn was not injectable, so the ledger suite hit the real network and HUNG. Now injectable via opts and a no-op under NODE_ENV=test. The "no row -> pending" test was updated to the new behaviour deliberately: a missing row on a FINAL game now voids. Suite 281/3373 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 03:04:55 -04:00
builtbykev	5a5e37e32e	Retention: fill enrichment fields + page on a zero-write slot ... PHASE 1 — cron capture needed NO wiring. Verified in code: the scheduler tick calls runAll = snapshotService.runAllSnapshots, which loops runSnapshot per sport, which already carries the onGraded -> retention hook. The scheduled path and the manual path are the SAME function. The reason no cron cycle had been captured is simply that no slot has fired since retention deployed (slots are 14/19/22/1/3 UTC; retention landed ~02:55). Induced proof follows the deploy. PHASE 2 — archetype/team/opponent were permanently null because retention persisted at GRADE time, before enrichment attaches them. Retention still COLLECTS at grade time (the only moment the feature vector exists) but now PERSISTS after enrichment, merging those three fields via retentionService.mergeEnrichment. The merge is pure and fills ONLY those three fields — features and every model output are grade-time values and must never be rewritten by enrichment; a test asserts that. Unmatched rows (refusals not in the enriched slate) keep nulls rather than guesses. The empty-slate early return now persists too: a refusal-only slate is still history worth keeping. PHASE 3 — ZERO-WRITE ALARM. opsWatch.retentionZeroWriteAlarm pages at missed-snapshot severity when a slot GRADED props but retention wrote fewer rows than the slate (or nothing). runSnapshot now returns retentionRows so the scheduler can evaluate it. Retention is best-effort by design so it can never break a snapshot — which means a broken write is silent by construction. This is the counterweight. A slot that graded nothing never false-pages; an absent count reads as NOTHING and still pages, distinct from a reported 0. Suite 280/3349 green, build exit 0. Outcome stamping deliberately NOT implemented (depends on the settlement fix). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 02:00:40 -04:00
builtbykev	2bfae804da	Verify off-box presence by reading the remote dir back ... Exit 0 from the backup script is deliberately tied to ON-BOX durability, so it is not proof the off-box copy landed. GET /api/internal/backup/offbox runs rsync --list-only against BACKUP_REMOTE using the SAME pinned known_hosts as the push (checking never disabled) and returns the dumps actually present, with size and timestamp — so off-box presence is a verified fact rather than an inference from an exit code. Needed because the dev box cannot authenticate to the Storage Box: the authorized key installed there is Kev's ~/vyndr-backup-key, not the keypair generated in-session, so independent verification has to run from the container that does hold working credentials. Suite 280/3338 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 01:14:38 -04:00
builtbykev	c4c9b97604	Off-box backup: pin the host key, guarantee the remote dir, page on failure ... PHASE 1 — HOST KEY STATICALLY PINNED. ssh-keyscan -p 23 returned an ED25519 key whose fingerprint EQUALS the out-of-band value SHA256:XqONwb1S0zuj5A1CDxpOSuD2hnAArV1A3wKY7Z3sdgM, so it is safe to pin. scripts/storagebox_known_hosts now carries that verified line and ships to the container (Dockerfile already COPYs scripts/). backup-db.sh uses StrictHostKeyChecking=yes + UserKnownHostsFile=<pin> instead of accept-new, which was trust-on-first-use and would have accepted an impostor on the very first run. A missing pin file REFUSES the push rather than silently falling back. Never weakened to accept-new/=no//dev/null — a test asserts that on executable lines. PHASE 1b — REMOTE DIR GUARANTEED. The box has only .ssh/, and rsyncing a file into a missing parent either fails or silently writes the dump AS the directory name — one file, overwritten nightly, reading as "backups exist" while retaining exactly one. Uses rsync --mkpath when available, else an explicit remote mkdir -p ahead of the push. PHASE 2b — FAILED OFF-BOX PUSH IS NOW LOUD. Off-box is required, so the failed-push path pages at "urgent" (was "low"/deferred) and the script emits a machine-readable OFFBOX_OK=1/0/deferred that POST /api/internal/backup/run surfaces as a distinct offbox_ok field. Exit code deliberately still reflects ON-BOX durability — a good on-box dump must not raise a false total-failure alarm. Surfacing the truth, not manufacturing a failure. No key material is echoed anywhere; only the PUBLIC host key is committed. Suite 280/3338 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-20 01:10:23 -04:00
builtbykev	d3ffa1b8c2	Retention: model_snapshots live + base64 SSH key support ... RETENTION (Phase 2, priority zero). History starts compounding tonight. migration 025 model_snapshots — APPLIED to prod. Append-only, one row per graded prop PER SIDE PER CYCLE, with a unique index on (snapshot_id, player_key, stat, line, side) so a retried cycle cannot duplicate. RLS on, service-role writes only. What it captures that the ledger never did: - features jsonb — the model's INPUTS. Without these a backtest can only grade our own homework; with them any future model can be replayed against the exact conditions this one faced. - REFUSALS (refused + refusal_reason). The ledger drops them, so a gate refusing props that would have WON is invisible — unmeasurable lost edge. Captured via a new onGraded hook in gradeSlateService that fires with BOTH sides before any filtering. - grade_11, the pre-collapse grade. The 4-letter map throws away the entire live C-/C/C+/B- range. - model_version + code_sha on every row. ledger_entries mixes pre/post-fix grades with no marker and cannot be separated retroactively. - p_win / ev_pct / fair_odds / takeable / value — none of which any permanent store held. Wiring: analyzeViaEngine1 attaches _features/_grade_11 (underscore = internal); gradeSlateService fires onGraded then STRIPS them so they never reach a cache or API payload; snapshotService builds rows and persists best-effort. Retention reuses the LEDGER's dateET/gameIdFor helpers so rows share the ledger's natural key exactly — otherwise the settle pass could never join outcomes onto them. Rows are written BEFORE the empty- slate early return: a slate that refused everything is exactly the case worth recording. CONTRACT HELD: retention is injectable and every path is caught. persist() returns errors, never throws; a missing Supabase client is SKIPPED, not an error. A retention failure can never break a snapshot. BACKUP: backup-db.sh now accepts BACKUP_SSH_KEY as base64 (recommended — survives env-var newline mangling, which is how injected SSH keys usually break silently) OR raw PEM, detected by decoding and looking for the PEM header. Verified both forms detect correctly against a real generated key. Suite 279/3325 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-19 23:01:12 -04:00
builtbykev	97e4dc72d5	Backup: chown /app/backups in image + report uid/writability ... The real backup run failed: pg_dump could not write to /app/backups — 'Permission denied'. Cause: the container runs as the non-root 'vyndr' user (Dockerfile USER vyndr) and the Coolify-mounted volume is root-owned, so the mount is present but unwritable. - Dockerfile now creates AND chowns /app/backups to vyndr alongside the existing /app/data + /app/.pm2 line. Docker seeds ownership into a NAMED volume on first creation, so this fixes it for a fresh volume; a host bind-mount still needs a host-side chown, which is why the next change exists. - GET /api/internal/backup/verify now reports process uid/gid, backup_dir_writable and the access errno, so the exact chown target is observable instead of guessed. A mounted-but-unwritable volume reads as 'configured' everywhere else — this makes it loud. Suite 278/3310 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-19 22:30:37 -04:00
builtbykev	ef7f17610f	Backup: durable on-box volume, off-box DEFERRED, and a real read-back check ... BACKUP_DIR is now a persistent volume (/app/backups), so the dump already survives redeploys — the container-ephemeral risk that made this urgent is closed. Storage Box SSH auth is not sorted yet, so the off-box push is explicitly DEFERRED rather than failing: - gated on BACKUP_OFFBOX=1 (plus BACKUP_REMOTE and BACKUP_SSH_KEY); until then the script logs "off-box push DEFERRED" and exits clean. - if an enabled push DOES fail, it is a LOW-priority "deferred" notice, not a failure — the durable on-box dump succeeded, and calling that an incident would train us to ignore backup alerts. Adds the read-back check, because a backup nobody has read is a hope: countRowsInDump() runs `pg_restore --data-only --table=X -f -` and counts the rows between `FROM stdin;` and the terminating `\.`, proving the archive CONTAINS the data rather than merely parsing. Needs no Postgres server, so it runs inside the API container. Validated against a real pg_dump from a scratch Postgres: counted exactly 604 rows. GET /api/internal/backup/verify exposes it (newest dump in BACKUP_DIR, size, table, rows_in_dump). Unit tests inject spawn/fs so CI needs neither docker nor pg_restore. Suite 278/3310 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-19 22:27:58 -04:00
builtbykev	40aba37f83	Backup: env-injected SSH key, nightly off-box push, triggerable run ... Closing the backup for real. Three changes, each fixing something that would have made the Storage Box target fail or silently rot. 1. SSH KEY COMES FROM ENV, not from the container. Generating a keypair inside the API container was the obvious move and it is wrong: the container filesystem is ephemeral, so the key dies on the next redeploy and the off-box push starts failing silently. backup-db.sh now reads BACKUP_SSH_KEY (a Coolify secret), writes it to a 0600 temp file per run, and removes it on exit via trap. 2. PORT 23, verified live. Hetzner Storage Box runs full OpenSSH on 23; port 22 answers with mod_sftp (SFTP only). Banner-checked both against u635423.your-storagebox.de. rsync now uses -e "ssh -p ${BACKUP_SSH_PORT:-23} ... -i <key>"; the old invocation had no -e at all and would have gone to 22. 3. OFF-BOX PUSH IS NIGHTLY, not Sundays-only. A weekly push meant up to six days of dumps existed ONLY inside an ephemeral container, which is the same as not existing. Alert copy updated to say exactly that when the push fails or is skipped. Also adds POST /api/internal/backup/run (internal-key gated) so a real backup can be TRIGGERED and OBSERVED — it returns exit code, duration, output tail, and whether the remote + ssh key are configured. The backup can only run where SUPABASE_DB_URL and the Supabase route live (this container), and there was no way to fire or inspect it without a shell. Connectivity established this session: Storage Box reachable from the dev box on 22/23; Supabase :5432 NOT reachable from WSL2 (so the dump must run in-container, as designed); docker IS available locally, so the restore-verify can run against a scratch Postgres using the real dump. Suite 278/3305 green, build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-19 21:42:27 -04:00
builtbykev	26b276fbfb	Fix the ESPN team-stats parser + report: opponent rank is still underivable ... Ran the manual regrade with the internal key (thanks). Results are mixed and the honest half matters more. CONFIRMED WORKING — the probability layer is fully alive in production. After POST /api/internal/snapshot/{mlb,wnba}: p_win, ev_pct, model_odds and value are present on 32/32 live grades (mlb 7/7, wnba 25/25), up from 0/8 before. That fix is done. NOT WORKING — the grade-range half did not land, and I am not going to claim it did. The live distribution is unchanged (wnba B17/C8 before AND after; mlb B4/C3), no A, no D, same four confidence values. Diagnosis: matchup_grade is 0/25 on the live board, i.e. opp_rank_stat is still null, so engine1's +/-1.0 opponent factor still never fires and the ceiling is still +3.0 against the +4.5 an A requires. Two distinct causes, both verified against the live ESPN feed: 1. refreshTeamStats CRASHED on every team — "buckets is not iterable", captured 0 / errored 15. ESPN's current shape is results.stats = an OBJECT with categories[], not an array. The old parser did for...of on it. This was invisible until S63 gave the function its first production caller. FIXED here (now captured 15 / errored 0) with a regression test covering the current shape, the legacy array shape, and empty payloads. 2. Even parsed correctly, the endpoint does not carry a defensive-strength metric at all: defensive_rating, opponent_ppg, pace and opponent_fg_pct all normalize to null — it returns only a team's OWN stats. So defensive_rank_normalized cannot be computed and opp_rank_stat remains underivable from this source. A test documents the gap and will fail if that ever changes. Consequence: A STILL DOES NOT EMIT, so the A-RATED marketing hold STAYS. Reviving the opponent factor needs a different derivation (opponent points allowed from scoreboard/schedule, or a different ESPN endpoint) — logged as the concrete next item, not hand-waved as done. Suite 278/3305 green. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-19 20:31:15 -04:00
builtbykev	b742230d94	Phase 1: ship the backup cron as CODE + a manual regrade trigger ... FOUNDATION-FIRST re-order, phase 1 (tooling + safety). BACKUP (highest-severity open item) — INSTALLED, not re-proven. src/backupScheduler.js runs scripts/backup-db.sh nightly from inside the API container, armed at boot in server.js. The container already has SUPABASE_DB_URL, pg_dump and the Supabase route, so deploy == installed: no host crontab, no Coolify click. Arming is deliberately opt-OUT (armed whenever SUPABASE_DB_URL exists; BACKUP_CRON=0 kills it) because the S62 design was opt-in and nobody ever opted in — the DB went unbacked every night for weeks. A failed run pages high-priority ntfy; silence is the danger with backups. Durability is the one part still needing a human: the container FS is ephemeral, so a dump dies on redeploy unless BACKUP_REMOTE (off-box rsync) or BACKUP_DIR (persistent volume) is set. The scheduler detects that and pages a WARNING at boot rather than letting an undurable backup read as "backed up". Runbook rewritten to lead with the code path. MANUAL REGRADE TRIGGER — scripts/run-snapshot.js, runnable via docker exec with no VYNDR_INTERNAL_KEY and no new HTTP surface. Runs the SAME snapshotService.runSnapshot the cron runs (including the team-stats refresh that powers opp_rank_stat), supports `all` and `--settle`, and prints the grade/confidence distribution plus p_win/ev_pct presence — which is the thing you actually want when verifying a grading change. ACCESS BLOCKER, logged honestly in specs/model-train.md: there is no VYNDR_INTERNAL_KEY in the local .env and SSH to the box times out from WSL2, so I can neither curl the internal endpoints (which already exist from S45) nor docker exec. The trigger is built and correct but only Kev can run it until a key or SSH access exists. This is the highest-leverage unblock for phases 2 and 3, which both need on-demand regrade+settle to verify anything. Also logged the standing cautions: CLV ledger stays private until backtest-proven; "self-improving model" is unsupported marketing until the loop closes; the engine is MLB/WNBA-calibrated and NFL/NBA/soccer need their own calibration before the hub grades them (scaling gate). Suite 277/3300 green. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-19 19:28:15 -04:00
builtbykev	1a94ef5fcf	Revive the dead probability layer + restore grade range ON MERIT ... Folds re-sequenced steps 1+2 into one change (Kev's call): same bug family — features wired to sources that return null. THE PROBABILITY LAYER WAS DEAD IN PRODUCTION. p_win/ev_pct/kelly/ model_odds/value were absent on 0/8 live grades because gameLogService.getGameLogs returns null for MLB by construction and depends on the offline Python service for NBA/WNBA, so meta.gameLogs was [] for every sport. This was the S46 bug in a second location — that fix gave featureCache an MLB branch (why grades still worked) but never the estimator. featureCache.getStatRows now supplies normalized rows ([{date,[statType]:v}], most-recent-first) for every sport, feeding the estimator AND consistency AND game_count_in_7d from one fetch. VERIFIED on real props: p_win 25/25 WNBA, 8/8 MLB (was 0). GRADE RANGE, ON MERIT — never by rescaling (permanent founder ruling: minting A's without new information is a relabelled B sold as an A and corrupts an append-only ledger). - refreshTeamStats wired into runSnapshot — it had ZERO production callers, so opp_rank_stat was permanently null and a +/-1.0 factor could never fire. Test-env no-op (opsNotify precedent). - L20 made SYMMETRIC: both branches were delta +1.0, so the season baseline could only ever ADD. No negative path was a structural reason D was unreachable. New l20_contradicts_* carries -1.0. - game_count_in_7d derived from real logged dates (heavy_workload_7d). - NOT wired, deliberately, with reasons inline: teamId (no team_id column; getFeatures reads it top-level; factor also needs a starter-id list) and season_type (ESPN 2 = REGULAR season; threading it raw would fire veteran_in_playoffs in July). Dead code dressed as a fix is the thing we are removing, not adding. CALIBRATION GUARD (found by verifying, not assuming): consistency CV is NBA-tuned; for a Poisson-ish stat cv ~ 1/sqrt(mean), so any stat with mean < 4 auto-classifies boom_bust. First verification run showed 8/8 MLB props boom_bust — a blanket -1.0 that dropped the board to all-C. Floored at CONSISTENCY_MIN_MEAN=4 -> 'unknown' below. Absent beats wrong. MLB low-count stats therefore still get no consistency factor: honest, not fixed. Scale-free index-of-dispersion classifier is the open follow-up. CONFIDENCE IS NOT A PROBABILITY: payloads carry confidence_basis: 'grade_band'. Corrected mlb-grade-degradation.md — its "25/25 grade<->confidence agreement" is a TAUTOLOGY (confidence is derived FROM the letter, so it would report 25/25 even if every grade were wrong), not a validation. Removed dead mlbGrader.js (referenced only by its own test) and the stale computeFeatures comment claiming a penalty that never ran. VERIFICATION (scripts/verify-grade-range.js, real props/logs/engine): WNBA 25 props B 68%->32%, C 32%->64%, D 0->1 (4%); 11-step spread went from 2 steps to 5 (C/C+/B-/D). The D is earned: Angel Reese assists o2.5, p_win 0.365. Nothing flooded — grades got HARDER. A did not emit locally because opp_rank_stat needs the Redis cache only prod populates (local ceiling +3.0 vs the +4.5 A needs); reachability is proven arithmetically and locked in tests. Prod A-emission is the outstanding fingerprint. MARKETING HOLD: "A-RATED" (AccuracyBadge, TopSignals) is unsupported until that fingerprint. Confirmed honest fallbacks render today — /api/ledger/accuracy has B and C buckets only, so the badge shows "MODEL · 63% HIT" and TopSignals self-hides. Nothing fabricated ships. Suite 276/3286 green, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01SmNjJAwEnqHPtXbvSZR8kA	2026-07-19 18:54:51 -04:00
builtbykev	7a925f43eb	Model Train arc 1 (engine): de-vig + EV + takeable/value gates + hero v2 + triplet ... Steps 1-6 — make "real opportunities at takeable prices" the engine, not a filter. 1. DE-VIG (src/utils/devig.js): two-way multiplicative de-vig strips the vig and returns fair prob + fair price per side + the overround. One side missing → fair UNAVAILABLE (null), never faked. Method noted in code + the `devig_method` field. 2. EV (devig.evPct): ev_pct = model prob × decimal − 1 at the graded side's ACTUAL price. This is the ranking signal now, replacing raw |model−consensus|. 3. TAKEABLE gate (src/config/valueEngine.js, TAKEABLE_ODDS_CEILING −160 .. +200, env-tunable): promoted surfaces only (hero/featured/alerts). The full board still shows everything; Parlay Lab exempt; JUICE_ODDS_FLOOR (−400) stays the absolute backstop underneath. Strict null-guard (Number(null)===0 would have made a missing price "takeable"). 4. VALUE flag: passes BOTH gates (takeable AND ev_pct ≥ VALUE_EV_THRESHOLD). Grade = read quality; value = the price pays you. Shipped in payloads. 5. HERO v2 (heroPropService): highest ev_pct among takeable A/B reads — a huge gap on a −900 line is trivia, not an opportunity. 6. VALUE TRIPLET: book_odds · fair_odds · model_odds on every read (snapshot, hero, scan — they all spread the grade). Handoff documents the fields; the rendering is Session-2 Design's job. All wired in analyzeViaEngine1's existing p_win/kelly block (real quantile probability × real book odds, or nothing). 33 new tests; suite 276/3306 green. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-19 02:43:30 -04:00
builtbykev	348a82b4a0	Generalize the no-edge guard: suppress by the BOOK'S PRICE, not a stat whitelist ... Follow-up to the rare-event under fix — the whitelist (doubles/triples/HR/SB) was fragile: the same juiced-under problem exists for steals, blocks, and any other low-frequency market, and a new stat would slip through. The real signal is the book's own price. The doubles unders were priced -625 to -1100 — laying 6-11x to win 1x on an ~82% event, with no value the model could recover. So the PRIMARY guard is now stat/sport-agnostic: analyzeViaEngine1 refuses any read whose graded-side odds are past the juice floor (JUICE_ODDS_FLOOR, default -400, env-tunable). That catches every version of this — steals, blocks, anything — and it also keeps the public record honest (those -800 "wins" hit ~82% of the time and would inflate the hit rate, the same class as the projection-0 degradation). The structural rare-event rules stay as the BACKUP for props with no odds (list also expanded cross-sport: + steals, blocks). Normal + longshot prices (-110, -250, +600) are preserved. 16 tests cover both layers. Reported: the doubles projection was REAL per-player (not a fallback); the fix is the price guard, not a bigger list. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-19 02:09:11 -04:00
builtbykev	f72f063e6f	Suppress rare-event 0.5 unders (juiced, no-edge) — config-driven grade + board fix ... Betting-logic audit: the CONSENSUS-vs-MODEL board flooded with fake reads like "DOUBLES u0.5 · MODEL 0.2 · +edge" — the juiced under side of rare counting-stat markets (doubles/triples/HR/SB), which is never a takeable edge and violates the no-unders-default doctrine. Report finding (item 3/4): the doubles projection is REAL per-player, not a flat fallback — 'doubles' maps to a real game-log field (MLB_LOG_FIELD doubles→ doubles) and the live values varied (0.03/0.16/0.2/0.22). So no projection-gate refusal for fakeness; the problem is purely structural (a rare event's real projection always sits below a 0.5 line, so the under always "wins"). Fix (config-driven — src/config/rareEventMarkets.js, tunable stat list + line threshold): - Grade layer (analyzeViaEngine1): a rare-event UNDER at ≤0.5 is always REFUSED (grade null + suppressed flag/reason). A rare-event OVER at ≤0.5 is refused UNLESS the model genuinely projects the event above the line — because a 0.2-over-0.5 carries the SAME |edge| as the suppressed under and would just take its rank on the board. The over grades normally once projection > line. - Board layer (marketBreadth.collectBreadth): drops null-model rows so a suppressed/ungraded prop can't rank a "MODEL —" placeholder onto the board. 10 suppression tests + config locks; also fixed a settingsPage book assertion left over from the ESPN→theScore swap. Suite 274/3289 green, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-19 00:19:23 -04:00
builtbykev	ccb9668f0c	Task B — founder checkout is SEAT-GATED; payment-decline grace spans retries ... 1+2. Checkout price was CODE-gated (founder price only with a valid founder code) — so "Claim a Founder Desk" would have charged the $44.99 standard price, not the advertised $34.99. Now it's SEAT-gated: resolveCheckoutPrice() attaches the founder price while founder seats remain (< FOUNDER_SEATS_TOTAL, read from the SAME countFounderSeats() truth as the ClaimMeter), and flips to standard at seat 100. createCheckoutSession uses it; the founderCode param is kept for back-compat but no longer drives price. The meter flips to "SOLD OUT" at capacity. When the count can't be verified we honor the advertised founder price (never overcharge). - Also hardened countFounderSeats to manual pagination (the for-await form broke on non-async-iterable list mocks). 3. Tests: resolveCheckoutPrice at seat 0 → founder, seat 100 → standard, the 99/100 boundary, null-count → advertised founder price. 4. Grace: invoice.payment_failed now sets a 14-DAY grace (spans Stripe's Smart Retry window) instead of 48h — a transient decline no longer revokes access mid-retry. Access is revoked only when Stripe actually cancels (customer.subscription.deleted keeps its 48h grace). Test updated. Stripe + founders suites green, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-18 23:04:19 -04:00
builtbykev	ae3cff9dbd	Item 7 — book roster: ESPN BET → theScore Bet (PENN) ... ESPN BET is defunct — PENN/ESPN terminated the deal; PENN rebranded it to theScore Bet (Dec 1 2025) and ESPN is now exclusive with DraftKings. Removed the ESPN BET entries from the BookChip map (web/src/lib/books.js) and added theScore Bet (mono TS, slug thescore) as the successor. Added 'thescore' to the backend oddsNormalizer ALLOWED_BOOKS so the feed's lines are accepted; synced the bookWordmark test list. The ESPN references in src/config/sports.js are ESPN's STATS API (data provider, unrelated to the sportsbook) — left untouched. Flagged in specs/design-reference/HANDOFF.md that the design mockups' BookChip row still shows ESPN BET and needs the same one-swap on the next refresh. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-18 13:55:39 -04:00
builtbykev	3b12c6ca98	Item 0 — founder count = REAL active Stripe subscriptions (kills the phantom 1) ... The counter showed 1/100 from user_profiles (founder_pricing=true AND subscription_status='active'), but the live Stripe account has ZERO subscriptions of any status — the "1" is a comped/manually-tiered profile, not a paying founder. A tier/founder_pricing field on a profile can be set without ever paying, so it is not proof of a paid seat. Now the count is Stripe's OWN truth: stripeService.countFounderSeats() counts ACTIVE subscriptions on a founder price. The route reads that (cached 5 min); null or any failure → hidden, never a number. A comped profile no longer counts → the honest number is 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-18 13:22:33 -04:00
builtbykev	cb3237cdce	Item 6 — Desk showcase renders REAL data (or hides), kills the mocked ladder ... The pricing Desk showcase hardcoded an alt-line ladder (1.5 A +7.1% / 2.5 A+ +11.4% / 4.5 C -3.8%), QUARTER-KELLY 2.4%, and PARLAY φ 0.34 — a mocked demo selling something we weren't proving. - deskShowcaseService reads the pre-graded snapshot for a real A/B prop's alt-line ladder (prefers the one with the most grade variation — the most compelling real example). Edge per rung shows only when it's a plausible market value; the inflated (model-line)/line artifact on small lines is guarded to "—" rather than shown as a fake +91%. - PARLAY φ is now REAL: the model's same-team correlation (0.34, mirroring the frontend parlayMath team constant) computed for TWO REAL same-team legs, named. No real same-team pair on the board → the tile hides, never an invented number. - QUARTER-KELLY tile is REMOVED: the snapshot has no odds, so a real quarter-Kelly % can't be computed here — a fabricated 2.4% is worse than nothing. Kelly stays a real in-app Desk feature; the showcase just doesn't fake it. - DeskShowcase is now a client component fetching /api/desk-showcase; when the board has no real ladder the whole visuals column hides (real-or-hidden, same law as the hero). The pitch copy is unchanged. 5 service tests. Change-affected suites green, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-18 01:42:16 -04:00
builtbykev	9b9aab4262	Item 5 — daily hero prop is a live RULE (biggest model-vs-market disagreement) ... The landing hero was a static Jokic "Example" card with a name-length pick and a hardcoded A- 73% +6.2% fallback. Now it's deterministic and live: - heroPropService.pickHeroProp reads the pre-graded snapshot and selects the prop with the LARGEST |projection - line| gap among A/B grades (conviction, not noise) — the read where VYNDR disagrees most with the market, the card that makes a stranger argue. No curation, no grading (reads cache → no API credits). GET /api/hero-prop (backend) + repointed Next proxy. - The card shows the disagreement EXPLICITLY: the book's line vs VYNDR's model, side by side (model in green), with the real grade timestamp ("Graded 2:14 PM"). The EXAMPLE chip is gone. - Empty slate → the MOST RECENT real graded read (flagged "LATEST READ", real date). Nothing cached → { available:false } and the card HIDES. No hand-written fallback — the Jokic card is deleted. Survives a dead night: a live rule shows tonight's real MLB read, never a phantom July NBA card. 7 service tests lock the rule (max-gap, A/B gate, projection/line required, empty→recent, hidden, cross-sport). colorContract updated to the new disagreement display. Change-affected suites green, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-18 01:29:55 -04:00
builtbykev	89a2977f57	Item 7 — public accuracy reads the CLEAN ledger; BEAT CLOSE hidden until C4 ... Kev's call: the 30D accuracy surfaces must read TRUTH, not a cache that can't be filtered. My earlier degraded-row exclusion only touched getModelAggregate (Postgres); the public buckets/badge still read outcomeService (Redis outcome log), which counts degraded projection-0 outcomes and has no field to filter on. - /api/accuracy (AccuracyBadge) + /api/ledger/accuracy (buckets/ModelRecord) now source from the clean Postgres ledger aggregate via new ledgerService.getAccuracyView + accuracyBucketsFromAgg (model_value > 0 excludes degraded rows). Same response shapes → no frontend change. Redis outcome log is now read by nothing public; it can age out or be rebuilt. - BEAT CLOSE is a MEASURED-WRONG ZERO: captureClosing re-records the locked line as the "closing" line, so clv is flat on the whole sample and beat_close reads 0% (comparing a number to itself). Full write-up: specs/audit-data/ clv-capture-broken.md (the fix belongs to C4). Until then, beat_close_pct + clv_distribution are SUPPRESSED at the source (getModelAggregate, gated by clvCaptureReliable() / CLV_CAPTURE_RELIABLE=1). Every public surface already renders BEAT CLOSE only when non-null, so they all hide it now — no wrong zero anywhere. HIT RATE (real) is unaffected. Suite 271/3261 green, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-17 16:08:18 -04:00
builtbykev	41fc2b90e2	Item 2 — founder counter is REAL or hidden (kills the hardcoded 47/100) ... ClaimMeter rendered a fabricated "47 / 100 CLAIMED" (a hardcoded default; the comment even said "Cosmetic conversion driver… Static here"). Now: - GET /api/founders/count counts ONLY real paying founders — user_profiles where founder_pricing = true AND subscription_status = 'active' (the Stripe-webhook-synced mirror, so we never hammer the Stripe API). Cached 5 min in Redis on top of that. - If the source is unavailable (Supabase unconfigured, query error, column not migrated, client throws) the endpoint returns { available: false } and the ClaimMeter renders NOTHING — counter and progress bar both hidden. We never fall back to a number. - A low real count is shown honestly (0 → "0 / 100"); the truth is the feature. Next proxy at app/api/founders/count. 6 route tests cover real count, low count, error/unconfigured/throw → hidden, and cache-hit. Suite 271/3260 green, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-17 15:32:18 -04:00
builtbykev	66d52a9ce0	Item 1 — VERB LAW: one verb, READ (never SCAN), + a lint that enforces it ... The product argued with itself: FAB/nav said "Scan", Free tier "5 scans", ticker "MLB slate scanned" — while the Ledger says "MY READS". Swept every user-visible surface to READ: - BottomTabBar FAB + Nav link: 'Scan' → 'Read' - Pricing free tier: '5 scans to try the model' → '5 reads …' - StatStrip: 'Awaiting next scan' → 'Awaiting next read' - Ticker badge + snapshotService event: tag 'SCAN' → 'READ', 'slate scanned' → 'slate read' (readSportOf parses BOTH old and new so cached ticker items dedupe cleanly through the rollover) - upgradePitch: 'You've scanned N parlays' / 'unlimited scans' → read/reads Internal untouched (not user-visible): /api/scan routes, scan_count column, scanning state, DemoScan/ScanIcon, scanlines CSS, the transitional SCAN color-map key. tests/unit/verbLaw.test.js is the enforcement: it fails on user-visible scan/scanned/scans copy across web/src + src/services (skips comments). Suite 270/3254 green, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-17 15:26:49 -04:00
builtbykev	9fc4edf3a9	Blast radius: exclude projection<=0 grades from the public model record ... The degraded grades (projection=0 → model_value=0) are already settled in the append-only ledger and must NOT be deleted (Data Semantics law). But their hit/miss is noise, not model skill — they never had a real projection. So getModelAggregate now filters `.gt('model_value', 0)` on both the settled and pending queries: the rows stay in ledger_entries, but leave the public hit_pct / CLV / per-tier record. `.gt` also drops NULL model_value. Post-fix no such row can be written (projection<=0 refuses), so this only sheds the historical set. This is the functional form of the "marking" the work order asked for — the degraded locks are effectively marked as non-counting without mutating history. Test builder mocks gained `.gt`; a lock asserts the filter is applied to both queries. Suite 269/3253 green, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-17 03:15:50 -04:00
builtbykev	888d103f95	Fix MLB grade degradation: projection>0 gate, edge semantics, letter=confidence ... The #1 board item — three grading bugs the phone audit surfaced, all in the live Node grade path (engine1 + analyzeViaEngine1), fixed at the source. 1. PROJECTION=0 NOW REFUSES. projectionFor returned l5_avg even when it was 0 (finite, so the `== null` gate passed it) — 9/25 live grades graded on a zero projection, producing a degenerate edge and a hollow grade. Now a non-positive reference is not a projection: projectionFor skips it and falls through to the next POSITIVE reference (l5 -> l20 -> per_90 -> xg); when none is positive it returns null and the read REFUSES (insufficient_data). The gate also gained an explicit `> 0` guard so the invariant is structural — a grade can never be emitted with a non-positive projection. Fewer graded props, honest. 2. EDGE_PCT. The formula was already (model - line) / line signed by direction — Kev's intended semantics. The broken {20,60,100,140} cluster was the proj=0 degeneracy ((line - 0)/line = 100%); with #1 those refuse, so the fabricated 100s vanish and real edges flow. The main-line edge now reuses the VALIDATED projection (edgePctFor accepts an optional ref) so edge and the persisted projection can never diverge. Frontend |edge|>40 guard stays as a safety net. 3. LETTER == THRESHOLD_TABLE(CONFIDENCE). engine1's hand-rolled GRADE_TO_CONFIDENCE drifted a full sub-tier low (B -> 0.55, which the canonical grade_thresholds.json calls B-) — the "B at 45%" the audit caught. Now confidence is DERIVED from each grade's band MIDPOINT in grade_thresholds.json (one source of truth, shared with the Python engine), so applying the threshold table to any grade's displayed confidence resolves back to the same letter. Proven for all 11 grades. Regression locks: tests/unit/mlbGradeDegradation.test.js (14 tests). Backend suite 269/3253 green, web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-17 03:06:12 -04:00
builtbykev	771d8b0ba4	Rev 3 glyphs: wire the 9 classifier-legacy marks (74→83), all backend archetypes now render real marks ... Design Rev 3 drew the 9 legacy classifier marks (BRUSH #E0B84A, WHIFF #E86A6A, CONNECTOR #9AB0C4, DISTRIBUTOR #7AB8D8, FASTBREAK #4AA0E8, FLEX #A08AC8, HYBRID #C88AB0, SWITCH #C0B08A, SWITCHBOARD #90A0E8). Wired each to its own Design mark + color (front lib/archetypes.js + backend archetypeService.js, color-synced). These were the 9 NO-MARK backend keys — now none are on a generic placeholder. They're classifier-side fallback renders (never user-facing archetype names, per MANIFEST). Re-imported Rev 3 package over specs/design-reference/ (83 glyph SVGs + MANIFEST regenerated from the authoritative glyphDefs(); HANDOFF Rev 3 note). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-16 21:23:59 -04:00
builtbykev	77d8fd658d	M3.6 glyph lift — 29 archetypes now render Design's real 74-mark set ... Replaced the generic reused shapes (triangle/star/plus/bolt…) with Design's real per-archetype marks from the authoritative glyphDefs() (HANDOFF), and aligned each archetype's color to Design's deduped palette — frontend lib/archetypes.js + backend archetypeService.js kept in color-sync (the cross-file test iterates the backend set). Badge test color expectations updated to Design (BOMBER #FF9F45, CONDUCTOR #6C8CFF, ALPHA #7C5CFF, FORTRESS #4C6FA5, …). Scope + honesty: - 29 non-combat archetypes wired to real marks + Design colors. - COMBAT namespace (STRIKER/GRAPPLER/PRESSURE/COUNTER/FINISHER/GRINDER) left untouched — it uses unicode CHAR glyphs + its own pinned colors + test (FINISHER deliberately doesn't collide with the soccer FINISHER). Combat could adopt Design's SVG marks in a follow-up. - 39 Design marks are INERT (no classify() producer yet) — the 74 SVGs live in specs/design-reference/assets/glyphs/; they light up when classify() expands. - 9 backend archetypes have NO Design mark (BRUSH/CONNECTOR/DISTRIBUTOR/ FASTBREAK/FLEX/HYBRID/SWITCH/SWITCHBOARD/WHIFF) — kept on their generic glyph, flagged for Design. VISUALLY UNVERIFIED at 390px/desktop — archetype marks + colors on the audit list. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-16 17:01:48 -04:00
builtbykev	2d413cfe1e	Quota guard: close the silent odds-api drain + reserve floor for MLB ... Diagnosis (why 500/500 went unpaged): the only regular odds-api burner was futuresService, which called axios DIRECTLY — bypassing the gateway, so it never hit recordCall (the ONE place the WARN/BLOCK pager fires) and never respected the 95% block. It only syncFromHeaders, which updated the counter's number SILENTLY. oddsService (which does go through the gateway) only touches odds-api when PropLine fails, so recordCall for odds-api effectively never ran. Result: the counter could reach 100% with neither pager firing. Fixes (a silent drain is now impossible, not just guarded): - futuresService routes through gateway.fetch('odds-api', …) → counted, blocked at 95%, and reserve-gated. Closes the raw-axios bypass. - Reserve floor in the gateway: a DISCRETIONARY call (futures/soccer) passes reserve=ODDS_API_RESERVE (default 50) and is refused while remaining <= reserve. The ESSENTIAL MLB prop-backup passes no reserve and may spend to the 95% block. → a futures/soccer drain can NEVER starve MLB's backup path. - quotaTracker.syncFromHeaders (the AUTHORITATIVE number) now fires the same once-per-period WARN/BLOCK alert on a crossing — extracted fireThresholdAlert shared with recordCall. The header-only drain now pages. - POST /api/internal/quota/test-alert (internal-key) test-fires the pager end-to-end so ntfy delivery is verifiable on demand. Also (reality-corrected cadence): WNBA restored to the full grid. 2026-07-15 had two AFTERNOON WNBA games finished before the 22 UTC slot — 14 UTC (10am ET) is the only slot early enough for a 1pm ET game's props, and on PropLine the extra slots cost a rounding error. Soccer stays the only trimmed sport (the real odds-api discipline). Assumption corrected by observed data. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-15 18:07:14 -04:00
builtbykev	4cd933d83e	Job 1: per-sport snapshot cadence (config, not baseball's rhythm for all) ... Every ACTIVE sport was graded at all five MLB slots (14/19/22/1/3 UTC). Sports post lines on different clocks, so that inheritance was wasteful both ways: WNBA props aren't posted at 14:00 UTC (10am ET) → that slot always graded 0 (the audit's "wnba:0"); soccer odds come from the 500/MONTH odds-api key, so five slots/day is a third of the budget for 1-2 matches. New src/config/sportCadence.js is the single source of truth (config-over- constants). Mapped from reality + quota headroom (PropLine 9k/day abundant, odds-api 500/mo scarce): mlb 14/19/22/1/3 intraday (full grid — games+props all day) nba 14/19/22/1/3 intraday (in-season fits; off-season self-skips empty) wnba 19/22/1 intraday (afternoon→evening ET; drops the 14/3 waste) soccer 14/19 NO intraday (WC live; 2 lean odds-api reads, key-protected) The scheduler still fires at HOURS_UTC and the missed-cron watchdog still references MLB (which runs every grid hour) — each slot now grades only sportsForHour(h), and only intradaySports() get the 20-min refresh. Every sport's hours are kept a subset of the firing grid (a boot-time guard + a test warn if that's ever violated). Retune a sport by editing one table row. Adaptive, not constant: near-zero when a sport is quiet, protecting the scarce odds-api quota from being drained by noon. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-15 16:17:55 -04:00
builtbykev	7712f0a442	Heartbeat honesty: SYNC badge reads refreshed_at, not grade-lock updated_at ... The "SIGNAL LIVE vs STALE 8h" contradiction was a field mismatch, not a dead pipeline. updated_at is the grade-LOCK time (advances only on a full snapshot, 5×/day — grades never change in-game, so it is intentionally stable). The SYNC badge measured the 20-min intraday cadence (expected_interval_s=1200) against that 5×/day field → structurally guaranteed STALE between slots even when intraday refreshes lines perfectly. - snapshotService: full snapshot now seeds refreshed_at at lock time - intradayRefresh already bumps refreshed_at every ~20 min (unchanged) - /api/snapshot/summary + GET /:sport now expose refreshed_at (was written to Redis but never serialized → no public liveness signal existed) - LiveLayer SYNC badge measures freshness from refreshed_at (fallback updated_at) Exposing refreshed_at also gives a public heartbeat probe: it advances every intraday slot, so pipeline liveness is verifiable without container logs. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-15 16:09:18 -04:00
builtbykev	bbfce05b94	Resolver hardening: ESPN team-roster index as primary NBA/WNBA name→id source ... Wave 0 shipped NBA/WNBA grading off ESPN per-athlete gamelogs, but name→id resolution went only through the v2 /search endpoint, which is unreliable at the edges. Live probing surfaced the real coverage gap: search actually resolves the right id for most names, but dual-league athletes (WNBA + NCAA — e.g. Napheesa Collier, Brionna Jones) get a filters-only gamelog until a `?season=` is supplied, so they silently returned insufficient_data despite a full season of games. Two fixes: 1. buildAthleteRosterIndex(sport) — aggregates every team roster for nba/wnba into a complete { nameKey → {id, displayName, teamId} } map (canonical accent-folded keys via playerName.nameKey). Bounded concurrency (6) over the ~15-30 team fetches, Redis `espnroster:{sport}` (24h) + in-memory mirror, fully defensive (a failing team is skipped → partial index, never throws; grouped OR flat athletes[] shapes handled; non-numeric ids dropped). This is now the PRIMARY resolver in resolveAthleteId/getPlayerGameLog; the v2 search stays as a backstop on a roster miss. A unique roster hit wins (S59 doctrine) — a missing name beats guessing another player's id. 2. getPlayerGameLog retries the gamelog with candidate seasons (current + previous calendar year) ONLY when the first parse comes back empty (filters-only), unlocking the dual-league athletes. The common path is untouched. MLB path (statsapi) unchanged; settlement/snapshot/frontend untouched. Live probe: WNBA roster index = 206 players (Collier id 3917450 / Lynx team 8, Brionna Jones id 3058895 present); NBA index = 544. Collier now resolves end-to-end with 20 gamelog rows (was NOT FOUND); Brionna Jones likewise; all previously-working players (A'ja Wilson, Ionescu, Clark, Stewart, Plum) still resolve. NBA hyphen names (Gilgeous-Alexander) resolve via nameKey folding. Tests: tests/unit/espnRosterIndex.test.js (9, fail-then-pass on base adapter). Full backend suite 3183 green; web build exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-14 00:21:59 -04:00
builtbykev	f0752b804b	Wave 2A: offseason data feeds — news wire + quota-disciplined futures ... FREE ESPN news wire + championship-winner futures for the never-dark offseason hub. Both graceful/empty, never fabricate a market value. - newsService (mirrors injuryService): per-sport ESPN /news FEEDS, pure parseNews → { sport, items:[{id,headline,description,published,type, athlete?{name,key},team?,href}] }; athlete/team from categories[] only (absent when not present). Cache 15m, injectable, offline-tested. - oddsNormalizer.normalizeOutrights: NEW branch — outrights outcomes are {name,price} with no point, so normalizeProps drops them; keeps them with best-price-across-allowed-books per selection. + americanToDecimal. - oddsService.FUTURES_KEYS: separate map (mlb/nba/wnba championship winner), OUT of the daily SPORT_KEYS/snapshot budget. - futuresService: getFutures(sport,deps) → { sport, updated_at, markets: [{key,title,selections:[{name,price,prevPrice?,move?}]}] }. One outrights call per 12h TTL (quota-disciplined), FUTURES_ENABLED gate. Price-move (shortening/drifting/flat) mirrors computeLineDeltas SHAPE on odds not line; prev prices persisted inside the futures:{sport} value (no new key). linkNewsToMoves pure causal-tie helper. - Routes /api/news/:sport + /api/futures/:sport (registered) + Next proxies. - Tests: newsService, futuresService, oddsNormalizerOutrights (fail→pass, no network). Full suite green. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-07-13 23:33:26 -04:00