modelrig 0.8.1 → 0.10.0

package/dist/routes/resolved-bundle.js

@@ -27,6 +27,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveRouteBundle = resolveRouteBundle;
+exports.assertMirrorSafe = assertMirrorSafe;
 exports.canonicalBundleJson = canonicalBundleJson;
 exports.hashResolvedBundle = hashResolvedBundle;
 exports.bundleFromResolved = bundleFromResolved;
@@ -34,6 +35,7 @@ exports.singleRouteStore = singleRouteStore;
 const node_crypto_1 = require("node:crypto");
 const fingerprint_1 = require("../registry/fingerprint");
 const loader_1 = require("./loader");
+const policy_1 = require("../screen/policy");
 /** Project an already-loaded (resolved) bundle to its serialisable form. Pure —
  * no filesystem; the loader already followed every file reference. */
 function resolveRouteBundle(bundle) {
@@ -41,18 +43,63 @@ function resolveRouteBundle(bundle) {
         route: bundle.route,
         version: bundle.version,
         outputSchema: bundle.outputSchema,
+        // Issue #1: prose contract crosses the wire (text only; json adds no key).
+        ...(bundle.outputKind === "text" ? { outputKind: "text" } : {}),
+        ...(bundle.outputKind === "text" && bundle.outputMinChars !== undefined ? { outputMinChars: bundle.outputMinChars } : {}),
         candidates: bundle.candidates,
         require: bundle.require,
         prefer: bundle.prefer,
         systemTemplate: bundle.systemTemplate,
+        ...(bundle.userTemplate !== undefined ? { userTemplate: bundle.userTemplate } : {}), // issue #5 (R1)
         variables: bundle.variables,
         policy: bundle.policy,
         ...(bundle.repair !== undefined ? { repair: bundle.repair } : {}),
         variants: bundle.variants,
         capture: bundle.capture,
         ...(bundle.groundingQuery !== undefined ? { groundingQuery: bundle.groundingQuery } : {}),
+        ...(bundle.groundingAssembly !== undefined ? { groundingAssembly: bundle.groundingAssembly } : {}),
+        ...(bundle.variableTrust !== undefined ? { variableTrust: bundle.variableTrust } : {}),
+        // SC-1b mirror fix (req 1): carry the RAW screen policy (re-resolved on the
+        // gateway) + the fully-resolved mask policy (entries inlined) so neither is
+        // silently inert on the hosted lane. Absent ⇒ omitted ⇒ byte-identical.
+        ...(bundle.screen !== undefined ? { screenPolicy: bundle.screen.policy } : {}),
+        ...(bundle.mask !== undefined ? { mask: bundle.mask } : {}),
+        // PSR-2: carry the served prompt's manifest so promote's write-through and the
+        // round-trip both preserve it. Absent ⇒ omitted ⇒ byte-identical.
+        ...(bundle.manifest !== undefined ? { manifest: bundle.manifest } : {}),
     };
 }
+/**
+ * Refuse-on-export guard (SC-1b req 1 — the #322 QA finding). A route that
+ * declares `screen: enforce` MUST be guaranteed to re-resolve its enforcement on
+ * the hosted (mirror) lane, or the hosted lane silently fails open. The mirror
+ * rebuilds the screen policy with `resolveScreenPolicy`, which ALWAYS builds the
+ * T0 pattern detector deterministically (no filesystem) — so a pure-T0 enforce
+ * policy re-resolves identically and mirrors safely. A T1 `classifier:` detector,
+ * though, depends on gateway-local weights the mirror cannot guarantee: there it
+ * would DEGRADE to T0 SILENTLY, weaker than what was authored and proven. Rather
+ * than ship a silently-degraded enforce we REFUSE at export with a teaching
+ * error. `mask` needs no guard: its resolved policy (dictionary entries inlined)
+ * crosses the wire whole and re-materialises identically.
+ *
+ * Called from the exporter (`buildExportedRouteMirrors`) — a hard failure at
+ * SYNC, on the developer's machine, never a silent inert enforce at request.
+ */
+function assertMirrorSafe(bundle) {
+    const screen = bundle.screen;
+    if (screen === undefined || screen.policy.mode !== "enforce")
+        return;
+    const classifiers = (screen.policy.detectors ?? []).filter((d) => d.startsWith("classifier:"));
+    if (classifiers.length > 0) {
+        throw new loader_1.RouteConfigError(`route "${bundle.route}" declares screen.mode: enforce with a classifier detector ` +
+            `(${classifiers.join(", ")}), which cannot be guaranteed to re-resolve on the hosted ` +
+            `(mirror) lane: the gateway has no access to the local classifier weights and would ` +
+            `silently DEGRADE to the T0 pattern tier — an enforce weaker than the one you authored ` +
+            `and proved. Fix: self-host this route, or drop the classifier from the enforce policy ` +
+            `(T0 patterns re-resolve deterministically on the mirror; the classifier stays a signal ` +
+            `under detect). Spec: screening §4.3, SC-1b req 1.`);
+    }
+}
 /** Deterministic JSON: object keys sorted recursively, array order preserved.
  * The whole point is that the SAME bundle always produces the SAME bytes, so
  * the content hash is stable across processes and machines. */
@@ -105,20 +152,49 @@ function bundleFromResolved(raw) {
         throw new loader_1.RouteConfigError(`mirrored route bundle "${b.route}" is missing \`policy\``);
     }
     const outputSchema = b.outputSchema ?? null;
+    // Issue #1: a mirrored `output: text` route rebuilds as text (never JSON-parsed
+    // on the hosted lane). Anything but the literal "text" ⇒ json (byte-identical);
+    // text + a schema is a corrupt mirror (the loader refuses that pair at author).
+    const outputKind = b.outputKind === "text" ? "text" : undefined;
+    if (outputKind === "text" && outputSchema !== null) {
+        throw new loader_1.RouteConfigError(`mirrored route bundle "${b.route}" declares output: text AND a schema — remove one`);
+    }
+    const minChars = b.outputMinChars;
+    const outputMinChars = outputKind === "text" && typeof minChars === "number" && Number.isInteger(minChars) && minChars >= 1 ? minChars : undefined;
     return Object.freeze({
         route: b.route,
         version: b.version,
         outputSchema: outputSchema === null ? null : Object.freeze(outputSchema),
+        ...(outputKind !== undefined ? { outputKind } : {}),
+        ...(outputMinChars !== undefined ? { outputMinChars } : {}),
         candidates: Object.freeze([...b.candidates]),
         require: Object.freeze([...(b.require ?? [])]),
         prefer: Object.freeze([...(b.prefer ?? [])]),
         systemTemplate: b.systemTemplate,
+        // Issue #5 (R1): a mirrored `prompt.user` rebuilds as the user turn; anything
+        // but a non-empty string ⇒ absent ⇒ the fixed trigger (byte-identical).
+        ...(typeof b.userTemplate === "string" && b.userTemplate !== "" ? { userTemplate: b.userTemplate } : {}),
         variables: Object.freeze([...(b.variables ?? [])]),
         policy: b.policy,
         ...(b.repair !== undefined ? { repair: b.repair } : {}),
         variants: Object.freeze([...(b.variants ?? [])]),
         capture: b.capture === true,
         ...(b.groundingQuery !== undefined ? { groundingQuery: b.groundingQuery } : {}),
+        ...(b.groundingAssembly !== undefined ? { groundingAssembly: b.groundingAssembly } : {}),
+        ...(b.variableTrust !== undefined ? { variableTrust: Object.freeze({ ...b.variableTrust }) } : {}),
+        // SC-1b mirror fix (req 1): RE-RESOLVE the raw screen policy so `route.screen`
+        // is a live `ResolvedScreenPolicy` (built detectors) on the hosted lane — no
+        // longer `undefined` (the silent fail-open). `resolveScreenPolicy` always
+        // builds the T0 pattern detector; a configured-but-absent T1 classifier
+        // degrades to T0 with `degraded: true` (never a silent inert enforce — and
+        // `assertMirrorSafe` already refused a T1-classifier enforce at export).
+        ...(b.screenPolicy !== undefined ? { screen: (0, policy_1.resolveScreenPolicy)(b.screenPolicy) } : {}),
+        // Mask carries its FULLY-RESOLVED policy (entries inlined) — passed through,
+        // re-materialising byte-identically so `mask: block` is never inert.
+        ...(b.mask !== undefined ? { mask: b.mask } : {}),
+        // PSR-2: the served prompt's structure-only manifest, passed through whole
+        // (no re-resolve — it carries no filesystem/closure state). Absent ⇒ omitted.
+        ...(b.manifest !== undefined ? { manifest: b.manifest } : {}),
         // Recomputed, never trusted from the wire — cannot drift from the schema.
         fingerprintCell: (0, fingerprint_1.fingerprintSchema)(outputSchema)?.cellKey ?? null,
     });

package/dist/routes/screen-loader.d.ts

@@ -4,10 +4,38 @@
  * Pure functions that push into the shared `problems[]`; unit-tested directly.
  * Spec: docs/ModelRig/screening/spec.md §2.4 (S1 assembly knob, S2 x-trust).
  */
+import type { ResolvedScreenPolicy } from "../screen/types";
+import type { DataClassification } from "../artifacts/classification";
+import type { ResolvedMaskPolicy } from "../mask/types";
+import type { Requirement } from "../types/route";
+/**
+ * Parse + resolve the optional `screen:` block (SC-1a, spec §4.1). Returns the
+ * resolved policy, or `undefined` when the block is absent OR `mode: off` (both
+ * ⇒ byte-identical, no screening). Pushes teaching-style problems for a
+ * malformed block: an unknown detector / action, or a `sources` key that loosens
+ * a default tier, is a LOAD error (validated at the SAME point as `require:` /
+ * `mask:`). A configured-but-unavailable optional classifier is NOT a load error
+ * — resolution degrades to T0 (spec §4.3), surfaced later on the receipt.
+ */
+export declare function parseScreenBlock(raw: unknown, problems: string[]): ResolvedScreenPolicy | undefined;
+/**
+ * SC-2 (spec-sc2 §4): parse the route-level `classification` (rides the 00058
+ * `data_classification` enum — zero-DDL) and, for a `phi` value, GATE the route
+ * posture at load. A `phi` route must mask (≥ redact) AND (`require:
+ * zero_retention` OR a `sidecar` detector present), else it refuses to load with
+ * the specific teaching message (checkPhiPosture). Returns the parsed
+ * classification, or `undefined` when absent/invalid (an invalid value is a
+ * pushed problem). Runs at the same point as `require:` / `mask:` / `screen:`.
+ */
+export declare function parseClassificationAndPhiGate(raw: unknown, ctx: {
+    mask?: ResolvedMaskPolicy;
+    screen?: ResolvedScreenPolicy;
+    require: readonly Requirement[];
+}, problems: string[]): DataClassification | undefined;
 /** Push a problem for every `{{var}}` referenced in the system template or the
  * grounding query that was not declared in `prompt.variables`. Colocated with
  * the variable parser it validates. */
-export declare function pushUndeclaredVariableProblems(systemTemplate: string, groundingQuery: string | undefined, variables: readonly string[], problems: string[]): void;
+export declare function pushUndeclaredVariableProblems(systemTemplate: string, groundingQuery: string | undefined, variables: readonly string[], problems: string[], userTemplate?: string): void;
 /** Parse `prompt.variables` — each entry is a bare name (semi, stays in the
  * system slot — the default) or `{name, "x-trust": "untrusted"}` (spotlighted out
  * of the system slot, S2). Returns the declared names and, when any variable is

package/dist/routes/screen-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"screen-loader.d.ts","sourceRoot":"","sources":["../../src/routes/screen-loader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH;;uCAEuC;AACvC,wBAAgB,8BAA8B,CAC5C,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,EAAE,MAAM,EAAE,GACjB,IAAI,CAcN;AAED;;;iFAGiF;AACjF,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAAE,GACjB;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;CAAE,CAwB5E;AAED;;iFAEiF;AACjF,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,QAAQ,EAAE,MAAM,EAAE,GACjB,QAAQ,GAAG,WAAW,GAAG,SAAS,CAQpC"}
+{"version":3,"file":"screen-loader.d.ts","sourceRoot":"","sources":["../../src/routes/screen-loader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAG5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAMlD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,oBAAoB,GAAG,SAAS,CAUnG;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE;IAAE,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAA;CAAE,EAClG,QAAQ,EAAE,MAAM,EAAE,GACjB,kBAAkB,GAAG,SAAS,CAYhC;AAED;;uCAEuC;AACvC,wBAAgB,8BAA8B,CAC5C,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,CAAC,EAAE,MAAM,GACpB,IAAI,CAqBN;AAED;;;iFAGiF;AACjF,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAAE,GACjB;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;CAAE,CAwB5E;AAED;;iFAEiF;AACjF,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,QAAQ,EAAE,MAAM,EAAE,GACjB,QAAQ,GAAG,WAAW,GAAG,SAAS,CAQpC"}

package/dist/routes/screen-loader.js

@@ -6,17 +6,68 @@
  * Spec: docs/ModelRig/screening/spec.md §2.4 (S1 assembly knob, S2 x-trust).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScreenBlock = parseScreenBlock;
+exports.parseClassificationAndPhiGate = parseClassificationAndPhiGate;
 exports.pushUndeclaredVariableProblems = pushUndeclaredVariableProblems;
 exports.parseVariables = parseVariables;
 exports.parseGroundingAssembly = parseGroundingAssembly;
 const template_1 = require("./template");
+const policy_1 = require("../screen/policy");
+const phi_gate_1 = require("../screen/phi-gate");
+const classification_1 = require("../artifacts/classification");
 function isRecord(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);
 }
+/**
+ * Parse + resolve the optional `screen:` block (SC-1a, spec §4.1). Returns the
+ * resolved policy, or `undefined` when the block is absent OR `mode: off` (both
+ * ⇒ byte-identical, no screening). Pushes teaching-style problems for a
+ * malformed block: an unknown detector / action, or a `sources` key that loosens
+ * a default tier, is a LOAD error (validated at the SAME point as `require:` /
+ * `mask:`). A configured-but-unavailable optional classifier is NOT a load error
+ * — resolution degrades to T0 (spec §4.3), surfaced later on the receipt.
+ */
+function parseScreenBlock(raw, problems) {
+    if (raw === undefined)
+        return undefined;
+    const shapeProblems = (0, policy_1.validateScreenPolicyShape)(raw);
+    if (shapeProblems.length > 0) {
+        for (const p of shapeProblems)
+            problems.push(`screen: ${p}`);
+        return undefined;
+    }
+    const policy = (0, policy_1.parseScreenPolicy)(raw);
+    if (policy.mode === "off")
+        return undefined; // off ⇒ no screening, byte-identical
+    return (0, policy_1.resolveScreenPolicy)(policy);
+}
+/**
+ * SC-2 (spec-sc2 §4): parse the route-level `classification` (rides the 00058
+ * `data_classification` enum — zero-DDL) and, for a `phi` value, GATE the route
+ * posture at load. A `phi` route must mask (≥ redact) AND (`require:
+ * zero_retention` OR a `sidecar` detector present), else it refuses to load with
+ * the specific teaching message (checkPhiPosture). Returns the parsed
+ * classification, or `undefined` when absent/invalid (an invalid value is a
+ * pushed problem). Runs at the same point as `require:` / `mask:` / `screen:`.
+ */
+function parseClassificationAndPhiGate(raw, ctx, problems) {
+    if (raw === undefined || raw === null)
+        return undefined;
+    const norm = (0, classification_1.normalizeClassification)(raw);
+    if (norm === null || !classification_1.DATA_CLASSIFICATIONS.includes(norm)) {
+        problems.push(`classification "${String(raw)}" is not one of ${classification_1.DATA_CLASSIFICATIONS.join(" | ")}`);
+        return undefined;
+    }
+    const classification = norm;
+    for (const p of (0, phi_gate_1.checkPhiPosture)({ classification, mask: ctx.mask, screen: ctx.screen, require: ctx.require })) {
+        problems.push(`phi posture: ${p}`);
+    }
+    return classification;
+}
 /** Push a problem for every `{{var}}` referenced in the system template or the
  * grounding query that was not declared in `prompt.variables`. Colocated with
  * the variable parser it validates. */
-function pushUndeclaredVariableProblems(systemTemplate, groundingQuery, variables, problems) {
+function pushUndeclaredVariableProblems(systemTemplate, groundingQuery, variables, problems, userTemplate) {
     const declared = new Set(variables);
     if (systemTemplate !== "") {
         for (const ref of (0, template_1.scanTemplateVariables)(systemTemplate)) {
@@ -25,6 +76,13 @@ function pushUndeclaredVariableProblems(systemTemplate, groundingQuery, variable
             }
         }
     }
+    if (userTemplate !== undefined) {
+        for (const ref of (0, template_1.scanTemplateVariables)(userTemplate)) {
+            if (!declared.has(ref)) {
+                problems.push(`prompt.user references undeclared variable "${ref}" (declare it in prompt.variables)`);
+            }
+        }
+    }
     if (groundingQuery !== undefined) {
         for (const ref of (0, template_1.scanTemplateVariables)(groundingQuery)) {
             if (!declared.has(ref))

package/dist/run/accept.d.ts

@@ -40,6 +40,11 @@ export interface SuccessMetaInput {
     readonly quality?: RunMeta["quality"];
     /** CS-1 mask receipt (spec §6) — counts-only, when the route masks. */
     readonly mask?: RunMeta["mask"];
+    /** SC-1a screen receipt (spec §5) — counts-only, when the route screens. */
+    readonly screen?: RunMeta["screen"];
+    /** Unified Route U2 (D-2): the resolved served destination (always `direct` in
+     * U2 — `modelrig-served` fails closed pre-dispatch). Additive result metadata. */
+    readonly destination?: RunMeta["destination"];
 }
 /** The validated `RunMeta` for the accept path — `repairedBy` is null here (the
  * repair path builds its own meta), `validated` is always true. */

package/dist/run/accept.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accept.d.ts","sourceRoot":"","sources":["../../src/run/accept.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE;;;iDAGiD;AACjD,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,OAAO,EACvB,OAAO,EAAE,UAAU,GAAG,IAAI,EAC1B,UAAU,EAAE,iBAAiB,EAC7B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,gBAAgB,CAiBlB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;IAChE,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1C,wEAAwE;IACxE,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1C,uDAAuD;IACvD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACtC,uEAAuE;IACvE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;CACjC;AAED;mEACmE;AACnE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAyBjE"}
+{"version":3,"file":"accept.d.ts","sourceRoot":"","sources":["../../src/run/accept.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE;;;iDAGiD;AACjD,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,OAAO,EACvB,OAAO,EAAE,UAAU,GAAG,IAAI,EAC1B,UAAU,EAAE,iBAAiB,EAC7B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,gBAAgB,CAiBlB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;IAChE,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1C,wEAAwE;IACxE,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1C,uDAAuD;IACvD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACtC,uEAAuE;IACvE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAChC,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IACpC;sFACkF;IAClF,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CAC/C;AAED;mEACmE;AACnE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CA2BjE"}

package/dist/run/accept.js

@@ -63,5 +63,7 @@ function buildSuccessMeta(input) {
         ...(input.grounding !== undefined ? { grounding: input.grounding } : {}),
         ...(input.quality !== undefined ? { quality: input.quality } : {}),
         ...(input.mask !== undefined ? { mask: input.mask } : {}),
+        ...(input.screen !== undefined ? { screen: input.screen } : {}),
+        ...(input.destination !== undefined ? { destination: input.destination } : {}),
     };
 }

package/dist/run/cost.d.ts

@@ -4,8 +4,36 @@
  * site: a model with no pricing entry NEVER costs $0 against an active
  * envelope — the envelope is charged a conservative per-token rate instead,
  * while telemetry keeps the honest $0 with `pricing_missing` flagged.
+ *
+ * KNOWN GAP (issue #2 follow-up, S9c record): context bands are LISTED on
+ * `pricing_v2.context_bands` but NOT APPLIED here — a Gemini row whose prompt
+ * exceeds 200k tokens is priced at the ≤200k rates (Google doubles input,
+ * output and cache read above 200k), so such rows UNDER-state Google's list.
+ * The snapshot's `*_above_200k_tokens` keys were always ignored; this is not
+ * new, only now stated.
+ *
+ * SCOPE (QA-S5, 2026-10-12): served-tier pricing applies to what THIS module
+ * prices — the attempt cost row (`cost_estimate_usd`, both lanes, every
+ * attempt) and the `meta.cost` components. The server's managed re-pricing
+ * (`modelrig-server/src/compute-fee.ts` `listPriceCents`, which feeds the
+ * `/costs` rollup and the settlement draw) still calls `estimateCostUsd`
+ * WITHOUT a served tier and so prices at base. That is a money path and is
+ * deliberately not changed alongside this; tracked for the next money-path MR.
  */
-import type { AdapterUsage, ProviderId } from "../types/provider";
+import type { ModelPricing } from "../registry/pricing";
+import type { AdapterUsage, ProviderId, ServiceTier } from "../types/provider";
+/** The `servedTier` an attempt reports, when the caller has it — optional so
+ * every existing (tier-less) caller is unchanged and bills at base. */
+type UsageTier = Partial<Pick<AdapterUsage, "servedTier">>;
+/**
+ * Per-token rates for the tier that actually SERVED an attempt (issue #2).
+ * `standard` (or an unknown tier) ⇒ the flat base price — today's behaviour,
+ * byte-identical. `flex` / `priority` ⇒ the model's published `pricing_v2`
+ * tier rates (`tierRates`, per component — Gemini flex halves input + output
+ * but NOT cache read); a model that publishes no such tier bills at base, never
+ * at a guessed multiplier. Returns null only when the model is unpriced.
+ */
+export declare function pricingForServedTier(provider: ProviderId, model: string, servedTier: ServiceTier | undefined): ModelPricing | null;
 export declare const ESTIMATE_CHARS_PER_TOKEN = 4;
 export declare const ESTIMATE_MAX_OUTPUT_TOKENS = 64000;
 /** Addendum A1 conservative default — above the priciest frontier output
@@ -26,7 +54,7 @@ export declare function attemptCost(provider: ProviderId, model: string, usage:
  * `attemptCost`'s `pricingMissing`). Every component uses the SAME per-token
  * rates as {@link estimateCostUsd}, so the sum equals the recorded
  * `cost_estimate_usd` for a priced model. `other` is reserved (0 today). */
-export declare function costComponents(provider: ProviderId, model: string, usage: Pick<AdapterUsage, "tokensIn" | "tokensOut" | "tokensCached" | "tokensCacheWrite" | "tokensCacheWrite1h">): {
+export declare function costComponents(provider: ProviderId, model: string, usage: Pick<AdapterUsage, "tokensIn" | "tokensOut" | "tokensCached" | "tokensCacheWrite" | "tokensCacheWrite1h"> & UsageTier): {
     in: number;
     out: number;
     cache_read: number;
@@ -36,4 +64,5 @@ export declare function costComponents(provider: ProviderId, model: string, usag
 /** Pre-dispatch upper-bound estimate for the envelope precheck: prompt
  * length + the full output bound, at real pricing or the conservative rate. */
 export declare function dispatchEstimateUsd(provider: ProviderId, model: string, promptChars: number, unpricedRatePerTok: number): number;
+export {};
 //# sourceMappingURL=cost.d.ts.map

package/dist/run/cost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../../src/run/cost.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAElE,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAC1C,eAAO,MAAM,0BAA0B,QAAS,CAAC;AAEjD;;yEAEyE;AACzE,eAAO,MAAM,kCAAkC,MAAM,CAAC;AAEtD,MAAM,WAAW,WAAW;IAC1B,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CAClC;AAED,wBAAgB,WAAW,CACzB,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,YAAY,EACnB,kBAAkB,EAAE,MAAM,GACzB,WAAW,CAkBb;AAED;;;;;4EAK4E;AAC5E,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,IAAI,CACT,YAAY,EACZ,UAAU,GAAG,WAAW,GAAG,cAAc,GAAG,kBAAkB,GAAG,oBAAoB,CACtF,GACA;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAkB5F;AAED;+EAC+E;AAC/E,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,MAAM,GACzB,MAAM,CAOR"}
+{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../../src/run/cost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAS/E;uEACuE;AACvE,KAAK,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC;AAE3D;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,WAAW,GAAG,SAAS,GAClC,YAAY,GAAG,IAAI,CAiBrB;AAED,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAC1C,eAAO,MAAM,0BAA0B,QAAS,CAAC;AAEjD;;yEAEyE;AACzE,eAAO,MAAM,kCAAkC,MAAM,CAAC;AAEtD,MAAM,WAAW,WAAW;IAC1B,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CAClC;AAED,wBAAgB,WAAW,CACzB,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,YAAY,EACnB,kBAAkB,EAAE,MAAM,GACzB,WAAW,CAoBb;AAED;;;;;4EAK4E;AAC5E,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,IAAI,CACT,YAAY,EACZ,UAAU,GAAG,WAAW,GAAG,cAAc,GAAG,kBAAkB,GAAG,oBAAoB,CACtF,GACC,SAAS,GACV;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAmB5F;AAED;+EAC+E;AAC/E,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,MAAM,GACzB,MAAM,CAOR"}

package/dist/run/cost.js

@@ -5,13 +5,65 @@
  * site: a model with no pricing entry NEVER costs $0 against an active
  * envelope — the envelope is charged a conservative per-token rate instead,
  * while telemetry keeps the honest $0 with `pricing_missing` flagged.
+ *
+ * KNOWN GAP (issue #2 follow-up, S9c record): context bands are LISTED on
+ * `pricing_v2.context_bands` but NOT APPLIED here — a Gemini row whose prompt
+ * exceeds 200k tokens is priced at the ≤200k rates (Google doubles input,
+ * output and cache read above 200k), so such rows UNDER-state Google's list.
+ * The snapshot's `*_above_200k_tokens` keys were always ignored; this is not
+ * new, only now stated.
+ *
+ * SCOPE (QA-S5, 2026-10-12): served-tier pricing applies to what THIS module
+ * prices — the attempt cost row (`cost_estimate_usd`, both lanes, every
+ * attempt) and the `meta.cost` components. The server's managed re-pricing
+ * (`modelrig-server/src/compute-fee.ts` `listPriceCents`, which feeds the
+ * `/costs` rollup and the settlement draw) still calls `estimateCostUsd`
+ * WITHOUT a served tier and so prices at base. That is a money path and is
+ * deliberately not changed alongside this; tracked for the next money-path MR.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_UNPRICED_RATE_USD_PER_MTOK = exports.ESTIMATE_MAX_OUTPUT_TOKENS = exports.ESTIMATE_CHARS_PER_TOKEN = void 0;
+exports.pricingForServedTier = pricingForServedTier;
 exports.attemptCost = attemptCost;
 exports.costComponents = costComponents;
 exports.dispatchEstimateUsd = dispatchEstimateUsd;
 const pricing_1 = require("../registry/pricing");
+const pricing_shape_1 = require("../registry/pricing-shape");
+/** The served tiers that carry their own published rates (issue #2). `standard`
+ * is `base` by definition; an unlisted tier bills at base (fail-closed, L5). */
+const SERVED_TIER_RATES = {
+    flex: "flex",
+    priority: "priority",
+};
+/**
+ * Per-token rates for the tier that actually SERVED an attempt (issue #2).
+ * `standard` (or an unknown tier) ⇒ the flat base price — today's behaviour,
+ * byte-identical. `flex` / `priority` ⇒ the model's published `pricing_v2`
+ * tier rates (`tierRates`, per component — Gemini flex halves input + output
+ * but NOT cache read); a model that publishes no such tier bills at base, never
+ * at a guessed multiplier. Returns null only when the model is unpriced.
+ */
+function pricingForServedTier(provider, model, servedTier) {
+    const base = (0, pricing_1.getPricing)(provider, model);
+    if (base === null)
+        return null;
+    const tier = servedTier === undefined ? undefined : SERVED_TIER_RATES[servedTier];
+    if (tier === undefined)
+        return base;
+    const v2 = (0, pricing_1.getPricingV2)(provider, model);
+    const rates = v2 === null ? null : (0, pricing_shape_1.tierRates)(v2, tier);
+    if (rates === null)
+        return base;
+    return {
+        inputUsdPerTok: rates.input,
+        outputUsdPerTok: rates.output,
+        // A component the richer shape does not carry falls back to the flat base
+        // rate (the authoritative snapshot value), never to a scaled guess.
+        cachedInputUsdPerTok: rates.cache_read ?? base.cachedInputUsdPerTok,
+        cacheWriteUsdPerTok: rates.cache_write ?? base.cacheWriteUsdPerTok,
+        cacheWrite1hUsdPerTok: rates.cache_write_1h ?? base.cacheWrite1hUsdPerTok,
+    };
+}
 exports.ESTIMATE_CHARS_PER_TOKEN = 4;
 exports.ESTIMATE_MAX_OUTPUT_TOKENS = 64000;
 /** Addendum A1 conservative default — above the priciest frontier output
@@ -19,7 +71,9 @@ exports.ESTIMATE_MAX_OUTPUT_TOKENS = 64000;
  * free. Override via MODELRIG_UNPRICED_RATE_USD_PER_MTOK / RigConfig. */
 exports.DEFAULT_UNPRICED_RATE_USD_PER_MTOK = 100;
 function attemptCost(provider, model, usage, unpricedRatePerTok) {
-    const pricing = (0, pricing_1.getPricing)(provider, model);
+    // Issue #2: price at the tier that SERVED (usage.servedTier), not the
+    // standard base — a flex row at standard rates overstated Gemini ~1.6×.
+    const pricing = pricingForServedTier(provider, model, usage.servedTier);
     if (pricing === null) {
         return {
             costUsd: 0,
@@ -37,7 +91,8 @@ function attemptCost(provider, model, usage, unpricedRatePerTok) {
  * rates as {@link estimateCostUsd}, so the sum equals the recorded
  * `cost_estimate_usd` for a priced model. `other` is reserved (0 today). */
 function costComponents(provider, model, usage) {
-    const pricing = (0, pricing_1.getPricing)(provider, model);
+    // Same served-tier rates as attemptCost, so the components still sum to the row.
+    const pricing = pricingForServedTier(provider, model, usage.servedTier);
     if (pricing === null)
         return null;
     const tokensIn = Math.max(usage.tokensIn, 0);

package/dist/run/destination.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Serving destination axis (Unified Route lane, spec U1 / ruling D-2) — the
+ * SINGLE vocabulary for WHERE a model call is served:
+ *   - "direct"          → called directly (today's behavior: routed lane uses the
+ *                          configured key; the raw inline on-ramp uses the caller's BYOK
+ *                          key). This is the default; ABSENT ⇒ BYTE-IDENTICAL.
+ *   - "modelrig-served" → ModelRig serves the model on its OWN managed credentials
+ *                          (Fireworks / DeepInfra today; Z.ai deferred), behind the
+ *                          `config.managedServing` flag (set in code, default off; wired in U3).
+ *
+ * RULING D-2 (Matt, 2026-09-08, final): this axis is a "destination", NEVER a
+ * "lane"/"mode", and its served value is NEVER "managed" — that word already means
+ * key_ownership:managed (billing, registry/claims.ts) and artifact_posture:managed
+ * (content custody, settings/task-settings.ts), both orthogonal and both keep their
+ * names. See docs/ModelRig/unified-route/{research,spec}.md.
+ *
+ * The per-provider serving facts are seeded in raw-support.ts's capability table (the
+ * ONE source of truth), not here — this module owns the type + the vocabulary set + the
+ * lookups, which READ that table. Wired in U1 (raw-support.ts); the route contract
+ * consumes it in U2.
+ */
+import type { ProviderId } from "../types/provider";
+/** The serving destination for a model call (ruling D-2). */
+export type Destination = "direct" | "modelrig-served";
+/** The ordered, exhaustive set — the loader validates a route's `destination:` against
+ * this (routes/loader.ts, U2), mirroring PROVIDERS/TIERS. */
+export declare const DESTINATIONS: readonly Destination[];
+/** The default when a route/run declares none — ABSENT ⇒ BYTE-IDENTICAL. */
+export declare const DEFAULT_DESTINATION: Destination;
+/**
+ * Which destinations a provider can be served through. Seeded in the capability table
+ * (raw-support.ts) — `direct` for every provider; `modelrig-served` only for providers
+ * with a ModelRig-owned key today (fireworks, deepinfra — config.ts:303-304). Reads the
+ * seeded serving cell from RAW_KNOB_SUPPORT — no second list (one source of truth).
+ */
+export declare function servedDestinations(provider: ProviderId): readonly Destination[];
+/** True when a provider can serve the given destination (over servedDestinations()). */
+export declare function destinationSupported(provider: ProviderId, destination: Destination): boolean;
+//# sourceMappingURL=destination.d.ts.map

package/dist/run/destination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"destination.d.ts","sourceRoot":"","sources":["../../src/run/destination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,6DAA6D;AAC7D,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,iBAAiB,CAAC;AAEvD;6DAC6D;AAC7D,eAAO,MAAM,YAAY,EAAE,SAAS,WAAW,EAAkC,CAAC;AAElF,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB,EAAE,WAAsB,CAAC;AAEzD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,SAAS,WAAW,EAAE,CAE/E;AAED,wFAAwF;AACxF,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAE5F"}

package/dist/run/destination.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Serving destination axis (Unified Route lane, spec U1 / ruling D-2) — the
+ * SINGLE vocabulary for WHERE a model call is served:
+ *   - "direct"          → called directly (today's behavior: routed lane uses the
+ *                          configured key; the raw inline on-ramp uses the caller's BYOK
+ *                          key). This is the default; ABSENT ⇒ BYTE-IDENTICAL.
+ *   - "modelrig-served" → ModelRig serves the model on its OWN managed credentials
+ *                          (Fireworks / DeepInfra today; Z.ai deferred), behind the
+ *                          `config.managedServing` flag (set in code, default off; wired in U3).
+ *
+ * RULING D-2 (Matt, 2026-09-08, final): this axis is a "destination", NEVER a
+ * "lane"/"mode", and its served value is NEVER "managed" — that word already means
+ * key_ownership:managed (billing, registry/claims.ts) and artifact_posture:managed
+ * (content custody, settings/task-settings.ts), both orthogonal and both keep their
+ * names. See docs/ModelRig/unified-route/{research,spec}.md.
+ *
+ * The per-provider serving facts are seeded in raw-support.ts's capability table (the
+ * ONE source of truth), not here — this module owns the type + the vocabulary set + the
+ * lookups, which READ that table. Wired in U1 (raw-support.ts); the route contract
+ * consumes it in U2.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DESTINATION = exports.DESTINATIONS = void 0;
+exports.servedDestinations = servedDestinations;
+exports.destinationSupported = destinationSupported;
+const raw_support_1 = require("./raw-support");
+/** The ordered, exhaustive set — the loader validates a route's `destination:` against
+ * this (routes/loader.ts, U2), mirroring PROVIDERS/TIERS. */
+exports.DESTINATIONS = ["direct", "modelrig-served"];
+/** The default when a route/run declares none — ABSENT ⇒ BYTE-IDENTICAL. */
+exports.DEFAULT_DESTINATION = "direct";
+/**
+ * Which destinations a provider can be served through. Seeded in the capability table
+ * (raw-support.ts) — `direct` for every provider; `modelrig-served` only for providers
+ * with a ModelRig-owned key today (fireworks, deepinfra — config.ts:303-304). Reads the
+ * seeded serving cell from RAW_KNOB_SUPPORT — no second list (one source of truth).
+ */
+function servedDestinations(provider) {
+    return raw_support_1.RAW_KNOB_SUPPORT[provider].serving.destinations;
+}
+/** True when a provider can serve the given destination (over servedDestinations()). */
+function destinationSupported(provider, destination) {
+    return servedDestinations(provider).includes(destination);
+}