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

src/config/tiers.js

@@ -77,6 +77,10 @@ const TIERS = Object.freeze({
       // Session 64 — per-read directional-CLV badge. Analyst+Desk only;
     // Free never RECEIVES the data (gated server-side, not hidden client-side).
     clv_badge: true,
+    // Session 66 — VYNDR's OWN price (model_odds) on the price triplet.
+    // Analyst+Desk. Free keeps BOOK and FAIR: the de-vigged honest number is
+    // the hook and is NEVER the paywall — only our own price gates.
+    model_price: true,
 }),
   desk: Object.freeze({
     scans_per_day: Infinity,
@@ -94,6 +98,10 @@ const TIERS = Object.freeze({
       // Session 64 — per-read directional-CLV badge. Analyst+Desk only;
     // Free never RECEIVES the data (gated server-side, not hidden client-side).
     clv_badge: true,
+    // Session 66 — VYNDR's OWN price (model_odds) on the price triplet.
+    // Analyst+Desk. Free keeps BOOK and FAIR: the de-vigged honest number is
+    // the hook and is NEVER the paywall — only our own price gates.
+    model_price: true,
 }),
 });
 

src/utils/tierGating.js

@@ -55,6 +55,20 @@ function applyTierGating(result, tierName) {
   if (!canAccess(tierName, 'alt_line_ladder')) delete deskGated.alt_lines;
   if (!canAccess(tierName, 'kelly_sizing')) delete deskGated.kelly;
 
+  // Session 66 — the PRICE TRIPLET's model leg. Free never RECEIVES
+  // `model_odds`; it is stripped here, at the wire, not blurred in the client.
+  // `book_odds` / `fair_odds` / `ev_pct` deliberately pass through on EVERY
+  // tier: the de-vigged fair number is the free-tier hook, and the fair leg is
+  // never the paywall. `model_price_locked` tells the card to render the lock
+  // teaser rather than an absent leg, so a gated price is never mistaken for a
+  // missing one.
+  if (!canAccess(tierName, 'model_price')) {
+    delete deskGated.model_odds;
+    if (deskGated.book_odds != null && deskGated.fair_odds != null) {
+      deskGated.model_price_locked = true;
+    }
+  }
+
   if (canAccess(tierName, 'reasoning_visible')) {
     // Paid tier — everything else passes through unchanged.
     return deskGated;