instar 1.3.779 → 1.3.781

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instar",
-  "version": "1.3.779",
+  "version": "1.3.781",
   "description": "Coherence infrastructure for self-evolving AI agents — on the Claude Code or Codex subscription you already have.",
   "type": "module",
   "main": "dist/index.js",

package/scripts/lint-nature-chains.mjs

@@ -166,6 +166,204 @@ export function runNatureChainsLint(src) {
   return { violations, reserveId, chains, labelMap };
 }
 
+/* ────────────────────────────────────────────────────────────────────────────
+ * FD4.2 — the R-rule STRUCTURAL-EXCLUSION lints (R3–R8), enforced at BUILD time.
+ * Spec: docs/specs/nature-axis-routing.md FD5(c) §296-314; LLM-ROUTING-REGISTRY
+ * hard rules #3/#5/#6.
+ *
+ * R3/R4/R5/R7 are POSITION bans over the authored chains — MIRRORING the pure TS
+ * predicate IntelligenceRouter.validateChainPositionRRule (a companion drift-guard
+ * test asserts the two agree). R6/R8 are COMPONENT-scoped structural pins over the
+ * per-component maps that live config can NEVER override, so they are BUILD-LINT
+ * ONLY. All are fail-closed: an unparseable map is a build failure, not a silent pass.
+ * ──────────────────────────────────────────────────────────────────────────── */
+
+const STRICT_FORMAT_CHAINS = new Set(['FAST', 'SORT']);
+const R3_QWEN = /qwen/i;
+const R4_GEMINI_CLI_DOOR = 'gemini-cli';
+const R5_WEAK_GATE = /gpt-oss-20b|llama-4-scout/i;
+const R7_DEEPSEEK = /deepseek/i;
+
+/**
+ * The FD4.2 R-rule POSITION-ban predicate over one authored position (R3/R4/R5/R7) —
+ * MIRRORS IntelligenceRouter.validateChainPositionRRule. Returns a violation or null.
+ */
+export function rruleViolationForPosition(chain, pos, index, labelMap) {
+  const resolvedModelId = labelMap[pos.door]?.[pos.model] ?? pos.model;
+  const modelText = `${pos.model} ${resolvedModelId}`;
+  const v = (rule, detail) => ({ chain, index, door: pos.door, model: pos.model, resolvedModelId, rule, detail });
+
+  if (STRICT_FORMAT_CHAINS.has(chain) && R3_QWEN.test(modelText)) {
+    return v(
+      'rrule-r3-qwen-strict-format',
+      `${chain}[${index}] ${pos.door}/'${pos.model}' is a qwen-tier model in a strict-format (FAST/SORT) ` +
+        `position — R3: qwen-tier chronically reason-burns and self-clips bounded-contract JSON (0.116/0.028).`,
+    );
+  }
+  if (chain !== 'JUDGE') return null;
+  if (pos.door === R4_GEMINI_CLI_DOOR) {
+    return v(
+      'rrule-r4-gemini-cli-judge',
+      `JUDGE[${index}] is the '${R4_GEMINI_CLI_DOOR}' door — R4: consumer Flash 2.5 fell for a judge-directed ` +
+        `injection; it may never take an injection-exposed JUDGE (safety-gate) position.`,
+    );
+  }
+  if (R5_WEAK_GATE.test(modelText)) {
+    return v(
+      'rrule-r5-weak-model-judge',
+      `JUDGE[${index}] ${pos.door}/'${pos.model}' — R5: gpt-oss-20b / llama-4-scout may never take a gate ` +
+        `(JUDGE) verdict position (injection-credulous / over-conservative contract-breakers).`,
+    );
+  }
+  if (R7_DEEPSEEK.test(modelText) || R7_DEEPSEEK.test(pos.door)) {
+    return v(
+      'rrule-r7-deepseek-judge',
+      `JUDGE[${index}] ${pos.door}/'${pos.model}' is a DeepSeek door/model — R7: DeepSeek may never take an ` +
+        `injection-exposed JUDGE (safety-gate) position.`,
+    );
+  }
+  return null;
+}
+
+/** Extract the quoted string members of a `new Set([ ... ])` const (fail-closed on absence). */
+export function extractStringSet(src, name) {
+  const start = src.indexOf(`export const ${name}`);
+  if (start < 0) throw new Error(`${name} not found in ${path.basename(COVERAGE_SRC)}`);
+  const open = src.indexOf('[', start);
+  const close = src.indexOf(']', open);
+  if (open < 0 || close < 0) throw new Error(`${name}: 'new Set([...])' body not found`);
+  const body = src.slice(open + 1, close);
+  const out = [];
+  const re = /'([^']+)'/g;
+  let m;
+  while ((m = re.exec(body)) !== null) out.push(m[1]);
+  return out;
+}
+
+/** Extract LLM_ROUTING_NATURE as { [component]: chain }. */
+export function extractNatureMap(src) {
+  const body = sliceConstBlock(src, 'LLM_ROUTING_NATURE');
+  const map = {};
+  const re = /(?:'([^']+)'|([A-Za-z_][\w-]*))\s*:\s*\{\s*nature:\s*'[^']+'\s*,\s*chain:\s*'([^']+)'\s*\}/g;
+  let m;
+  while ((m = re.exec(body)) !== null) map[m[1] || m[2]] = m[3];
+  if (Object.keys(map).length === 0) throw new Error('LLM_ROUTING_NATURE parsed empty');
+  return map;
+}
+
+/** Extract LLM_ROUTING_INJECTION_EXPOSURE as { [component]: boolean exposed } from the exposed()/notExposed() sugar. */
+export function extractExposureMap(src) {
+  const body = sliceConstBlock(src, 'LLM_ROUTING_INJECTION_EXPOSURE');
+  const map = {};
+  const re = /(?:'([^']+)'|([A-Za-z_][\w-]*))\s*:\s*(exposed|notExposed)\(/g;
+  let m;
+  while ((m = re.exec(body)) !== null) map[m[1] || m[2]] = m[3] === 'exposed';
+  if (Object.keys(map).length === 0) throw new Error('LLM_ROUTING_INJECTION_EXPOSURE parsed empty');
+  return map;
+}
+
+/**
+ * R6 (build-lint only) — every claude-banned (doc-tree/cartographer) component that HAS a
+ * nature/chain must route through a chain with NO claude-code door position. Structural pin:
+ * a future edit giving a doc-tree component a Claude-containing chain fails the build.
+ */
+export function r6Violations(src, chains) {
+  const banned = extractStringSet(src, 'NATURE_ROUTING_CLAUDE_BANNED_COMPONENTS');
+  if (banned.length === 0) throw new Error('NATURE_ROUTING_CLAUDE_BANNED_COMPONENTS parsed empty (fail-closed)');
+  const natureChain = extractNatureMap(src);
+  const out = [];
+  for (const comp of banned) {
+    const chain = natureChain[comp];
+    if (!chain) continue; // no nature/chain yet ⇒ structurally cannot route anywhere (vacuously off-Claude)
+    const positions = chains[chain] ?? [];
+    positions.forEach((pos, i) => {
+      if (pos.door === 'claude-code') {
+        out.push({
+          chain,
+          index: i,
+          door: pos.door,
+          model: pos.model,
+          resolvedModelId: pos.model,
+          rule: 'rrule-r6-claude-banned-component',
+          detail:
+            `component '${comp}' is Claude-banned (doc-tree/cartographer, R6) but its ${chain} chain routes to a ` +
+            `claude-code door at [${i}] — R6 (absolute): a doc-tree component may never route to any claude-code door.`,
+        });
+      }
+    });
+  }
+  return out;
+}
+
+/**
+ * R8 (build-lint only) — the input-classifier components are pinned off Flash-Lite. Assert
+ * (a) each is `exposed: true` in the injection map (so the FD5b gate skips non-injection doors
+ * for them), and (b) every authored `flash-lite` position sits on a METERED door — so it is
+ * structurally skipped in Increment A and no input-classifier can reach it.
+ */
+export function r8Violations(src, chains) {
+  const inputClassifiers = extractStringSet(src, 'NATURE_ROUTING_INPUT_CLASSIFIER_COMPONENTS');
+  if (inputClassifiers.length === 0)
+    throw new Error('NATURE_ROUTING_INPUT_CLASSIFIER_COMPONENTS parsed empty (fail-closed)');
+  const exposure = extractExposureMap(src);
+  const metered = new Set(extractStringSet(src, 'METERED_ROUTING_DOORS'));
+  const out = [];
+  // (a) each input-classifier must be statically injection-exposed.
+  for (const comp of inputClassifiers) {
+    if (exposure[comp] !== true) {
+      out.push({
+        chain: 'n/a',
+        index: -1,
+        door: 'n/a',
+        model: comp,
+        resolvedModelId: comp,
+        rule: 'rrule-r8-input-classifier-not-exposed',
+        detail:
+          `input-classifier component '${comp}' must be marked injection-exposed (exposed: true) in ` +
+          `LLM_ROUTING_INJECTION_EXPOSURE — R8: so the FD5b gate skips non-injection doors for it. ` +
+          `(found: ${exposure[comp] === false ? 'exposed: false' : 'absent'})`,
+      });
+    }
+  }
+  // (b) any authored flash-lite position must be behind the metered gate (unreachable in Increment A).
+  for (const chain of ['FAST', 'SORT', 'JUDGE', 'WRITE']) {
+    (chains[chain] ?? []).forEach((pos, i) => {
+      if (/flash-lite/i.test(pos.model) && !metered.has(pos.door)) {
+        out.push({
+          chain,
+          index: i,
+          door: pos.door,
+          model: pos.model,
+          resolvedModelId: pos.model,
+          rule: 'rrule-r8-flash-lite-reachable',
+          detail:
+            `${chain}[${i}] places flash-lite on non-metered door '${pos.door}' — R8: Flash-Lite must stay behind ` +
+            `the metered gate so input-classifier components (which walk FAST/SORT) can never land on it.`,
+        });
+      }
+    });
+  }
+  return out;
+}
+
+/** Run ALL FD4.2 R-rule lints (R3–R8) over source text. Returns { violations }. */
+export function runNatureRuleLints(src) {
+  const labelMap = extractLabelMap(src);
+  const chains = extractChains(src);
+  const violations = [];
+  // R3/R4/R5/R7 — position bans over the authored chains.
+  for (const chain of ['FAST', 'SORT', 'JUDGE', 'WRITE']) {
+    chains[chain].forEach((pos, i) => {
+      const v = rruleViolationForPosition(chain, pos, i, labelMap);
+      if (v) violations.push(v);
+    });
+  }
+  // R6/R8 — component-scoped structural pins over the maps.
+  violations.push(...r6Violations(src, chains));
+  violations.push(...r8Violations(src, chains));
+  return { violations, chains, labelMap };
+}
+
 function main() {
   let src;
   try {
@@ -175,26 +373,30 @@ function main() {
     process.exit(1);
   }
   let result;
+  let ruleResult;
   try {
     result = runNatureChainsLint(src);
+    ruleResult = runNatureRuleLints(src);
   } catch (err) {
     console.error(`lint-nature-chains: parse error (fail-closed — an unparseable map is a build failure) — ${err.message}`);
     process.exit(1);
   }
-  if (result.violations.length === 0) {
+  const allViolations = [...result.violations, ...ruleResult.violations];
+  if (allViolations.length === 0) {
     console.log(
-      `lint-nature-chains: OK — every FAST/SORT/JUDGE claude-code position is the pinned reserve ` +
-        `'${result.reserveId}', and no chain emits Fable (FD4 harness-door ban clean).`,
+      `lint-nature-chains: OK — FD4 harness-door ban clean (claude-code FAST/SORT/JUDGE is the pinned reserve ` +
+        `'${result.reserveId}', no Fable), AND the FD4.2 R-rule structural exclusions (R3–R8) all hold.`,
     );
     process.exit(0);
   }
   console.error(
-    'lint-nature-chains: FD4 HARNESS-DOOR BAN VIOLATION(S) in NATURE_ROUTING_DEFAULT_CHAINS ' +
-      '(src/data/llmBenchCoverage.ts):\n' +
-      result.violations.map((v) => `  - [${v.rule}] ${v.detail}`).join('\n') +
+    'lint-nature-chains: NATURE-CHAIN VIOLATION(S) in src/data/llmBenchCoverage.ts ' +
+      '(FD4 harness-door ban and/or FD4.2 R-rule structural exclusions R3–R8):\n' +
+      allViolations.map((v) => `  - [${v.rule}] ${v.detail}`).join('\n') +
       `\n\nThe one permitted claude-code FAST/SORT/JUDGE position is the pinned reserve id ` +
-      `'${result.reserveId}' (author it as the registry-pinned 'balanced' label or the concrete id). ` +
-      `WRITE is exempt for Opus-via-CLI, but NO chain may emit Fable. Spec: docs/specs/nature-axis-routing.md FD4/FD8.`,
+      `'${result.reserveId}'; WRITE is exempt for Opus-via-CLI but NO chain may emit Fable; and the R-rules ` +
+      `(R3 qwen∉strict-format, R4 gemini-cli∉JUDGE, R5 gpt-oss-20b/llama-4-scout∉JUDGE, R6 doc-tree∉claude-code, ` +
+      `R7 DeepSeek∉JUDGE, R8 input-classifiers off Flash-Lite) are structural. Spec: docs/specs/nature-axis-routing.md FD4/FD5c/FD8.`,
   );
   process.exit(1);
 }

package/scripts/routing-price-refresh.mjs

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+/**
+ * routing-price-refresh.mjs — the deterministic prober behind the OFF-by-default
+ * `routing-price-refresh` job (docs/specs/routing-control-room-spend-alerts.md, FD-8).
+ *
+ * It re-confirms published per-token prices for the metered doors and writes them into
+ * the MACHINE-LOCAL OBSERVED CACHE ONLY (`.instar/routing-prices.observed.json`) —
+ * STRUCTURALLY never the canonical manifest (a lint + unit test assert this). Observed
+ * points feed the REPORTING view + the promote-me drift hint; they are gate-INELIGIBLE
+ * by construction (in Increment B the money gate reads only the canonical manifest).
+ *
+ * FD-8 discipline (all enforced here):
+ *  - FORWARD-ONLY: every written point has `effectiveAt = today (UTC, day-aligned)`,
+ *    `corrects: null`. It can never write a backdated point or a correction.
+ *  - FREE-PROBE FIRST: `--scope free-probes` (default) queries only public, no-auth
+ *    model-list endpoints (OpenRouter). Metered / web-verify probes are MANUAL-ONLY and
+ *    refused unless a positive `--budget-usd` is passed (default 0 → refuse) — an
+ *    unknown price refuses rather than guesses.
+ *  - SANE-PRICE VALIDATION: a candidate failing the range / cached≤input checks is
+ *    dropped (never written), matching the reporting authority's fail-closed load.
+ *
+ * Pure core (parse / forward-only-merge / validate) is unit-tested with fixtures — no
+ * network in tests. Usage:
+ *   node scripts/routing-price-refresh.mjs [--scope free-probes|+liveness|+web-verify]
+ *        [--budget-usd N] [--dry-run] [--out <path>] [--project-dir <dir>] [--state-dir <dir>]
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/** The metered (door → canonical model ids) we track prices for — kept in sync with the manifest. */
+export const TRACKED = {
+  'openrouter-api': ['openai/gpt-5.5', 'anthropic/claude-opus-4-8'],
+  'gemini-api': ['gemini-3.1-flash-lite'],
+  'groq-api': ['openai/gpt-oss-120b'],
+};
+
+/** UTC-day-aligned ISO (T00:00:00Z) for a timestamp — every observed point is day-aligned (FD-18). */
+export function dayAlignedIso(ms) {
+  const d = new Date(ms);
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate())).toISOString();
+}
+
+function canonical(id) {
+  return String(id ?? '').trim().toLowerCase();
+}
+
+/** Sane-price validation (mirrors routingPriceAuthority.isValidPricePoint's money-safety checks). */
+export function isSanePoint(p) {
+  if (!p || typeof p !== 'object') return false;
+  if (typeof p.door !== 'string' || !p.door.trim()) return false;
+  if (typeof p.modelId !== 'string' || !p.modelId.trim()) return false;
+  if (typeof p.inPerMtok !== 'number' || !Number.isFinite(p.inPerMtok) || p.inPerMtok < 0) return false;
+  if (typeof p.outPerMtok !== 'number' || !Number.isFinite(p.outPerMtok) || p.outPerMtok < 0) return false;
+  if (p.cachedInPerMtok !== undefined) {
+    if (typeof p.cachedInPerMtok !== 'number' || !Number.isFinite(p.cachedInPerMtok) || p.cachedInPerMtok < 0 || p.cachedInPerMtok > p.inPerMtok) return false;
+  }
+  if (typeof p.effectiveAt !== 'string' || dayAlignedIso(Date.parse(p.effectiveAt)) !== p.effectiveAt) return false;
+  return true;
+}
+
+/**
+ * Parse OpenRouter's public /models payload into candidate observed points for the
+ * TRACKED openrouter models. OpenRouter reports `pricing.prompt`/`.completion` as USD
+ * PER TOKEN (string); we convert to USD per MILLION tokens. Pure.
+ */
+export function parseOpenRouterModels(payload, nowMs) {
+  const effectiveAt = dayAlignedIso(nowMs);
+  const out = [];
+  const data = payload && Array.isArray(payload.data) ? payload.data : [];
+  const tracked = new Set(TRACKED['openrouter-api'].map(canonical));
+  for (const m of data) {
+    if (!m || typeof m !== 'object') continue;
+    const modelId = canonical(m.id);
+    if (!tracked.has(modelId)) continue;
+    const pr = m.pricing;
+    if (!pr) continue;
+    const inPerMtok = Number(pr.prompt) * 1e6;
+    const outPerMtok = Number(pr.completion) * 1e6;
+    const point = {
+      door: 'openrouter-api',
+      modelId,
+      inPerMtok: Number.isFinite(inPerMtok) ? round6(inPerMtok) : NaN,
+      outPerMtok: Number.isFinite(outPerMtok) ? round6(outPerMtok) : NaN,
+      effectiveAt,
+      recordedAt: new Date(nowMs).toISOString(),
+      source: 'openrouter-models-api',
+      corrects: null,
+    };
+    if (isSanePoint(point)) out.push(point);
+  }
+  return out;
+}
+
+/**
+ * FORWARD-ONLY merge into the observed cache: keep existing observed points, and add a
+ * new candidate ONLY when its effectiveAt is ≥ every existing point for the same
+ * (door, model) — never rewrite history, never a same-day duplicate. Pure.
+ */
+export function mergeForwardOnly(existingPoints, candidates) {
+  const points = Array.isArray(existingPoints) ? existingPoints.slice() : [];
+  const latestByKey = new Map();
+  for (const p of points) {
+    const key = `${p.door} ${canonical(p.modelId)}`;
+    const eff = Date.parse(p.effectiveAt);
+    if (!latestByKey.has(key) || eff > latestByKey.get(key)) latestByKey.set(key, eff);
+  }
+  const added = [];
+  for (const c of candidates) {
+    if (!isSanePoint(c)) continue;
+    const key = `${c.door} ${canonical(c.modelId)}`;
+    const eff = Date.parse(c.effectiveAt);
+    const latest = latestByKey.get(key);
+    if (latest !== undefined && eff <= latest) continue; // forward-only: no backdate, no same-day dup
+    points.push(c);
+    latestByKey.set(key, eff);
+    added.push(c);
+  }
+  return { points, added };
+}
+
+function round6(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
+
+function readObserved(outPath) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(outPath, 'utf-8'));
+    return Array.isArray(raw?.points) ? raw.points : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeObserved(outPath, points) {
+  const body = {
+    schemaVersion: 1,
+    _doc: 'MACHINE-LOCAL observed price cache written ONLY by scripts/routing-price-refresh.mjs (FD-8). REPORTING-ONLY — never gate-eligible; promote to the canonical manifest via the reviewed git/PIN path. Append/forward-only.',
+    points,
+  };
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  fs.writeFileSync(outPath, `${JSON.stringify(body, null, 2)}\n`);
+}
+
+async function fetchOpenRouterModels(timeoutMs = 8000) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const resp = await fetch('https://openrouter.ai/api/v1/models', { signal: ctrl.signal });
+    if (!resp.ok) throw new Error(`openrouter models HTTP ${resp.status}`);
+    return await resp.json();
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+function parseArgs(argv) {
+  const args = { scope: 'free-probes', budgetUsd: 0, dryRun: false, out: null, projectDir: process.cwd(), stateDir: null };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--scope') args.scope = argv[++i];
+    else if (a === '--budget-usd') args.budgetUsd = Number(argv[++i]);
+    else if (a === '--dry-run') args.dryRun = true;
+    else if (a === '--out') args.out = argv[++i];
+    else if (a === '--project-dir') args.projectDir = argv[++i];
+    else if (a === '--state-dir') args.stateDir = argv[++i];
+  }
+  return args;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const stateDir = args.stateDir ?? path.join(args.projectDir, '.instar');
+  const outPath = args.out ?? path.join(stateDir, 'routing-prices.observed.json');
+  const now = Date.now();
+
+  if (args.scope !== 'free-probes' && !(args.budgetUsd > 0)) {
+    // Metered / web-verify probes are MANUAL-ONLY + budget-capped (FD-8). No budget → refuse.
+    console.error(`[routing-price-refresh] scope '${args.scope}' requires a positive --budget-usd (metered probes are manual-only, budget-fail-closed). Refusing.`);
+    process.exit(2);
+    return;
+  }
+
+  const candidates = [];
+  const notes = [];
+  // Free scope: only publicly queryable doors. OpenRouter's /models is public + no-auth.
+  try {
+    const payload = await fetchOpenRouterModels();
+    const pts = parseOpenRouterModels(payload, now);
+    candidates.push(...pts);
+    notes.push(`openrouter-api: ${pts.length} tracked model price(s) probed`);
+  } catch (err) {
+    notes.push(`openrouter-api: probe failed (${err?.message ?? err}) — skipped, no data written for this door`);
+  }
+  // gemini-api / groq-api need a key → out of the free scope. Honestly reported, never guessed.
+  notes.push('gemini-api, groq-api: need an API key → not in free-probe scope (manual metered probe only)');
+
+  const existing = readObserved(outPath);
+  const { points, added } = mergeForwardOnly(existing, candidates);
+
+  if (args.dryRun) {
+    console.log(JSON.stringify({ dryRun: true, wouldAdd: added, notes }, null, 2));
+    return;
+  }
+  if (added.length > 0) writeObserved(outPath, points);
+  console.log(JSON.stringify({ added: added.length, totalObserved: points.length, out: outPath, notes }, null, 2));
+}
+
+// Only run when invoked directly (import for unit tests stays side-effect-free).
+const invokedDirectly = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(new URL(import.meta.url).pathname);
+if (invokedDirectly) {
+  main().catch((err) => {
+    console.error('[routing-price-refresh] fatal:', err?.message ?? err);
+    process.exit(1);
+  });
+}

package/scripts/routing-prices.manifest.json

@@ -0,0 +1,64 @@
+{
+  "schemaVersion": 1,
+  "version": 1,
+  "_doc": "Canonical, human-reviewed price authority for the Routing Control Room spend view (docs/specs/routing-control-room-spend-alerts.md, Layer 1). USD per MILLION tokens, per door+model, effective-dated. APPEND-ONLY: a change or correction ADDS a point; points are never edited in place. GENERIC PUBLISHED prices only — operator-specific deals live in the machine-local overlay (.instar/routing-prices.overlay.json), never here. Written ONLY by a human path (a reviewed git commit, or — in Increment B — the PIN-gated promotion action). Every point's effectiveAt MUST be UTC-day-aligned (T00:00:00Z). In Increment A this manifest feeds the REPORTING view only; no money gate consumes it yet (the gate is Increment B).",
+  "doors": {
+    "gemini-api": {
+      "freshnessSlaDays": 45,
+      "staleMode": "book-conservative-max",
+      "conservativeMax": { "inPerMtok": 2.0, "outPerMtok": 12.0 }
+    },
+    "openrouter-api": {
+      "freshnessSlaDays": 45,
+      "staleMode": "book-conservative-max",
+      "conservativeMax": { "inPerMtok": 15.0, "outPerMtok": 90.0 }
+    },
+    "groq-api": {
+      "freshnessSlaDays": 45,
+      "staleMode": "book-conservative-max",
+      "conservativeMax": { "inPerMtok": 2.0, "outPerMtok": 8.0 }
+    }
+  },
+  "points": [
+    {
+      "door": "gemini-api",
+      "modelId": "gemini-3.1-flash-lite",
+      "inPerMtok": 0.25,
+      "outPerMtok": 1.5,
+      "effectiveAt": "2026-07-01T00:00:00Z",
+      "recordedAt": "2026-07-05T00:00:00Z",
+      "source": "published-generic-list",
+      "corrects": null
+    },
+    {
+      "door": "openrouter-api",
+      "modelId": "openai/gpt-5.5",
+      "inPerMtok": 5.0,
+      "outPerMtok": 30.0,
+      "effectiveAt": "2026-07-01T00:00:00Z",
+      "recordedAt": "2026-07-05T00:00:00Z",
+      "source": "published-generic-list",
+      "corrects": null
+    },
+    {
+      "door": "openrouter-api",
+      "modelId": "anthropic/claude-opus-4-8",
+      "inPerMtok": 5.0,
+      "outPerMtok": 25.0,
+      "effectiveAt": "2026-07-01T00:00:00Z",
+      "recordedAt": "2026-07-05T00:00:00Z",
+      "source": "published-generic-list",
+      "corrects": null
+    },
+    {
+      "door": "groq-api",
+      "modelId": "openai/gpt-oss-120b",
+      "inPerMtok": 0.2,
+      "outPerMtok": 0.8,
+      "effectiveAt": "2026-07-01T00:00:00Z",
+      "recordedAt": "2026-07-05T00:00:00Z",
+      "source": "published-generic-list",
+      "corrects": null
+    }
+  ]
+}