modelrig 0.0.1 → 0.2.0

package/dist/registry/build.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Registry v0 build logic — spec WS3. Pure functions (script entrypoints in
+ * registry/ do the IO): declared from the vendored pricing map + adapter
+ * capability maps; probed from probe result files; observed from telemetry
+ * aggregates; merge + discrepancy detection.
+ *
+ * PRIVACY (spec WS6 / plan step-4 review): the observed layer publishes
+ * AGGREGATES ONLY — no tags, no payloads, no fingerprint joins.
+ */
+import type { ModelFacts } from "./claims";
+import type { ModelPricingV2 } from "./pricing-shape";
+export interface DeclaredLayer {
+    readonly as_of: string;
+    readonly source: string;
+    readonly pricing: {
+        readonly input_usd_per_mtok: number;
+        readonly output_usd_per_mtok: number;
+        readonly cached_input_usd_per_mtok: number | null;
+    } | null;
+    /**
+     * First-class structured pricing (pricing-first-class spec §2.2) — ADDITIVE
+     * and optional. Rides inside the existing `declared` jsonb; the flat `pricing`
+     * field above STAYS this pass (S3: retire it in a later change once every
+     * reader uses `pricing_v2`). `pricing_v2.base` always equals the flat field.
+     */
+    readonly pricing_v2?: ModelPricingV2 | null;
+    readonly flags: {
+        readonly supports_response_schema: boolean | null;
+        readonly supports_web_search: boolean | null;
+        readonly supports_prompt_caching: boolean | null;
+        /** What OUR adapter actually drives for this model (static map v0). */
+        readonly adapter_structured_native: boolean | null;
+        readonly adapter_grounded_native: boolean | null;
+    };
+}
+/** Per-corpus (fixture-family) breakdown of a schema summary — demo-rig
+ * §11.3b: the leaderboard and registry surface which corpus produced a cell,
+ * so a model probed only by `demo-rig` fixtures is visibly that. The aggregate
+ * fields above stay the ranking basis (same whole corpus for every model);
+ * this splits them by provenance for honesty, not for per-model subsetting. */
+export interface ProbedFamilySummary {
+    readonly samples: number;
+    readonly conform_rate: number | null;
+    readonly conform_ci95: readonly [number, number] | null;
+    readonly value_accuracy_mean: number | null;
+    /** Fraction of this subset's samples served via the NATIVE structured rung
+     * vs json_mode coaching (discriminating-fixtures follow-up 3a). Lets a hard
+     * cell read "coached, missed" rather than a flat fail: a model without probed
+     * structured_native is coached on every schema sample, so a strict-constraint
+     * miss is the coaching path's limit, not the model's. Null when no sample in
+     * the subset recorded a rung (pre-rung result files). */
+    readonly native_rung_rate: number | null;
+    /** Mean per-sample cost (USD) over this subset — the per-family analogue of
+     * the aggregate `mean_cost_usd` (task-type-leaderboards spec §2.1). Lets a
+     * per-family view compute its own effective-cost-of-conformance
+     * (`mean_cost_usd / conform_rate * 1000`) so the faceted "cheapest-conformant
+     * on <task type>" rank has a number to sort on. Optional/additive: absent on
+     * pre–task-type probed layers, so a consumer reads it behind a null guard. */
+    readonly mean_cost_usd?: number;
+}
+export interface ProbedSchemaSummary {
+    readonly samples: number;
+    readonly parse_rate: number;
+    readonly conform_rate: number | null;
+    readonly conform_ci95: readonly [number, number] | null;
+    readonly value_accuracy_mean: number | null;
+    readonly native_rung_rate: number | null;
+    readonly mean_cost_usd: number;
+    /** family → its own stats (demo-rig §11.3b). Absent on pre-family probed
+     * layers; present once a result file carries fixtureFamilies. */
+    readonly by_family?: Readonly<Record<string, ProbedFamilySummary>>;
+    /** difficulty → its own stats (discriminating-fixtures §3). Same shape as
+     * by_family; the "hard" bucket is the leaderboard's differentiating column.
+     * Absent on pre-difficulty probed layers; present once a result file carries
+     * fixtureDifficulties. */
+    readonly by_difficulty?: Readonly<Record<string, ProbedFamilySummary>>;
+    /** task subtype → its own stats (www-clarity §5.5 W16). Unlike family
+     * (provenance) these are REAL task types (extraction.tabular,
+     * classification, …), cross-corpus by design. No default bucket: an
+     * untagged fixture joins no subtype. Absent when nothing is tagged. */
+    readonly by_subtype?: Readonly<Record<string, ProbedFamilySummary>>;
+}
+export interface ProbedGroundingSummary {
+    readonly samples: number;
+    readonly grounded_rate: number;
+    readonly mean_citations: number;
+}
+export interface ProbedCachingSummary {
+    readonly samples: number;
+    readonly cache_hit_rate: number;
+    readonly mean_cached_tokens: number;
+    /** Samples that passed the documented-path eligibility gate (prefix ≥ the
+     * provider's minimum cacheable length; typed skips excluded). The
+     * caching discrepancy rule requires this > 0 — a rate of 0 over zero
+     * eligible samples is a probe-coverage fact, not a capability finding.
+     * Absent in pre-2026-08-18 result files → treated as `samples`. */
+    readonly eligible_samples?: number;
+}
+export interface ProbedLayer {
+    readonly as_of: string;
+    readonly source: string;
+    readonly schema: ProbedSchemaSummary | null;
+    readonly grounding: ProbedGroundingSummary | null;
+    readonly caching: ProbedCachingSummary | null;
+}
+export interface ObservedLayer {
+    readonly as_of: string;
+    readonly source: string;
+    readonly inferences: number;
+    readonly p50_latency_ms: number | null;
+    /** TTFB p50 (Phase 4 WS3) — optional: aggregators populate it where
+     * ttfb_ms rows exist; older observed layers lack the field. */
+    readonly p50_ttfb_ms?: number | null;
+    /**
+     * Observed-health percentiles + error-rate (G-4, observed-health/spec §4.2).
+     * Optional and additive — older observed layers lack these fields; they are
+     * min-n gated to `null` on thin endpoints. Operational health for the console
+     * + routing ONLY, NEVER a RigIndex input (spec §4.4).
+     */
+    readonly p90_latency_ms?: number | null;
+    readonly p99_latency_ms?: number | null;
+    readonly p90_ttfb_ms?: number | null;
+    readonly p99_ttfb_ms?: number | null;
+    /** failure_class non-null / total; null under the min-n gate. */
+    readonly error_rate?: number | null;
+    /** Sample count behind the health stats (drives the min-n gate + freshness). */
+    readonly sample_n?: number;
+    readonly served_tier_rates: Readonly<Record<string, number>>;
+    readonly cache_hit_rate: number | null;
+    readonly failure_class_rates: Readonly<Record<string, number>>;
+}
+export interface Discrepancy {
+    readonly kind: string;
+    readonly message: string;
+}
+export interface RegistryEntry {
+    readonly model_key: string;
+    readonly declared: DeclaredLayer | null;
+    readonly probed: ProbedLayer | null;
+    readonly observed: ObservedLayer | null;
+    readonly discrepancies: readonly Discrepancy[];
+    /** Per-model call-shaping knowledge (addendum A1 / patch P1) — seeded from
+     * the adapters' documented constraints; see call-notes.ts. */
+    readonly callNotes: readonly string[];
+    /** Credential-scoped {value, scope, source, as_of} facts (Phase 4 WS3) —
+     * null when nothing is cited; absence IS the conservative claim. */
+    readonly facts: ModelFacts | null;
+}
+export interface Registry {
+    readonly generated_at: string;
+    readonly license: string;
+    readonly models: readonly RegistryEntry[];
+}
+/** Minimal shape of a probe result file this builder consumes (kept
+ * structural so the core package does not depend on modelrig-probes). */
+export interface ProbeResultFile {
+    readonly modelKey: string;
+    readonly class: "schema" | "grounding" | "caching";
+    readonly date: string;
+    readonly harnessVersion: string;
+    /** fixtureId → family (demo-rig §11.3b). Absent on pre-family result files;
+     * those fixtures roll up under the default "probe-suite" family. */
+    readonly fixtureFamilies?: Readonly<Record<string, string>>;
+    /** fixtureId → difficulty (discriminating-fixtures §3). Absent on
+     * pre-difficulty result files; those fixtures roll up under "standard". */
+    readonly fixtureDifficulties?: Readonly<Record<string, string>>;
+    /** fixtureId → task subtype (www-clarity §5.5 W16). Absent on pre-subtype
+     * result files — the registry builder may inject the mapping from the
+     * current fixture corpus (subtype is hash-excluded retro-taggable
+     * metadata). Fixtures absent from the map join no subtype bucket. */
+    readonly fixtureSubtypes?: Readonly<Record<string, string>>;
+    readonly raw: Readonly<Record<string, ReadonlyArray<{
+        readonly rung?: "native" | "json_mode";
+        readonly parseOk: boolean;
+        readonly schemaConform: boolean | null;
+        readonly valueAccuracy: number | null;
+        readonly grounded: boolean | null;
+        readonly citationCount: number | null;
+        readonly cachedTokens: number | null;
+        readonly costUsd: number;
+        readonly failureClass: string | null;
+    }>>>;
+}
+/** Latest result per class wins (results are dated). */
+export declare function latestPerClass(results: readonly ProbeResultFile[]): Partial<Record<ProbeResultFile["class"], ProbeResultFile>>;
+export declare function summarizeSchemaResult(result: ProbeResultFile): ProbedSchemaSummary;
+export declare function summarizeGroundingResult(result: ProbeResultFile): ProbedGroundingSummary;
+export declare function summarizeCachingResult(result: ProbeResultFile): ProbedCachingSummary;
+/** Compose a model's SCHEMA result files into one synthetic file, so a cheap
+ * SUPPLEMENTAL run (new fixtures only) ADDS to a prior full run instead of
+ * replacing it — the default latest-per-file rule would drop every fixture the
+ * newest file omits. The latest schema file is the base; older files fill in
+ * fixtures the base lacks, newest date winning on any per-fixture collision.
+ * ONLY fixtures in `currentFixtureIds` (the live corpus) are pulled forward, so
+ * a RETIRED id sitting in an old file is never resurrected (the trap a naive
+ * union hits, e.g. demo-support-summarize double-counting summarize). */
+export declare function mergeSchemaResults(results: readonly ProbeResultFile[], currentFixtureIds: ReadonlySet<string>): ProbeResultFile | undefined;
+/**
+ * Build a model's probed layer. When `currentSchemaFixtureIds` is supplied, the
+ * schema class COMPOSES across the model's result files (a supplemental run adds
+ * fixtures to a prior full run) via mergeSchemaResults; grounding/caching stay
+ * latest-per-file (one file per cycle). Omitting the ids keeps the pure
+ * latest-per-file behaviour (back-compat for hermetic tests).
+ */
+export declare function buildProbedLayer(results: readonly ProbeResultFile[], currentSchemaFixtureIds?: ReadonlySet<string>): ProbedLayer | null;
+/** Declared-vs-probed disagreement detection — plan §4 (the rule pair) plus
+ * the rung gap that motivated the whole exercise (DeepSeek json_object). */
+export declare function detectDiscrepancies(declared: DeclaredLayer | null, probed: ProbedLayer | null): Discrepancy[];
+export declare function buildRegistry(entries: ReadonlyArray<{
+    readonly model_key: string;
+    readonly declared: DeclaredLayer | null;
+    readonly probed: ProbedLayer | null;
+    readonly observed: ObservedLayer | null;
+}>, generatedAt: string): Registry;
+/** Leaderboard ranking metric — spec WS3: "conformance per dollar".
+ * Effective $ per 1K conformant outputs: mean sample cost ÷ conform rate
+ * × 1000. Null when unjudged or never conformant. */
+export declare function effectiveCostPer1kConformant(schema: ProbedSchemaSummary | null): number | null;
+//# sourceMappingURL=build.d.ts.map

package/dist/registry/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/registry/build.ts"],"names":[],"mappings":"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"}

package/dist/registry/build.js

@@ -0,0 +1,313 @@
+"use strict";
+/**
+ * Registry v0 build logic — spec WS3. Pure functions (script entrypoints in
+ * registry/ do the IO): declared from the vendored pricing map + adapter
+ * capability maps; probed from probe result files; observed from telemetry
+ * aggregates; merge + discrepancy detection.
+ *
+ * PRIVACY (spec WS6 / plan step-4 review): the observed layer publishes
+ * AGGREGATES ONLY — no tags, no payloads, no fingerprint joins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.latestPerClass = latestPerClass;
+exports.summarizeSchemaResult = summarizeSchemaResult;
+exports.summarizeGroundingResult = summarizeGroundingResult;
+exports.summarizeCachingResult = summarizeCachingResult;
+exports.mergeSchemaResults = mergeSchemaResults;
+exports.buildProbedLayer = buildProbedLayer;
+exports.detectDiscrepancies = detectDiscrepancies;
+exports.buildRegistry = buildRegistry;
+exports.effectiveCostPer1kConformant = effectiveCostPer1kConformant;
+const call_notes_1 = require("./call-notes");
+const claims_1 = require("./claims");
+const CONFORMANCE_BAR = 0.9;
+const GROUNDED_BAR = 0.5;
+function mean(values) {
+    if (values.length === 0)
+        return null;
+    return values.reduce((a, b) => a + b, 0) / values.length;
+}
+function wilson95(successes, n) {
+    if (n === 0)
+        return [0, 1];
+    const z = 1.959963984540054;
+    const p = successes / n;
+    const z2 = z * z;
+    const denominator = 1 + z2 / n;
+    const center = (p + z2 / (2 * n)) / denominator;
+    const half = (z * Math.sqrt((p * (1 - p)) / n + z2 / (4 * n * n))) / denominator;
+    return [Math.max(0, center - half), Math.min(1, center + half)];
+}
+/** Latest result per class wins (results are dated). */
+function latestPerClass(results) {
+    const byClass = {};
+    for (const result of results) {
+        const current = byClass[result.class];
+        if (current === undefined || result.date > current.date) {
+            byClass[result.class] = result;
+        }
+    }
+    return byClass;
+}
+const DEFAULT_FIXTURE_FAMILY = "probe-suite";
+const DEFAULT_FIXTURE_DIFFICULTY = "standard";
+/** Sentinel for fixtures with no subtype tag — dropped from by_subtype. */
+const UNTAGGED_SUBTYPE = "__untagged__";
+/** Group a result's schema samples by a per-fixture classification map
+ * (family or difficulty), defaulting fixtures the map omits to `fallback`.
+ * Shared by the by_family and by_difficulty rollups so both are computed the
+ * same way as the headline (via schemaFamilyStats). */
+function rollupBy(result, classification, fallback) {
+    const buckets = new Map();
+    for (const [fixtureId, fixtureSamples] of Object.entries(result.raw)) {
+        const key = classification?.[fixtureId] ?? fallback;
+        const bucket = buckets.get(key) ?? [];
+        bucket.push(...fixtureSamples);
+        buckets.set(key, bucket);
+    }
+    const out = {};
+    for (const [key, samples] of [...buckets.entries()].sort()) {
+        out[key] = schemaFamilyStats(samples);
+    }
+    return out;
+}
+/** Conformance + value-accuracy stats over a set of schema samples — shared
+ * by the aggregate summary and each per-family sub-summary so a family cell is
+ * computed the same way as the headline. */
+function schemaFamilyStats(samples) {
+    const judged = samples.filter((s) => s.schemaConform !== null);
+    const conforming = judged.filter((s) => s.schemaConform === true).length;
+    const accuracies = samples.map((s) => s.valueAccuracy).filter((a) => a !== null);
+    // Same native-rung computation as the aggregate — the serving path a subset
+    // was served through (native strict vs json_mode coaching), so a hard cell
+    // can say which it was (follow-up 3a).
+    const rungs = samples.filter((s) => s.rung !== undefined);
+    return {
+        samples: samples.length,
+        conform_rate: judged.length === 0 ? null : conforming / judged.length,
+        conform_ci95: judged.length === 0 ? null : wilson95(conforming, judged.length),
+        value_accuracy_mean: mean(accuracies),
+        native_rung_rate: rungs.length === 0 ? null : rungs.filter((s) => s.rung === "native").length / rungs.length,
+        // Per-subset mean cost, same computation as the aggregate — so a per-family
+        // view can derive its own effective-cost-of-conformance (spec §2.1).
+        mean_cost_usd: samples.length === 0 ? 0 : samples.reduce((a, s) => a + s.costUsd, 0) / samples.length,
+    };
+}
+function summarizeSchemaResult(result) {
+    const samples = Object.values(result.raw).flat();
+    const n = samples.length;
+    const judged = samples.filter((s) => s.schemaConform !== null);
+    const conforming = judged.filter((s) => s.schemaConform === true).length;
+    const rungs = samples.filter((s) => s.rung !== undefined);
+    const accuracies = samples
+        .map((s) => s.valueAccuracy)
+        .filter((a) => a !== null);
+    // Per-corpus rollup (demo-rig §11.3b) and per-difficulty rollup
+    // (discriminating-fixtures §3). Each groups the same samples by a different
+    // hash-excluded classification, so surfaces can say which corpus produced a
+    // cell and how a model does on the hard subset. The aggregate above stays the
+    // ranking basis (same whole corpus for every model).
+    const by_family = rollupBy(result, result.fixtureFamilies, DEFAULT_FIXTURE_FAMILY);
+    const by_difficulty = rollupBy(result, result.fixtureDifficulties, DEFAULT_FIXTURE_DIFFICULTY);
+    // Subtype rollup (W16): no default bucket — an untagged fixture belongs to
+    // no task type, so it rolls into a sentinel that is then dropped.
+    const by_subtype = rollupBy(result, result.fixtureSubtypes, UNTAGGED_SUBTYPE);
+    delete by_subtype[UNTAGGED_SUBTYPE];
+    return {
+        samples: n,
+        parse_rate: n === 0 ? 0 : samples.filter((s) => s.parseOk).length / n,
+        conform_rate: judged.length === 0 ? null : conforming / judged.length,
+        conform_ci95: judged.length === 0 ? null : wilson95(conforming, judged.length),
+        value_accuracy_mean: mean(accuracies),
+        native_rung_rate: rungs.length === 0 ? null : rungs.filter((s) => s.rung === "native").length / rungs.length,
+        mean_cost_usd: n === 0 ? 0 : samples.reduce((a, s) => a + s.costUsd, 0) / n,
+        ...(Object.keys(by_family).length > 0 ? { by_family } : {}),
+        ...(Object.keys(by_difficulty).length > 0 ? { by_difficulty } : {}),
+        ...(Object.keys(by_subtype).length > 0 ? { by_subtype } : {}),
+    };
+}
+function summarizeGroundingResult(result) {
+    const samples = Object.values(result.raw).flat();
+    const n = samples.length;
+    return {
+        samples: n,
+        grounded_rate: n === 0 ? 0 : samples.filter((s) => s.grounded === true).length / n,
+        mean_citations: mean(samples.map((s) => s.citationCount ?? 0)) ?? 0,
+    };
+}
+function summarizeCachingResult(result) {
+    const samples = Object.values(result.raw).flat();
+    // failureClass null = the paired call ran AND passed the documented-path
+    // eligibility gate (cache_prefix_below_minimum is a typed skip upstream).
+    const okSamples = samples.filter((s) => s.failureClass === null);
+    const n = okSamples.length;
+    return {
+        samples: samples.length,
+        cache_hit_rate: n === 0 ? 0 : okSamples.filter((s) => (s.cachedTokens ?? 0) > 0).length / n,
+        mean_cached_tokens: mean(okSamples.map((s) => s.cachedTokens ?? 0)) ?? 0,
+        eligible_samples: n,
+    };
+}
+/** Compose a model's SCHEMA result files into one synthetic file, so a cheap
+ * SUPPLEMENTAL run (new fixtures only) ADDS to a prior full run instead of
+ * replacing it — the default latest-per-file rule would drop every fixture the
+ * newest file omits. The latest schema file is the base; older files fill in
+ * fixtures the base lacks, newest date winning on any per-fixture collision.
+ * ONLY fixtures in `currentFixtureIds` (the live corpus) are pulled forward, so
+ * a RETIRED id sitting in an old file is never resurrected (the trap a naive
+ * union hits, e.g. demo-support-summarize double-counting summarize). */
+function mergeSchemaResults(results, currentFixtureIds) {
+    const schemaFiles = results
+        .filter((r) => r.class === "schema")
+        .sort((a, b) => (a.date > b.date ? -1 : a.date < b.date ? 1 : 0)); // newest first
+    const base = schemaFiles[0];
+    if (base === undefined)
+        return undefined;
+    const raw = { ...base.raw };
+    const fixtureSubtypes = { ...(base.fixtureSubtypes ?? {}) };
+    const fixtureFamilies = { ...(base.fixtureFamilies ?? {}) };
+    const fixtureDifficulties = { ...(base.fixtureDifficulties ?? {}) };
+    for (const older of schemaFiles.slice(1)) {
+        for (const [fid, samples] of Object.entries(older.raw)) {
+            if (fid in raw)
+                continue; // a newer file already carries it — newest wins
+            if (!currentFixtureIds.has(fid))
+                continue; // retired id — never resurrect
+            raw[fid] = samples;
+            if (older.fixtureSubtypes?.[fid] !== undefined)
+                fixtureSubtypes[fid] = older.fixtureSubtypes[fid];
+            if (older.fixtureFamilies?.[fid] !== undefined)
+                fixtureFamilies[fid] = older.fixtureFamilies[fid];
+            if (older.fixtureDifficulties?.[fid] !== undefined)
+                fixtureDifficulties[fid] = older.fixtureDifficulties[fid];
+        }
+    }
+    return {
+        ...base,
+        raw,
+        ...(Object.keys(fixtureSubtypes).length > 0 ? { fixtureSubtypes } : {}),
+        ...(Object.keys(fixtureFamilies).length > 0 ? { fixtureFamilies } : {}),
+        ...(Object.keys(fixtureDifficulties).length > 0 ? { fixtureDifficulties } : {}),
+    };
+}
+/**
+ * Build a model's probed layer. When `currentSchemaFixtureIds` is supplied, the
+ * schema class COMPOSES across the model's result files (a supplemental run adds
+ * fixtures to a prior full run) via mergeSchemaResults; grounding/caching stay
+ * latest-per-file (one file per cycle). Omitting the ids keeps the pure
+ * latest-per-file behaviour (back-compat for hermetic tests).
+ */
+function buildProbedLayer(results, currentSchemaFixtureIds) {
+    if (results.length === 0)
+        return null;
+    const byClass = latestPerClass(results);
+    const schemaFile = currentSchemaFixtureIds !== undefined
+        ? mergeSchemaResults(results, currentSchemaFixtureIds)
+        : byClass.schema;
+    const dates = results.map((r) => r.date).sort();
+    const versions = results.map((r) => r.harnessVersion).sort();
+    const newest = dates[dates.length - 1];
+    const version = versions[versions.length - 1];
+    return {
+        as_of: newest,
+        source: `modelrig-probes@${version}`,
+        schema: schemaFile !== undefined ? summarizeSchemaResult(schemaFile) : null,
+        grounding: byClass.grounding !== undefined ? summarizeGroundingResult(byClass.grounding) : null,
+        caching: byClass.caching !== undefined ? summarizeCachingResult(byClass.caching) : null,
+    };
+}
+/** Declared-vs-probed disagreement detection — plan §4 (the rule pair) plus
+ * the rung gap that motivated the whole exercise (DeepSeek json_object). */
+function detectDiscrepancies(declared, probed) {
+    if (declared === null || probed === null)
+        return [];
+    const out = [];
+    const schema = probed.schema;
+    if (schema !== null && schema.conform_rate !== null) {
+        if (declared.flags.supports_response_schema === true && schema.conform_rate < CONFORMANCE_BAR) {
+            out.push({
+                kind: "declared_schema_low_conformance",
+                message: `declared supports_response_schema, but probed conformance is ` +
+                    `${(schema.conform_rate * 100).toFixed(0)}% (bar: ${CONFORMANCE_BAR * 100}%)`,
+            });
+        }
+        if (declared.flags.supports_response_schema !== true &&
+            schema.conform_rate >= CONFORMANCE_BAR) {
+            out.push({
+                kind: "undeclared_schema_capable",
+                message: `no declared schema support, but probed conformance is ` +
+                    `${(schema.conform_rate * 100).toFixed(0)}% — capability exists undeclared`,
+            });
+        }
+    }
+    if (schema !== null &&
+        schema.native_rung_rate !== null &&
+        declared.flags.supports_response_schema === true &&
+        schema.native_rung_rate === 0) {
+        out.push({
+            kind: "schema_served_via_json_mode",
+            message: "declared supports_response_schema, but every probed sample was served via " +
+                "json_mode coaching — no native strict enforcement exists on this serving path " +
+                "(the json_object-vs-schema gap)",
+        });
+    }
+    const grounding = probed.grounding;
+    if (grounding !== null && grounding.samples > 0) {
+        if (declared.flags.supports_web_search === true && grounding.grounded_rate < GROUNDED_BAR) {
+            out.push({
+                kind: "declared_search_ungrounded",
+                message: `declared supports_web_search, but only ${(grounding.grounded_rate * 100).toFixed(0)}% ` +
+                    `of probed answers carried citations (bar: ${GROUNDED_BAR * 100}%)`,
+            });
+        }
+        if (declared.flags.supports_web_search !== true && grounding.grounded_rate >= GROUNDED_BAR) {
+            out.push({
+                kind: "citations_without_declared_search",
+                message: `no declared web-search support, but ${(grounding.grounded_rate * 100).toFixed(0)}% of ` +
+                    `probed answers cited URLs — verify whether these are real or fabricated sources`,
+            });
+        }
+    }
+    const caching = probed.caching;
+    if (caching !== null && caching.samples > 0) {
+        // Guarded (launch-runbook A1, 2026-08-18): fire only when at least one
+        // sample passed the documented-path eligibility gate — a zero rate over
+        // zero eligible samples means the probe couldn't measure, not that the
+        // capability is unrealized. Pre-gate result files lack the field and
+        // keep the old behavior via the ?? fallback.
+        if (declared.flags.supports_prompt_caching === true &&
+            caching.cache_hit_rate === 0 &&
+            (caching.eligible_samples ?? caching.samples) > 0) {
+            out.push({
+                kind: "declared_caching_unrealized",
+                message: "declared supports_prompt_caching, but no eligible probed repeat call on the documented caching path reported cached tokens",
+            });
+        }
+    }
+    return out;
+}
+function buildRegistry(entries, generatedAt) {
+    return {
+        generated_at: generatedAt,
+        license: "CC-BY-4.0",
+        models: entries
+            .map((e) => ({
+            model_key: e.model_key,
+            declared: e.declared,
+            probed: e.probed,
+            observed: e.observed,
+            discrepancies: detectDiscrepancies(e.declared, e.probed),
+            callNotes: (0, call_notes_1.callNotesFor)(e.model_key),
+            facts: (0, claims_1.factsFor)(e.model_key),
+        }))
+            .sort((a, b) => (a.model_key < b.model_key ? -1 : 1)),
+    };
+}
+/** Leaderboard ranking metric — spec WS3: "conformance per dollar".
+ * Effective $ per 1K conformant outputs: mean sample cost ÷ conform rate
+ * × 1000. Null when unjudged or never conformant. */
+function effectiveCostPer1kConformant(schema) {
+    if (schema === null || schema.conform_rate === null || schema.conform_rate === 0)
+        return null;
+    return (schema.mean_cost_usd / schema.conform_rate) * 1000;
+}

package/dist/registry/cache-policy.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Cache Policy Registry — cache-aware-routing spec §3, [Briefing §7].
+ *
+ * Per-provider cache SEMANTICS as versioned DATA, never routing code: TTLs,
+ * refresh-on-read, minimum-cacheable prefix, key mechanism, telemetry dialect,
+ * endpoint affinity. A provider rule change (OpenAI shipping paid writes,
+ * Anthropic GA-ing the 1h TTL) becomes a data edit here with a new `as_of`, not
+ * a code change anywhere else — the whole point of the registry.
+ *
+ * TWO HOMES, both pre-existing (spec §3):
+ *   • RATES ride pricing — `ModelPricingV2.base.{cache_read,cache_write,
+ *     cache_write_1h}` and flat `ModelPricing.cacheWrite*UsdPerTok`, entered via
+ *     the pricing sweep with source+as_of. NOT here.
+ *   • POLICY (this file) is the non-price semantics.
+ *
+ * L5 (fail-closed): every field cites a first-party page (research §2.1, fetched
+ * 2026-08-18). A value we could not verify is `null` (or `cache_supported:
+ * false`) — never a guess. `getCachePolicy` returns a fail-closed
+ * `cache_supported: false` policy for any provider not seeded, identical posture
+ * to the zero-coverage gates.
+ *
+ * ── CROSS-REFERENCES (no import — the probes package is standalone since P2) ──
+ *   • `min_cacheable_tokens` is reconciled by hand against the probes package's
+ *     `MIN_CACHEABLE_TOKENS` (packages/modelrig-probes/src/caching.ts, PR #157),
+ *     which cites the same first-party pages. See MIN_CACHEABLE_RECONCILIATION
+ *     below for the value-by-value comparison and the two deliberate deltas
+ *     (anthropic, gemini) flagged for the architect to converge if desired. A
+ *     reciprocal comment lives in caching.ts.
+ *   • OBSERVED cache facts (`cache_hit_rate`, `mean_cached_tokens`,
+ *     `declared_caching_unrealized`) are materialized separately in
+ *     `src/registry/build.ts` from probe/production telemetry — the DECLARED
+ *     policy here is the counterpart truth, and the §5.6 streak alert (WS-C)
+ *     cross-references `declared_caching_unrealized` (same smell, other plane).
+ */
+import type { ProviderId } from "../types/provider";
+/**
+ * Per-provider cache semantics (spec §3). Additive to the registry's declared
+ * layer; every field is first-party-sourced or `null` (L5).
+ */
+export interface CachePolicy {
+    /** Whether the provider caches on the path ModelRig uses. false ⇒ every
+     * other field is moot (fail-closed). */
+    readonly cache_supported: boolean;
+    /** How caching is engaged. `explicit_breakpoints` = caller marks blocks
+     * (Anthropic cache_control); `automatic_prefix` = provider caches the longest
+     * matching prefix with no request change; `key_opt_in` = caller supplies a
+     * routing key (Mistral-style — no ModelRig provider uses it in v1). */
+    readonly mode: "explicit_breakpoints" | "automatic_prefix" | "key_opt_in";
+    /** Default cache lifetime, seconds. null ⇒ undocumented / best-effort. */
+    readonly default_ttl_seconds: number | null;
+    /** Extended-TTL option, seconds (Anthropic 1h write tier; OpenAI 24h
+     * retention). null ⇒ none published. */
+    readonly extended_ttl_seconds: number | null;
+    /** Whether a cache READ resets the TTL (Anthropic 5m: true). Conservative
+     * `false` when undocumented — under-claiming warmth never over-predicts a hit. */
+    readonly ttl_refresh_on_read: boolean;
+    /** Minimum prefix (tokens) below which caching silently does not engage.
+     * null ⇒ no documented minimum (L5). See MIN_CACHEABLE_RECONCILIATION. */
+    readonly min_cacheable_tokens: number | null;
+    /** The request parameter that engages/keys caching, or null for pure
+     * automatic caching with no caller control. */
+    readonly cache_key_param: "prompt_cache_key" | "cache_control" | "cachedContent" | null;
+    /** Whether cache-READ tokens are observable on the path ModelRig reads
+     * (usage JSON). false where they ride HTTP headers we do not yet lift. */
+    readonly reports_read_tokens: boolean;
+    /** Whether cache-WRITE (creation) tokens are separately reported. */
+    readonly reports_write_tokens: boolean;
+    /** Which usage shape the adapter normalizes from. */
+    readonly usage_dialect: "anthropic" | "openai_details" | "deepseek_partition" | "gemini_metadata" | "fireworks_headers";
+    /** true where the warm cache is endpoint-sticky and follow-ups must land on
+     * the same endpoint (research: OpenAI ~15 req/min/key; Fireworks
+     * x-session-affinity). */
+    readonly provider_affinity_required: boolean;
+    /** Provenance — same rule as pricing (first-party page). */
+    readonly source: string;
+    readonly as_of: string;
+    readonly policy_version: string;
+}
+/** The fail-closed policy for any provider not seeded (spec §3): caching is
+ * assumed OFF until a first-party source says otherwise — identical posture to
+ * the zero-coverage gates. `usage_dialect` defaults to the OpenAI shape only as
+ * a type-satisfying placeholder; `cache_supported: false` means no consumer
+ * reads it. */
+export declare function failClosedCachePolicy(): CachePolicy;
+/**
+ * The cache policy for a provider — the seeded first-party record, or a
+ * fail-closed `cache_supported: false` policy when the provider is not seeded
+ * (spec §3). Provider-level in v1; model-specific overrides land with the
+ * conversational-gateway phase.
+ */
+export declare function getCachePolicy(provider: ProviderId): CachePolicy;
+/** Every seeded provider — for tests and the console policy surface (WS-D). */
+export declare function seededCachePolicyProviders(): readonly ProviderId[];
+//# sourceMappingURL=cache-policy.d.ts.map

package/dist/registry/cache-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-policy.d.ts","sourceRoot":"","sources":["../../src/registry/cache-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;4CACwC;IACxC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC;;;2EAGuE;IACvE,QAAQ,CAAC,IAAI,EAAE,sBAAsB,GAAG,kBAAkB,GAAG,YAAY,CAAC;IAC1E,0EAA0E;IAC1E,QAAQ,CAAC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C;4CACwC;IACxC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C;sFACkF;IAClF,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC;8EAC0E;IAC1E,QAAQ,CAAC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C;mDAC+C;IAC/C,QAAQ,CAAC,eAAe,EAAE,kBAAkB,GAAG,eAAe,GAAG,eAAe,GAAG,IAAI,CAAC;IACxF;8EAC0E;IAC1E,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,qEAAqE;IACrE,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;IACvC,qDAAqD;IACrD,QAAQ,CAAC,aAAa,EAClB,WAAW,GACX,gBAAgB,GAChB,oBAAoB,GACpB,iBAAiB,GACjB,mBAAmB,CAAC;IACxB;;8BAE0B;IAC1B,QAAQ,CAAC,0BAA0B,EAAE,OAAO,CAAC;IAC7C,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AA8KD;;;;eAIe;AACf,wBAAgB,qBAAqB,IAAI,WAAW,CAiBnD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,CAEhE;AAED,+EAA+E;AAC/E,wBAAgB,0BAA0B,IAAI,SAAS,UAAU,EAAE,CAElE"}