modelrig 0.0.1 → 0.2.0

package/dist/registry/cache-policy.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * 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).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failClosedCachePolicy = failClosedCachePolicy;
+exports.getCachePolicy = getCachePolicy;
+exports.seededCachePolicyProviders = seededCachePolicyProviders;
+const AS_OF = "2026-08-18";
+/**
+ * min_cacheable_tokens reconciliation vs probes `MIN_CACHEABLE_TOKENS`
+ * (packages/modelrig-probes/src/caching.ts, PR #157). Same first-party pages;
+ * the two tables cannot share by import (probes is standalone). The probe table
+ * is a conservative PROBE-ELIGIBILITY gate — it decides whether to SPEND a
+ * paired probe call, so it errs toward the larger provider-wide bound. This
+ * registry records the documented minimum for the models ModelRig actually
+ * serves, for accounting/policy. Value-by-value (registry ⇄ probes):
+ *
+ *   anthropic  1024 ⇄ 2048   DELTA — registry = Sonnet 5 / Opus 4.8 minimum
+ *                            (the deployed frontier; Opus 5/Fable 5 = 512,
+ *                            Haiku up to 4096); probes uses a haiku-safe 2048.
+ *   openai     1024 ⇄ 1024   agree (automatic prefix engages ≥1024).
+ *   gemini     4096 ⇄ 2048   DELTA — registry = implicit-caching 4096-token
+ *                            minimum prefix (research §2.1 / spec §1.4); probes
+ *                            uses 2048. FLAGGED for the architect to converge.
+ *   deepseek   64   ⇄ 64     agree (64-token cache blocks).
+ *   grok       null ⇄ 1024*  registry = no documented minimum (L5 null);
+ *   deepinfra  null ⇄ 1024*  probes falls these to DEFAULT_MIN_CACHEABLE_TOKENS
+ *   fireworks  null ⇄ 1024*  (1024) as an operational gate. Deliberate divergence:
+ *                            the registry will not assert a minimum it cannot
+ *                            source first-party.
+ */
+const POLICIES = {
+    // Anthropic — explicit cache_control (≤4 breakpoints) + automatic top-level
+    // mode. Writes 1.25× (5m) / 2× (1h); reads 0.1×. platform.claude.com
+    // prompt-caching, fetched 2026-08-18 (research §2.1).
+    anthropic: {
+        cache_supported: true,
+        mode: "explicit_breakpoints",
+        default_ttl_seconds: 300, // 5-min ephemeral, refreshes free on read
+        extended_ttl_seconds: 3600, // 1h GA at the 2× write multiplier
+        ttl_refresh_on_read: true, // documented: a read refreshes the 5m window
+        min_cacheable_tokens: 1024, // Sonnet 5 / Opus 4.8 (deployed); see reconciliation
+        cache_key_param: "cache_control",
+        reports_read_tokens: true, // cache_read_input_tokens
+        reports_write_tokens: true, // cache_creation_input_tokens (+ 5m/1h split)
+        usage_dialect: "anthropic",
+        provider_affinity_required: false, // model-scoped/workspace-isolated, no endpoint stickiness
+        source: "platform.claude.com/docs prompt-caching (fetched 2026-08-18)",
+        as_of: AS_OF,
+        policy_version: AS_OF,
+    },
+    // OpenAI — automatic prefix caching (≤5.5 baseline). Reads 0.1×; writes free
+    // ≤5.5, and GPT-5.6+ adds explicit breakpoints + PAID writes (1.25×, exact
+    // 30-min TTL) reported as input_tokens_details.cache_write_tokens.
+    // developers.openai.com prompt-caching, fetched 2026-08-18 (research §2.1).
+    openai: {
+        cache_supported: true,
+        mode: "automatic_prefix", // 5.6+ additionally supports explicit_breakpoints
+        default_ttl_seconds: 600, // 5-10 min inactivity window (5.6+: exact 30 min)
+        extended_ttl_seconds: 86400, // optional 24h retention, same price
+        ttl_refresh_on_read: true, // inactivity-based window — activity extends it (≤5.5)
+        min_cacheable_tokens: 1024, // automatic prefix engages at ≥1024 tokens
+        cache_key_param: "prompt_cache_key", // routing hint (not required to cache)
+        reports_read_tokens: true, // prompt_tokens_details.cached_tokens
+        reports_write_tokens: true, // input_tokens_details.cache_write_tokens (5.6+; 0 on ≤5.5)
+        usage_dialect: "openai_details",
+        provider_affinity_required: true, // ~15 req/min/key affinity (research §2.5)
+        source: "developers.openai.com/docs prompt-caching (fetched 2026-08-18)",
+        as_of: AS_OF,
+        policy_version: AS_OF,
+    },
+    // DeepSeek — automatic disk cache, always on. Reads ~0.03× (deepest in
+    // market); writes free. Usage is a hit/miss PARTITION (not a subset).
+    // api-docs.deepseek.com, fetched 2026-08-18 (research §2.1).
+    deepseek: {
+        cache_supported: true,
+        mode: "automatic_prefix",
+        default_ttl_seconds: null, // "hours to days", no exact documented TTL
+        extended_ttl_seconds: null,
+        ttl_refresh_on_read: false, // undocumented → conservative
+        min_cacheable_tokens: 64, // 64-token cache blocks (matches probes)
+        cache_key_param: null, // pure automatic, no key
+        reports_read_tokens: true, // prompt_cache_hit_tokens
+        reports_write_tokens: false, // writes free; miss tokens are the non-cached input
+        usage_dialect: "deepseek_partition",
+        provider_affinity_required: false,
+        source: "api-docs.deepseek.com context-caching (fetched 2026-08-18)",
+        as_of: AS_OF,
+        policy_version: AS_OF,
+    },
+    // Gemini — implicit caching, default-on 2.5+. Reads 0.1×; writes free. TTL is
+    // undocumented best-effort. EXCLUDED from WS-C `cache: auto` (its adapter
+    // treats any cache.key as a cachedContents RESOURCE NAME and drops
+    // systemInstruction+tools — gemini.ts:145). ai.google.dev, fetched 2026-08-18.
+    gemini: {
+        cache_supported: true,
+        mode: "automatic_prefix",
+        default_ttl_seconds: null, // undocumented best-effort
+        extended_ttl_seconds: null,
+        ttl_refresh_on_read: false, // undocumented → conservative
+        min_cacheable_tokens: 4096, // implicit-caching minimum prefix (spec §1.4); see reconciliation
+        cache_key_param: null, // implicit only; the cachedContents API is a different (explicit) product
+        reports_read_tokens: true, // usageMetadata.cachedContentTokenCount
+        reports_write_tokens: false,
+        usage_dialect: "gemini_metadata",
+        provider_affinity_required: false,
+        source: "ai.google.dev/gemini-api context-caching (fetched 2026-08-18)",
+        as_of: AS_OF,
+        policy_version: AS_OF,
+    },
+    // Grok (xAI) — automatic caching; reads 0.25× (Grok 4.6, model-varying),
+    // writes free. TTL ~5 min (3rd-party). docs.x.ai, fetched 2026-08-18.
+    grok: {
+        cache_supported: true,
+        mode: "automatic_prefix",
+        default_ttl_seconds: 300, // ~5 min (3rd-party; not first-party confirmed)
+        extended_ttl_seconds: null,
+        ttl_refresh_on_read: false, // undocumented → conservative
+        min_cacheable_tokens: null, // no documented minimum (L5)
+        cache_key_param: "prompt_cache_key", // x-grok-conv-id / prompt_cache_key hint
+        reports_read_tokens: true, // prompt_tokens_details.cached_tokens (compat)
+        reports_write_tokens: false,
+        usage_dialect: "openai_details",
+        provider_affinity_required: false, // team-scoped, undocumented
+        source: "docs.x.ai prompt-caching (fetched 2026-08-18)",
+        as_of: AS_OF,
+        policy_version: AS_OF,
+    },
+    // Fireworks — automatic caching on all models; reads ~0.5× serverless / free
+    // dedicated. Usage rides HTTP HEADERS (fireworks-prompt-tokens /
+    // -cached-prompt-tokens), NOT the usage JSON the openai-compat adapter reads —
+    // so cache tokens are NOT observable on our path today (header lift is a
+    // spec non-goal / flagged follow-up). docs.fireworks.ai, fetched 2026-08-18.
+    fireworks: {
+        cache_supported: true,
+        mode: "automatic_prefix",
+        default_ttl_seconds: null, // minutes-to-hours LRU, no exact
+        extended_ttl_seconds: null,
+        ttl_refresh_on_read: false,
+        min_cacheable_tokens: null,
+        cache_key_param: null,
+        reports_read_tokens: false, // header-based; not read by our usage-JSON path yet
+        reports_write_tokens: false,
+        usage_dialect: "fireworks_headers",
+        provider_affinity_required: true, // x-session-affinity
+        source: "docs.fireworks.ai prompt-caching (fetched 2026-08-18)",
+        as_of: AS_OF,
+        policy_version: AS_OF,
+    },
+    // DeepInfra — caching on SELECT models only (DeepSeek V3.x, Qwen3, some
+    // Claude), cached rates unverified first-party. Fail-closed to
+    // cache_supported:false, matching DeepInfra's existing pricing posture
+    // (pricing-sweep sweepDeepInfra: base-only, richer fields unverified, L5).
+    deepinfra: {
+        cache_supported: false,
+        mode: "automatic_prefix",
+        default_ttl_seconds: null,
+        extended_ttl_seconds: null,
+        ttl_refresh_on_read: false,
+        min_cacheable_tokens: null,
+        cache_key_param: null,
+        reports_read_tokens: false,
+        reports_write_tokens: false,
+        usage_dialect: "openai_details",
+        provider_affinity_required: false,
+        source: "deepinfra — cached rates unverified first-party (fail-closed, L5)",
+        as_of: AS_OF,
+        policy_version: AS_OF,
+    },
+};
+/** 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. */
+function failClosedCachePolicy() {
+    return {
+        cache_supported: false,
+        mode: "automatic_prefix",
+        default_ttl_seconds: null,
+        extended_ttl_seconds: null,
+        ttl_refresh_on_read: false,
+        min_cacheable_tokens: null,
+        cache_key_param: null,
+        reports_read_tokens: false,
+        reports_write_tokens: false,
+        usage_dialect: "openai_details",
+        provider_affinity_required: false,
+        source: "unseeded provider — fail-closed (no first-party cache policy)",
+        as_of: AS_OF,
+        policy_version: AS_OF,
+    };
+}
+/**
+ * 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.
+ */
+function getCachePolicy(provider) {
+    return POLICIES[provider] ?? failClosedCachePolicy();
+}
+/** Every seeded provider — for tests and the console policy surface (WS-D). */
+function seededCachePolicyProviders() {
+    return Object.keys(POLICIES);
+}

package/dist/registry/call-notes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Per-model call-shaping knowledge as data — addendum A1 (Phase 2), closed as
+ * post-C2 patch P1 (Phase 3 step 0). Seeded from the adapters' documented
+ * constraints (the same facts the adapter code enforces); consumed by the
+ * registry artifact today and the Phase 5 oracle's `get_call_notes` later.
+ * Registry entries carry these top-level as `callNotes[]`; the Supabase
+ * mirror rides them inside the existing `declared` jsonb (no migration).
+ */
+/** Call notes for a "provider/model" key; [] for unknown providers. */
+export declare function callNotesFor(modelKey: string): readonly string[];
+//# sourceMappingURL=call-notes.d.ts.map

package/dist/registry/call-notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-notes.d.ts","sourceRoot":"","sources":["../../src/registry/call-notes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAwCH,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAkEhE"}

package/dist/registry/call-notes.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Per-model call-shaping knowledge as data — addendum A1 (Phase 2), closed as
+ * post-C2 patch P1 (Phase 3 step 0). Seeded from the adapters' documented
+ * constraints (the same facts the adapter code enforces); consumed by the
+ * registry artifact today and the Phase 5 oracle's `get_call_notes` later.
+ * Registry entries carry these top-level as `callNotes[]`; the Supabase
+ * mirror rides them inside the existing `declared` jsonb (no migration).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callNotesFor = callNotesFor;
+/** Models that accept thinkingConfig — mirror of the gemini adapter's set. */
+const GEMINI_THINKING_CAPABLE = new Set([
+    "gemini-3.1-pro-preview",
+    "gemini-3.0-pro-preview",
+    "gemini-3.1-flash-preview",
+]);
+/**
+ * Models whose published probe measurements predate the provider-default
+ * reasoning policy (architect ruling, 2026-08-10): probe cycles 001–002
+ * pinned thinkingConfig thinkingLevel "high" on this set, inflating output
+ * tokens (billed as output) and therefore the effective-cost figure. The only
+ * board model affected. Remove each entry once its cycle-003 re-measure
+ * (provider-default thinking) is published.
+ */
+const GEMINI_PROBED_AT_THINKING_HIGH = new Set(["gemini-3.1-pro-preview"]);
+const GEMINI_COMMON = [
+    "temperature must be 1.0 — lower values cause output looping on Gemini 3 models",
+    "native strict structured output via responseJsonSchema; very complex schemas can be rejected as INVALID_ARGUMENT (complexity ceiling)",
+    "native web grounding via the googleSearch tool",
+    "cachedContent excludes systemInstruction and tools — bake the system prompt (and the googleSearch tool for grounded steps) into the cache at creation time",
+];
+const OPENAI_COMMON = [
+    "native strict structured output via response_format json_schema with strict: true",
+    "streamed refusal deltas are terminal for the call, even alongside partial content",
+    "prompt caching is keyed via prompt_cache_key; retention extends to 24h when the cache directive's TTL is ≥ 86400s",
+    "finish_reason=stop with <200 visible completion tokens on a 50K+ token prompt indicates flex-tier degradation or a stream drop — treat as invalid, not success",
+];
+const DEEPSEEK_COMMON = [
+    "no native json_schema — json_object forcing only; the schema must be coached into the prompt and validated caller-side",
+    'json_object mode returns 400 unless the literal word "JSON" appears in the prompt',
+    "automatic prefix caching: prompt_cache_hit_tokens are billed ~10x cheaper than fresh input",
+    "no service tiers — served tier is always standard",
+];
+/** Call notes for a "provider/model" key; [] for unknown providers. */
+function callNotesFor(modelKey) {
+    const slash = modelKey.indexOf("/");
+    if (slash <= 0)
+        return [];
+    const provider = modelKey.slice(0, slash);
+    const model = modelKey.slice(slash + 1);
+    switch (provider) {
+        case "gemini":
+            return [
+                ...GEMINI_COMMON,
+                GEMINI_THINKING_CAPABLE.has(model)
+                    ? "accepts thinkingConfig (thinking level); thinking tokens are billed as output and count against maxOutputTokens"
+                    : "does NOT accept thinkingConfig — sending it returns 400 (thinking models only)",
+                ...(GEMINI_PROBED_AT_THINKING_HIGH.has(model)
+                    ? [
+                        "probe cycles 001-002 measured this model at thinking level high; probes run at provider-default thinking from cycle 003, and the published cost figure is re-measured then",
+                    ]
+                    : []),
+            ];
+        case "openai": {
+            // The Pro tier is Responses-API only (v1/chat/completions returns "not a
+            // chat model") — probed via the responses caller (coverage follow-ups
+            // 2026-08-11). Reasoning tokens bill as output at the Pro rate.
+            const responsesOnly = model.endsWith("-pro");
+            const flexEligible = !model.includes("-mini") &&
+                !model.includes("-nano") &&
+                !responsesOnly &&
+                ["gpt-5.4", "gpt-5.2", "gpt-5.1", "gpt-5", "gpt-4.1"].some((p) => model.startsWith(p));
+            return [
+                ...OPENAI_COMMON,
+                ...(responsesOnly
+                    ? [
+                        "Responses-API only — v1/chat/completions rejects it ('not a chat model'); probed via the v1/responses caller with strict json_schema output; reasoning tokens are billed as output at the Pro rate",
+                    ]
+                    : []),
+                flexEligible
+                    ? "flex service tier eligible — discounted, sheddable capacity; served tier is echoed on the stream"
+                    : "NOT flex-eligible (mini/nano, Pro, and older families) — flex requests are silently served at default tier",
+            ];
+        }
+        case "deepseek": {
+            // Alias resolution (coverage follow-ups, verified 2026-08-11 against the
+            // live models list + a call to each): DeepSeek's model list now shows only
+            // deepseek-v4-flash / deepseek-v4-pro; the classic `deepseek-chat` and
+            // `deepseek-reasoner` are rolling ALIASES that both currently resolve to
+            // deepseek-v4-flash (the API echoes `model: "deepseek-v4-flash"`). They are
+            // alive, not retired — kept on the board with this note. reasoner is
+            // v4-flash in reasoning mode.
+            const aliasNote = model === "deepseek-chat"
+                ? "rolling alias — currently serves deepseek-v4-flash (API echoes model=deepseek-v4-flash, verified 2026-08-11); alive despite being absent from the models list"
+                : model === "deepseek-reasoner"
+                    ? "rolling alias — currently serves deepseek-v4-flash in reasoning mode (API echoes model=deepseek-v4-flash, verified 2026-08-11); alive despite being absent from the models list"
+                    : "listed as a current DeepSeek model (deepseek-v4-*), 2026-08-11";
+            return [
+                ...DEEPSEEK_COMMON,
+                model.includes("reasoner")
+                    ? "emits reasoning_content (chain-of-thought) deltas — exclude them from the JSON buffer; only delta.content is the answer"
+                    : "max_tokens up to 64K — full capacity for long structured reports",
+                aliasNote,
+            ];
+        }
+        default:
+            return [];
+    }
+}

package/dist/registry/claims.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Curated credential-scoped claims — Phase 4 WS3 fact-shape upgrade.
+ * Every fact is {value, scope, source, as_of}: WHAT is claimed, UNDER WHICH
+ * CREDENTIAL it holds, WHERE it's cited, and WHEN it was checked.
+ *
+ * Scope semantics (the TrustedRouter lesson): a provider's zero-data-
+ * retention arrangement on OUR managed account does not transfer to a
+ * customer's own (BYOK) key — the same capability can be true on one
+ * credential and false on the other, and conflating them is a compliance
+ * hazard. Conservative default: models/facts absent here are absent from
+ * the registry — false-until-cited, same doctrine as probed-beats-declared.
+ *
+ * This is the curated seed (same pattern as call-notes.ts); probe-derived
+ * facts can join the same shape later without changing consumers.
+ */
+export declare const SCOPES: readonly ["managed", "byok", "any"];
+export type FactScope = (typeof SCOPES)[number];
+export interface ScopedFact {
+    readonly value: boolean | string | number;
+    /** Which credential the claim holds under: the vendor-managed account,
+     * a bring-your-own-key credential, or any. */
+    readonly scope: FactScope;
+    /** Citation — a URL or document reference; never "we assume". */
+    readonly source: string;
+    readonly as_of: string;
+}
+export type ModelFacts = Readonly<Record<string, readonly ScopedFact[]>>;
+/** Facts for a model, or null when nothing is cited (the conservative
+ * default — absence is the claim). */
+export declare function factsFor(modelKey: string): ModelFacts | null;
+/** Which credential an account is calling a model under. Phase 6 WS3: the
+ * telemetry `key_ownership` dimension, seen from the registry's side. */
+export type CredentialOwnership = "managed" | "byok";
+/** A fact resolved to what holds under ONE credential. */
+export interface CredentialScopedFact {
+    readonly value: boolean | string | number;
+    readonly source: string;
+    readonly as_of: string;
+    /**
+     * True when a fact is cited for THIS credential (its own scope or `any`).
+     * False means "not established for your key" — the honest answer when a
+     * fact holds only under our managed account and the account is BYOK. It is
+     * NEVER silently promoted to the managed value.
+     */
+    readonly established: boolean;
+}
+/**
+ * Render a model's facts as they hold under ONE account's credential — Phase 6
+ * WS3, the "credential-scoped facts render per account" deliverable.
+ *
+ * THE RULE, and the whole reason this exists: **a BYOK key does not inherit our
+ * managed-account posture.** If `zero_retention` is cited `true` under
+ * `managed` and nothing is cited under `byok`, a BYOK account sees
+ * `established: false` — not `true`. Inheriting the managed value onto a
+ * customer's own key is the exact compliance hazard claims.ts's scope field
+ * exists to prevent (the TrustedRouter lesson). An `any`-scoped fact holds on
+ * every credential; a scope-specific fact holds only on its own.
+ *
+ * Returns one entry per fact NAME, so a caller (the console's model surface)
+ * can render "zero retention: yes / not established for your key" honestly.
+ */
+export declare function factsUnderCredential(modelKey: string, ownership: CredentialOwnership): Readonly<Record<string, CredentialScopedFact>>;
+//# sourceMappingURL=claims.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claims.d.ts","sourceRoot":"","sources":["../../src/registry/claims.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,MAAM,qCAAsC,CAAC;AAC1D,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAC1C;kDAC8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC,CAAC,CAAC;AA0CzE;sCACsC;AACtC,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAE5D;AAED;yEACyE;AACzE,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,MAAM,CAAC;AAErD,0DAA0D;AAC1D,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,mBAAmB,GAC7B,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAwBhD"}

package/dist/registry/claims.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Curated credential-scoped claims — Phase 4 WS3 fact-shape upgrade.
+ * Every fact is {value, scope, source, as_of}: WHAT is claimed, UNDER WHICH
+ * CREDENTIAL it holds, WHERE it's cited, and WHEN it was checked.
+ *
+ * Scope semantics (the TrustedRouter lesson): a provider's zero-data-
+ * retention arrangement on OUR managed account does not transfer to a
+ * customer's own (BYOK) key — the same capability can be true on one
+ * credential and false on the other, and conflating them is a compliance
+ * hazard. Conservative default: models/facts absent here are absent from
+ * the registry — false-until-cited, same doctrine as probed-beats-declared.
+ *
+ * This is the curated seed (same pattern as call-notes.ts); probe-derived
+ * facts can join the same shape later without changing consumers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCOPES = void 0;
+exports.factsFor = factsFor;
+exports.factsUnderCredential = factsUnderCredential;
+exports.SCOPES = ["managed", "byok", "any"];
+/** The curated claims table. Add entries WITH citations only. */
+const CLAIMS = {
+    "openai/gpt-5.4-mini": {
+        zero_retention: [
+            {
+                // OpenAI's API-platform data controls: eligible orgs can be approved
+                // for zero data retention on the API — an ACCOUNT property, granted
+                // to our managed platform account.
+                value: true,
+                scope: "managed",
+                source: "https://platform.openai.com/docs/models/how-we-use-your-data",
+                as_of: "2026-08-02",
+            },
+            {
+                // The same claim does NOT transfer to a customer's own key: a BYOK
+                // org has whatever retention ITS account negotiated — unknowable
+                // from here, so the honest value is false (not "probably fine").
+                value: false,
+                scope: "byok",
+                source: "https://platform.openai.com/docs/models/how-we-use-your-data",
+                as_of: "2026-08-02",
+            },
+        ],
+    },
+    "gemini/gemini-3.1-pro-preview": {
+        zero_retention: [
+            {
+                // Paid-tier Gemini API: prompts/outputs not used for training, but
+                // retained transiently for abuse monitoring — that is NOT zero
+                // retention, on any credential. Recorded false to keep the registry
+                // honest where marketing language blurs.
+                value: false,
+                scope: "any",
+                source: "https://ai.google.dev/gemini-api/terms",
+                as_of: "2026-08-02",
+            },
+        ],
+    },
+};
+/** Facts for a model, or null when nothing is cited (the conservative
+ * default — absence is the claim). */
+function factsFor(modelKey) {
+    return CLAIMS[modelKey] ?? null;
+}
+/**
+ * Render a model's facts as they hold under ONE account's credential — Phase 6
+ * WS3, the "credential-scoped facts render per account" deliverable.
+ *
+ * THE RULE, and the whole reason this exists: **a BYOK key does not inherit our
+ * managed-account posture.** If `zero_retention` is cited `true` under
+ * `managed` and nothing is cited under `byok`, a BYOK account sees
+ * `established: false` — not `true`. Inheriting the managed value onto a
+ * customer's own key is the exact compliance hazard claims.ts's scope field
+ * exists to prevent (the TrustedRouter lesson). An `any`-scoped fact holds on
+ * every credential; a scope-specific fact holds only on its own.
+ *
+ * Returns one entry per fact NAME, so a caller (the console's model surface)
+ * can render "zero retention: yes / not established for your key" honestly.
+ */
+function factsUnderCredential(modelKey, ownership) {
+    const facts = CLAIMS[modelKey];
+    if (facts === undefined)
+        return {};
+    const out = {};
+    for (const [name, claims] of Object.entries(facts)) {
+        // Prefer the credential-specific claim; fall back to an `any` claim; never
+        // borrow the OTHER credential's claim.
+        const specific = claims.find((c) => c.scope === ownership);
+        const anyScoped = claims.find((c) => c.scope === "any");
+        const chosen = specific ?? anyScoped;
+        if (chosen !== undefined) {
+            out[name] = {
+                value: chosen.value,
+                source: chosen.source,
+                as_of: chosen.as_of,
+                established: true,
+            };
+        }
+        else {
+            // A managed-only fact seen from a BYOK account (or vice-versa): not
+            // inherited. The value is the conservative false, flagged not-established.
+            out[name] = { value: false, source: claims[0]?.source ?? "", as_of: claims[0]?.as_of ?? "", established: false };
+        }
+    }
+    return out;
+}