Session 58: Phase 1 — Truth Infrastructure (2327 tests)

ledger_entries is live (migration 019 applied to prod, RLS + NULLS NOT
DISTINCT dedupe verified against the real database). Every grade now
persists, settles against the real result, and carries closing-line value.

- ledgerService: pipeline pre-grade upserts (public model record, user_id
  null, idempotent), closing capture on every snapshot (last write before
  game start = the close), settlement with SIGNED CLV (over = locked -
  closing; beat/faded/flat), 30d model aggregate with the hard n>=20 rule.
- Write paths: snapshotService -> ledger (priority path); Next /api/scan ->
  ledger for authenticated users only (anon never touches the public
  record). Refused reads write nothing and don't burn a scan.
- Honest refusal (work-order 1.5): no projection => insufficient_data,
  grade null, "INSUFFICIENT DATA - no read" UI. The web gradeAdapter no
  longer displays the line as the model projection (the audit's
  model==line / +0% edge degenerate); the card renders absent states.
  projectionFor is sport-aware (l5 -> l20 -> {stat}_per_90 -> xG).
- /ledger: MY READS | MODEL tabs; model header shows hit% + beat-close%
  only at n>=20, else RECORD BUILDING + live pending count. ModelRecord
  deferred-render strip on landing + player hero. CLV + outcome chips,
  revised_from_grade strikethrough (Phase 2.5 ready).
- SYNC (Task 5): thresholds vs SNAPSHOT_EXPECTED_INTERVAL (normal <1.5x,
  amber >=1.5x, STALE red >=3x) via /api/snapshot/summary.
- Phase 2.5 logged in specs/vyndr-roadmap.md (build after Phase 3).
- Data-semantics hardening: strict null-safe numeric parsing everywhere a
  market value is handled (Number(null)===0 would have fabricated lines).

Backend 2309 -> 2327 tests (201 suites), web build exit 0.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/services/intelligence/analyzeViaEngine1.js

@@ -232,34 +232,52 @@ function buildConcreteReasoning(features = {}, engine1Result = {}, meta = {}, pr
   };
 }
 
-// edge_pct in the legacy shape compares the relevant average to the line.
-// We use l5_avg when present (matches legacy "recent form" weighting),
-// fall back to l20_avg, otherwise return 0 so the field is always present.
+// The model's projection: the same reference the edge is computed from.
+// Recent-form averages first (l5, else l20); soccer props (which carry
+// per-90 rates instead of game averages) fall back to `{stat}_per_90`,
+// then xG for goals. This is a REAL model number — it is never the line.
+// When it's null the model has no projection and the read must refuse
+// (insufficient_data), not ship a hollow grade.
+function projectionFor(features, prop) {
+  const f = features || {};
+  const round2 = (n) => Math.round(n * 100) / 100;
+  if (Number.isFinite(f.l5_avg)) return round2(f.l5_avg);
+  if (Number.isFinite(f.l20_avg)) return round2(f.l20_avg);
+  const stat = String(prop?.stat_type || '').toLowerCase();
+  const per90 = f[`${stat}_per_90`];
+  if (Number.isFinite(per90)) return round2(per90);
+  if (stat === 'goals' && Number.isFinite(f.xg_per_90)) return round2(f.xg_per_90);
+  return null;
+}
+
+// edge_pct in the legacy shape compares the model projection to the line.
 function edgePctFor(features, prop) {
-  const ref = Number.isFinite(features?.l5_avg) ? features.l5_avg
-    : Number.isFinite(features?.l20_avg) ? features.l20_avg
-    : null;
+  const ref = projectionFor(features, prop);
   if (ref == null || !Number.isFinite(prop?.line) || prop.line === 0) return 0;
   const signed = prop.direction === 'over' ? (ref - prop.line) : (prop.line - ref);
   return Math.round((signed / prop.line) * 1000) / 10;
 }
 
-// When computeFeatures fails so badly that even a partial feature vector
-// is empty, return a legacy-shaped low-confidence result rather than
-// asking engine1 to grade nothing.
-function fallbackLegacyResult(rawProp, errors) {
+// Session 58 (work-order 1.5) — when the model has NO projection there is no
+// read. This used to return grade 'C' / confidence 10 / edge 0 — the exact
+// "hollow C" the live audit caught (model==line, +0% edge). A refused read
+// builds more trust than a fake one: grade is null, insufficient_data is
+// true, and NOTHING downstream (grades cache, snapshot, ledger) persists it.
+function insufficientDataResult(rawProp, errors) {
   return {
     player: rawProp.player ?? null,
     stat_type: rawProp.stat_type ?? null,
     line: rawProp.line ?? null,
     direction: rawProp.direction ?? null,
     book: rawProp.book || 'unknown',
-    grade: 'C',
-    confidence: 10,
+    grade: null,
+    insufficient_data: true,
+    confidence: 0,
     edge_pct: 0,
+    projection: null,
     kill_conditions_triggered: [],
     reasoning: {
-      summary: `Unable to compute full analysis. ${explainErrors(errors) || ''} Grade is provisional.`.trim(),
+      summary: `INSUFFICIENT DATA — no read. ${explainErrors(errors) || 'The model has no projection for this prop.'}`.trim(),
       steps: [],
     },
   };
@@ -334,12 +352,19 @@ async function analyzeViaEngine1(rawProp = {}) {
   const featureResult = await computeFeaturesForProp(rawProp);
   const { features, trap, consistency, prop, meta } = featureResult;
 
-  // Hard fallback only when computeFeatures couldn't produce anything
-  // useful at all (no features AND no consistency input).
+  // Hard refusal when computeFeatures couldn't produce anything useful at
+  // all (no features AND no consistency input) — there is nothing to grade.
   if ((!features || Object.keys(features).length === 0)
       && (!consistency || consistency.consistency === 'unknown')
       && (!Array.isArray(meta?.gameLogs) || meta.gameLogs.length === 0)) {
-    return fallbackLegacyResult(rawProp, meta?.errors);
+    return insufficientDataResult(rawProp, meta?.errors);
+  }
+
+  // Session 58 (work-order 1.5) — no projection ⇒ no read. Without a model
+  // reference the edge is fictional and the grade would be hollow.
+  const projection = projectionFor(features, { ...rawProp, line: prop.line });
+  if (projection == null) {
+    return insufficientDataResult(rawProp, meta?.errors);
   }
 
   // Engine 1: deterministic rule-based grade on the feature vector.
@@ -377,6 +402,10 @@ async function analyzeViaEngine1(rawProp = {}) {
   // intelligence). Optional + self-hiding on the card; zero extra I/O.
   Object.assign(legacy, buildIntelFields(features));
 
+  // Session 58 — the model's REAL projection (never the line). Persisted as
+  // ledger model_value and rendered under the MODEL label on the card.
+  legacy.projection = projection;
+
   return legacy;
 }
 
@@ -385,7 +414,8 @@ module.exports = {
   __internals: {
     buildConcreteReasoning,
     edgePctFor,
-    fallbackLegacyResult,
+    projectionFor,
+    insufficientDataResult,
     explainErrors,
     ERROR_EXPLANATIONS,
     buildIntelFields,