modelrig 0.8.1 → 0.10.0

package/dist/run/record-attempt.js

@@ -14,10 +14,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.rungOf = rungOf;
 exports.createRecordAttempt = createRecordAttempt;
 const node_crypto_1 = require("node:crypto");
+const dispatch_1 = require("./dispatch");
+const destination_1 = require("./destination");
 const failures_1 = require("../types/failures");
 const cache_stamp_1 = require("./cache-stamp");
 const cache_handle_1 = require("./cache-handle");
 const attempt_meta_1 = require("../telemetry/attempt-meta");
+const telemetry_row_1 = require("./telemetry-row");
 /**
  * Classify a recorded row's ladder rung (R1 review, F1). `primaryDispatched`
  * carries the candidate indices already given a primary dispatch on this call —
@@ -99,12 +102,19 @@ function createRecordAttempt(deps) {
         // meta (metaInputs) plus THIS row's provider/model/usage.
         const meta = (0, attempt_meta_1.summarizeAttemptMeta)({
             ...(attempt.metaInputs ?? {}),
+            ...(deps.arm !== undefined ? { arm: deps.arm } : {}),
+            // SC-1a (spec §5, §8): the counts-only screen receipt rides meta.screen —
+            // ZERO migration. The single producer passes it through verbatim.
+            ...(attempt.screen !== undefined ? { screen: attempt.screen } : {}),
             provider: attempt.candidate.provider,
             model: attempt.candidate.model,
             usage: {
                 tokensIn: attempt.tokensIn,
                 tokensOut: attempt.tokensOut,
                 tokensCached: attempt.tokensCached,
+                // Issue #2 (L6 F1): the SERVED tier, so meta.cost components price at
+                // the same tier as cost_estimate_usd and still sum to the row (WI-1).
+                servedTier: attempt.servedTier,
                 ...(attempt.tokensCacheWrite !== undefined ? { tokensCacheWrite: attempt.tokensCacheWrite } : {}),
                 ...(attempt.tokensCacheWrite1h !== undefined ? { tokensCacheWrite1h: attempt.tokensCacheWrite1h } : {}),
             },
@@ -117,9 +127,13 @@ function createRecordAttempt(deps) {
         // stepKey ?? tags.step ?? the auto `route#n` key, so a caller's own step lands
         // unchanged and the tag agrees with the ground-truth step row.
         const stepTag = runCtx !== null && autoStepKey !== null ? { step: autoStepKey } : {};
-        const row = {
+        // U4: the row is assembled — and its tags serialized — by the ONE shared
+        // builder (./telemetry-row.ts). `rung` is stamped LAST inside stampRowTags so
+        // a caller's extraTags (Q1 quality tags) can never override the
+        // recorder-owned rung. Cache-write accounting (WS-A) + WS-C substrate + the
+        // CS-1 mask receipt ride the same builder unchanged.
+        const row = (0, telemetry_row_1.buildTelemetryRow)({
             id: (0, node_crypto_1.randomUUID)(),
-            ts: new Date().toISOString(),
             route: route.route,
             routeVersion: route.version,
             provider: attempt.candidate.provider,
@@ -129,31 +143,35 @@ function createRecordAttempt(deps) {
             tokensIn: attempt.tokensIn,
             tokensOut: attempt.tokensOut,
             tokensCached: attempt.tokensCached,
-            // Cache-write accounting (WS-A) + request-path substrate (WS-C).
             tokensCacheWrite: attempt.tokensCacheWrite ?? 0,
             tokensCacheWrite1h: attempt.tokensCacheWrite1h ?? 0,
-            cacheKey,
-            prefixFingerprint: cacheStamp?.prefixFingerprint ?? null,
             costEstimateUsd: attempt.costUsd,
             latencyMs: attempt.latencyMs,
             ttfbMs: attempt.ttfbMs ?? null,
             failureClass: attempt.failure?.class ?? null,
             attemptsJson: JSON.stringify(ledger.snapshot()),
-            // `rung` is stamped LAST so a caller's extraTags (Q1 quality tags) can
-            // never override the recorder-owned rung.
-            tagsJson: JSON.stringify({ ...stepTag, ...effectiveTags, ...attempt.extraTags, rung }),
+            // U3 (D-2) × U4: the serving `destination` tag rides the ONE shared row
+            // builder — `buildTelemetryRow` → `stampRowTags` serializes `tags_json` in a
+            // single place, and `rung` is stamped LAST there so a caller's extraTags can
+            // never override it. `destinationTag()` returns `{}` for the default `direct`,
+            // so a direct/absent routed row stays byte-identical; a `modelrig-served` row
+            // gains `destination`. Folded into `baseTags` here because `destination` is a
+            // routed-lane concept (the raw/search recorders have none).
+            baseTags: { ...stepTag, ...effectiveTags, ...(0, dispatch_1.destinationTag)(deps.destination ?? destination_1.DEFAULT_DESTINATION) },
+            extraTags: attempt.extraTags,
+            rung,
             fingerprintCell: route.fingerprintCell,
             servedVariant,
             repairedBy: attempt.repairedBy ?? null,
             pricingMissing: attempt.pricingMissing ?? false,
+            cacheKey,
+            prefixFingerprint: cacheStamp?.prefixFingerprint ?? null,
             callId: ladderKey.callId,
             attemptSeq: ladderKey.attemptSeq,
             candidateIndex: ladderKey.candidateIndex,
             meta,
-            // CS-1 (spec §6): the counts-only mask receipt for this attempt, or absent
-            // when the route does not mask. NEVER a matched value.
-            ...(attempt.mask !== undefined ? { mask: attempt.mask } : {}),
-        };
+            mask: attempt.mask,
+        });
         telemetry.record(row);
         // Mirror this inference into a ground-truth step attempt (fail-open — the
         // context swallows buffer errors; the run loop is never affected).

package/dist/run/repair-attempt.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The routed lane's REPAIR RUNG (spec §4, WS2), extracted from run.ts as a
+ * factory over the run's per-call state — mirroring the `createRecordAttempt`
+ * factory pattern in ./record-attempt.ts, and for the same reason: run.ts sits
+ * at the 700-LOC cap (dev-rule P1), and the repair closure is a large,
+ * self-contained block (~157 LOC). This is a PURE MOVE (Unified Route U4,
+ * behavior-preserving): the logic, the record shapes, the throw conditions, and
+ * the returned `RunResult` meta are byte-identical to the former inline closure.
+ *
+ * The one mechanical change the move forces: the former closure read the run
+ * loop's mutable `injectedSources` binding directly; the factory-built function
+ * receives it as an explicit call argument instead (the run loop passes the
+ * value in scope for the candidate being repaired), so behavior is unchanged.
+ */
+import type { ProviderAdapter, CandidateRef } from "../types/provider";
+import type { RigFailure } from "../types/failures";
+import type { RouteBundle, RunResult } from "../types/route";
+import type { ScreenReceipt } from "../screen/types";
+import type { EnvelopeGuard } from "./envelope";
+import type { RunMode } from "./resolve";
+import type { RepairStep } from "./repair";
+import type { AttemptTelemetry } from "./dispatch";
+import type { SearchResultItem } from "./grounding";
+import type { LadderKeyMinter } from "./ladder-key";
+import type { RetryLedger } from "./retry";
+import type { Destination } from "./destination";
+/** User turn for repair calls (WS2) — same terse-trigger convention run.ts uses
+ * for the primary directive. Moved here with the repair closure. */
+export declare const REPAIR_DIRECTIVE = "Produce the corrected JSON object now, following the system instructions exactly.";
+/** The user turn of a SAME-MODEL repair re-ask (issue #5, R1): on a route that
+ * declares `prompt.user`, the rendered per-call user turn is kept ahead of the
+ * repair directive (the delta is content the model needs to correct against —
+ * dropping it would be the silent loss R1 closes); on every other route the
+ * directive alone, byte-identical to pre-R1. Pure; exported for the tests. */
+export declare function repairUserTurn(route: Pick<RouteBundle, "userTemplate">, originalUserPrompt: string): string;
+export interface RepairAttemptOutcome {
+    readonly done?: RunResult;
+    readonly invalid?: {
+        readonly text: string;
+        readonly errors: readonly string[];
+    };
+}
+export interface AttemptRepairDeps {
+    readonly adapters: ReadonlyMap<string, ProviderAdapter>;
+    readonly guard: EnvelopeGuard | null;
+    readonly unpricedRatePerTok: number;
+    readonly route: RouteBundle;
+    readonly mode: RunMode;
+    readonly recordAttempt: (attempt: AttemptTelemetry) => string;
+    readonly captureAttempt: (inferenceId: string, text: string) => void;
+    readonly ledger: RetryLedger;
+    readonly servedVariant: string | null;
+    readonly ladder: LadderKeyMinter;
+    readonly destination: Destination;
+    /** run.ts's `failRun` — records a pre-dispatch terminal row and throws. */
+    readonly failRun: (candidate: CandidateRef, failure: RigFailure, latencyMs: number, screen?: ScreenReceipt) => never;
+}
+/**
+ * Build the run loop's `attemptRepair`. Returns a function performing ONE repair
+ * dispatch: `{done}` on schema-valid output, `{invalid}` with the newest
+ * output+errors for chaining, or null when the dispatch itself failed (adapter
+ * failure / unmintable repair candidate). `injectedSources` is the run loop's
+ * current grounding-inject payload for the candidate under repair (null when the
+ * run is not spotlight-grounded) — passed in so the returned `done` meta carries
+ * the same `groundingMeta` the primary success path would.
+ */
+export declare function createAttemptRepair(deps: AttemptRepairDeps): (step: RepairStep, original: CandidateRef, originalSystemPrompt: string, invalidText: string, errors: readonly string[], injectedSources: readonly SearchResultItem[] | null, originalUserPrompt?: string) => Promise<RepairAttemptOutcome | null>;
+//# sourceMappingURL=repair-attempt.d.ts.map

package/dist/run/repair-attempt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair-attempt.d.ts","sourceRoot":"","sources":["../../src/run/repair-attempt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAG3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;oEACoE;AACpE,eAAO,MAAM,gBAAgB,sFAAsF,CAAC;AAEpH;;;;8EAI8E;AAC9E,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,EAAE,kBAAkB,EAAE,MAAM,GAAG,MAAM,CAE3G;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC;CAClF;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACxD,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,MAAM,CAAC;IAC9D,QAAQ,CAAC,cAAc,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,KAAK,KAAK,CAAC;CACtH;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,iBAAiB,GACtB,CACD,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,YAAY,EACtB,oBAAoB,EAAE,MAAM,EAC5B,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,eAAe,EAAE,SAAS,gBAAgB,EAAE,GAAG,IAAI,EACnD,kBAAkB,CAAC,EAAE,MAAM,KACxB,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CA0KxC"}

package/dist/run/repair-attempt.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * The routed lane's REPAIR RUNG (spec §4, WS2), extracted from run.ts as a
+ * factory over the run's per-call state — mirroring the `createRecordAttempt`
+ * factory pattern in ./record-attempt.ts, and for the same reason: run.ts sits
+ * at the 700-LOC cap (dev-rule P1), and the repair closure is a large,
+ * self-contained block (~157 LOC). This is a PURE MOVE (Unified Route U4,
+ * behavior-preserving): the logic, the record shapes, the throw conditions, and
+ * the returned `RunResult` meta are byte-identical to the former inline closure.
+ *
+ * The one mechanical change the move forces: the former closure read the run
+ * loop's mutable `injectedSources` binding directly; the factory-built function
+ * receives it as an explicit call argument instead (the run loop passes the
+ * value in scope for the candidate being repaired), so behavior is unchanged.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPAIR_DIRECTIVE = void 0;
+exports.repairUserTurn = repairUserTurn;
+exports.createAttemptRepair = createAttemptRepair;
+const failures_1 = require("../types/failures");
+const cost_1 = require("./cost");
+const resolve_1 = require("./resolve");
+const repair_1 = require("./repair");
+const validate_1 = require("./validate");
+const dispatch_1 = require("./dispatch");
+const grounding_1 = require("./grounding");
+/** User turn for repair calls (WS2) — same terse-trigger convention run.ts uses
+ * for the primary directive. Moved here with the repair closure. */
+exports.REPAIR_DIRECTIVE = "Produce the corrected JSON object now, following the system instructions exactly.";
+/** The user turn of a SAME-MODEL repair re-ask (issue #5, R1): on a route that
+ * declares `prompt.user`, the rendered per-call user turn is kept ahead of the
+ * repair directive (the delta is content the model needs to correct against —
+ * dropping it would be the silent loss R1 closes); on every other route the
+ * directive alone, byte-identical to pre-R1. Pure; exported for the tests. */
+function repairUserTurn(route, originalUserPrompt) {
+    return route.userTemplate === undefined ? exports.REPAIR_DIRECTIVE : `${originalUserPrompt}\n\n${exports.REPAIR_DIRECTIVE}`;
+}
+/**
+ * Build the run loop's `attemptRepair`. Returns a function performing ONE repair
+ * dispatch: `{done}` on schema-valid output, `{invalid}` with the newest
+ * output+errors for chaining, or null when the dispatch itself failed (adapter
+ * failure / unmintable repair candidate). `injectedSources` is the run loop's
+ * current grounding-inject payload for the candidate under repair (null when the
+ * run is not spotlight-grounded) — passed in so the returned `done` meta carries
+ * the same `groundingMeta` the primary success path would.
+ */
+function createAttemptRepair(deps) {
+    const { adapters, guard, unpricedRatePerTok, route, mode, recordAttempt, captureAttempt, ledger, servedVariant, ladder, destination, failRun, } = deps;
+    return async function attemptRepair(step, original, originalSystemPrompt, invalidText, errors, injectedSources, originalUserPrompt) {
+        let repairCandidate;
+        let systemPrompt;
+        // Issue #5 (R1): the same-model re-ask keeps a declared `prompt.user` turn;
+        // the repair-model path re-frames the whole task (invalid output + errors +
+        // schema) and is unchanged. REPAIR_DIRECTIVE alone ⇒ byte-identical to pre-R1.
+        let userPrompt = exports.REPAIR_DIRECTIVE;
+        if (step.kind === "same_model") {
+            repairCandidate = original;
+            systemPrompt = originalSystemPrompt + (0, repair_1.repairFeedbackBlock)(errors);
+            userPrompt = repairUserTurn(route, originalUserPrompt ?? "");
+        }
+        else {
+            // Declare-first backstop (spec §4.4): the loader rejects a `trial` candidate
+            // as `repair_model`, but a programmatically-built bundle (runBundle) could
+            // bypass the loader — so refuse to mint a trial candidate for LIVE repair
+            // here too (the primary ladder's trial-drop has no repair-path equivalent).
+            if (mode === "live" &&
+                route.candidates.some((c) => c.provider === step.model.provider && c.model === step.model.model && c.trial === true)) {
+                return null;
+            }
+            // Brand stays in resolve.ts; loader validated repairModel ⊆ declared.
+            const minted = (0, resolve_1.resolveDeclaredCandidate)(route, step.model);
+            if (minted === null)
+                return null;
+            repairCandidate = minted;
+            systemPrompt = (0, repair_1.repairModelPrompt)(invalidText, errors, route.outputSchema);
+        }
+        const repairedBy = `${repairCandidate.provider}/${repairCandidate.model}`;
+        const adapter = adapters.get(repairCandidate.provider);
+        if (adapter === undefined)
+            return null;
+        if (guard !== null) {
+            // A1: unpriced repair models fail closed exactly like primaries.
+            const breach = guard.precheck((0, cost_1.dispatchEstimateUsd)(repairCandidate.provider, repairCandidate.model, systemPrompt.length + userPrompt.length, unpricedRatePerTok));
+            if (breach !== null) {
+                failRun(repairCandidate, breach, 0);
+            }
+        }
+        const started = Date.now();
+        const result = await adapter.call((0, dispatch_1.buildRepairAdapterRequest)(route, repairCandidate, systemPrompt, userPrompt));
+        const latencyMs = Date.now() - started;
+        if (!result.ok) {
+            let cost = 0;
+            let repairFailurePricingMissing = false;
+            if (result.usage !== undefined) {
+                const settled = (0, cost_1.attemptCost)(repairCandidate.provider, repairCandidate.model, result.usage, unpricedRatePerTok);
+                cost = settled.costUsd;
+                repairFailurePricingMissing = settled.pricingMissing;
+                guard?.settle(settled.envelopeChargeUsd);
+            }
+            recordAttempt({
+                candidate: repairCandidate,
+                servedTier: result.usage?.servedTier ?? route.policy.tier,
+                tokensIn: result.usage?.tokensIn ?? 0,
+                tokensOut: result.usage?.tokensOut ?? 0,
+                tokensCached: result.usage?.tokensCached ?? 0,
+                tokensCacheWrite: result.usage?.tokensCacheWrite ?? 0,
+                tokensCacheWrite1h: result.usage?.tokensCacheWrite1h ?? 0,
+                costUsd: cost,
+                latencyMs,
+                ...(result.usage?.ttfbMs !== undefined ? { ttfbMs: result.usage.ttfbMs } : {}),
+                failure: result.failure,
+                repairedBy,
+                pricingMissing: repairFailurePricingMissing,
+                metaInputs: (0, dispatch_1.attemptMetaInputs)({ systemPrompt, userDirective: userPrompt, outputSchema: route.outputSchema, outputKind: route.outputKind, result }),
+            });
+            if (failures_1.TERMINAL_CLASSES.has(result.failure.class)) {
+                throw new failures_1.RigFailureError(result.failure);
+            }
+            return null;
+        }
+        const { costUsd, envelopeChargeUsd, pricingMissing: repairPricingMissing, } = (0, cost_1.attemptCost)(repairCandidate.provider, repairCandidate.model, result.usage, unpricedRatePerTok);
+        guard?.settle(envelopeChargeUsd);
+        const outcome = (0, validate_1.validateOutput)(route, result.text);
+        const failure = outcome.valid
+            ? null
+            : {
+                class: "content_invalid",
+                message: `repair output failed schema validation: ${outcome.errors.join("; ")}`,
+                provider: repairCandidate.provider,
+                model: repairCandidate.model,
+            };
+        const inferenceId = recordAttempt({
+            candidate: repairCandidate,
+            servedTier: result.usage.servedTier,
+            tokensIn: result.usage.tokensIn,
+            tokensOut: result.usage.tokensOut,
+            tokensCached: result.usage.tokensCached,
+            tokensCacheWrite: result.usage.tokensCacheWrite ?? 0,
+            tokensCacheWrite1h: result.usage.tokensCacheWrite1h ?? 0,
+            costUsd,
+            latencyMs,
+            ...(result.usage.ttfbMs !== undefined ? { ttfbMs: result.usage.ttfbMs } : {}),
+            failure,
+            repairedBy,
+            pricingMissing: repairPricingMissing,
+            metaInputs: (0, dispatch_1.attemptMetaInputs)({ systemPrompt, userDirective: userPrompt, outputSchema: route.outputSchema, outputKind: route.outputKind, result }),
+        });
+        captureAttempt(inferenceId, result.text);
+        if (!outcome.valid) {
+            return { invalid: { text: result.text, errors: outcome.errors } };
+        }
+        return {
+            done: {
+                output: outcome.parsed,
+                meta: {
+                    inferenceId,
+                    route: route.route,
+                    routeVersion: route.version,
+                    provider: repairCandidate.provider,
+                    model: repairCandidate.model,
+                    requestedTier: route.policy.tier,
+                    servedTier: result.usage.servedTier,
+                    tokensIn: result.usage.tokensIn,
+                    tokensOut: result.usage.tokensOut,
+                    tokensCached: result.usage.tokensCached,
+                    costEstimateUsd: costUsd,
+                    latencyMs,
+                    validated: true,
+                    attemptsByClass: ledger.snapshot(),
+                    servedVariant,
+                    repairedBy,
+                    callId: ladder.callId, destination, // destination: Unified Route U2 (D-2)
+                    ...(injectedSources !== null
+                        ? (0, grounding_1.groundingMeta)(result.text, injectedSources)
+                        : {}),
+                },
+            },
+        };
+    };
+}

package/dist/run/resolve-destination.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Serving-destination resolution + the U2 fail-closed guard (Unified Route U2,
+ * ruling D-2). Its own module so run.ts stays under the 700-LOC cap (EXTRACT,
+ * don't grow) and so U3 can wire managed serving through the same two seams.
+ *
+ * `resolveDestination` is pure: it picks the EFFECTIVE served destination with a
+ * fixed precedence — a per-run `RunOptions.destination` override wins, else the
+ * route's declared `destination`, else `DEFAULT_DESTINATION` (`direct`). Absent
+ * everywhere ⇒ `direct` ⇒ BYTE-IDENTICAL (the top acceptance bar).
+ *
+ * `assertDestinationServable` is the fail-closed-but-discoverable guard, made
+ * flag + capability aware in U3. `modelrig-served` PASSES only when BOTH the
+ * managed-serving config flag (`config.managedServing`, set IN CODE via
+ * `createRig` — NOT an env var; default off) is on AND the run's provider can be
+ * served (`providersServing("modelrig-served")` —
+ * fireworks/deepinfra per U1). Otherwise it throws a TEACHING `RigFailureError`
+ * (class `invariant_violation`) rather than silently serving `direct`, with a
+ * fixHint that distinguishes the two failure cases. `direct` passes untouched —
+ * no throw, no telemetry row, no provider call — so an absent/`direct` route is
+ * byte-identical, and ANY run with the flag off behaves exactly as today.
+ *
+ * This is a SEAM, not a key override: the fireworks/deepinfra adapters already
+ * carry ModelRig-owned keys on the routed lane (config.ts PROVIDER_KEY_ENV), so
+ * a passing `modelrig-served` run dispatches through the SAME adapter/key a
+ * `direct` run would — U3 gates it and tags it (record-attempt.ts), it does not
+ * flip a credential. True customer-keyless serving now SHIPS as a hosted-server
+ * capability (built by the keyless-serving program — SDK transport K1,
+ * named-variable K1b, per-org provisioning K2), gated by `config.managedServing`
+ * (default off) rather than deferred (spec §4 U3).
+ */
+import type { Destination } from "./destination";
+import type { ProviderId } from "../types/provider";
+/** The effective served destination: RunOptions override > route > default
+ * `direct`. Pure — no throw; the fail-closed decision lives in the guard below. */
+export declare function resolveDestination(routeDestination: Destination | undefined, runOptionDestination: Destination | undefined): Destination;
+/**
+ * Fail-closed-but-discoverable guard (U3, flag + capability aware). `direct`
+ * always passes (returns void — byte-identical). `modelrig-served` passes ONLY
+ * when the managed-serving flag is on AND `provider` is served-capable; the two
+ * failure cases throw a teaching `RigFailureError` with a distinguishing fixHint:
+ *   • flag OFF                → tells the caller to set `managedServing: true` in
+ *                               the rig config (or set `destination: direct`).
+ *   • flag ON, provider incapable (openai/gemini/grok/deepseek/anthropic) → names
+ *                               the served-capable set from the U1 matrix.
+ * `provider` is the run's RESOLVED serving candidate (threaded from run.ts). No
+ * silent `direct` fallback either way (spec §4 U3, R3).
+ */
+export declare function assertDestinationServable(destination: Destination, managedServingEnabled: boolean, provider: ProviderId): void;
+//# sourceMappingURL=resolve-destination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-destination.d.ts","sourceRoot":"","sources":["../../src/run/resolve-destination.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD;mFACmF;AACnF,wBAAgB,kBAAkB,CAChC,gBAAgB,EAAE,WAAW,GAAG,SAAS,EACzC,oBAAoB,EAAE,WAAW,GAAG,SAAS,GAC5C,WAAW,CAEb;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,WAAW,EACxB,qBAAqB,EAAE,OAAO,EAC9B,QAAQ,EAAE,UAAU,GACnB,IAAI,CAuBN"}

package/dist/run/resolve-destination.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Serving-destination resolution + the U2 fail-closed guard (Unified Route U2,
+ * ruling D-2). Its own module so run.ts stays under the 700-LOC cap (EXTRACT,
+ * don't grow) and so U3 can wire managed serving through the same two seams.
+ *
+ * `resolveDestination` is pure: it picks the EFFECTIVE served destination with a
+ * fixed precedence — a per-run `RunOptions.destination` override wins, else the
+ * route's declared `destination`, else `DEFAULT_DESTINATION` (`direct`). Absent
+ * everywhere ⇒ `direct` ⇒ BYTE-IDENTICAL (the top acceptance bar).
+ *
+ * `assertDestinationServable` is the fail-closed-but-discoverable guard, made
+ * flag + capability aware in U3. `modelrig-served` PASSES only when BOTH the
+ * managed-serving config flag (`config.managedServing`, set IN CODE via
+ * `createRig` — NOT an env var; default off) is on AND the run's provider can be
+ * served (`providersServing("modelrig-served")` —
+ * fireworks/deepinfra per U1). Otherwise it throws a TEACHING `RigFailureError`
+ * (class `invariant_violation`) rather than silently serving `direct`, with a
+ * fixHint that distinguishes the two failure cases. `direct` passes untouched —
+ * no throw, no telemetry row, no provider call — so an absent/`direct` route is
+ * byte-identical, and ANY run with the flag off behaves exactly as today.
+ *
+ * This is a SEAM, not a key override: the fireworks/deepinfra adapters already
+ * carry ModelRig-owned keys on the routed lane (config.ts PROVIDER_KEY_ENV), so
+ * a passing `modelrig-served` run dispatches through the SAME adapter/key a
+ * `direct` run would — U3 gates it and tags it (record-attempt.ts), it does not
+ * flip a credential. True customer-keyless serving now SHIPS as a hosted-server
+ * capability (built by the keyless-serving program — SDK transport K1,
+ * named-variable K1b, per-org provisioning K2), gated by `config.managedServing`
+ * (default off) rather than deferred (spec §4 U3).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDestination = resolveDestination;
+exports.assertDestinationServable = assertDestinationServable;
+const destination_1 = require("./destination");
+const raw_support_1 = require("./raw-support");
+const failures_1 = require("../types/failures");
+/** The effective served destination: RunOptions override > route > default
+ * `direct`. Pure — no throw; the fail-closed decision lives in the guard below. */
+function resolveDestination(routeDestination, runOptionDestination) {
+    return runOptionDestination ?? routeDestination ?? destination_1.DEFAULT_DESTINATION;
+}
+/**
+ * Fail-closed-but-discoverable guard (U3, flag + capability aware). `direct`
+ * always passes (returns void — byte-identical). `modelrig-served` passes ONLY
+ * when the managed-serving flag is on AND `provider` is served-capable; the two
+ * failure cases throw a teaching `RigFailureError` with a distinguishing fixHint:
+ *   • flag OFF                → tells the caller to set `managedServing: true` in
+ *                               the rig config (or set `destination: direct`).
+ *   • flag ON, provider incapable (openai/gemini/grok/deepseek/anthropic) → names
+ *                               the served-capable set from the U1 matrix.
+ * `provider` is the run's RESOLVED serving candidate (threaded from run.ts). No
+ * silent `direct` fallback either way (spec §4 U3, R3).
+ */
+function assertDestinationServable(destination, managedServingEnabled, provider) {
+    if (destination !== "modelrig-served")
+        return; // direct ⇒ byte-identical
+    if (!managedServingEnabled) {
+        throw new failures_1.RigFailureError({
+            class: "invariant_violation",
+            message: 'resolved destination "modelrig-served", but managed serving is not enabled (config `managedServing` is off)',
+            fixHint: "managed serving is not enabled — set `managedServing: true` in your rig config " +
+                "(e.g. `createRig({ managedServing: true })`) to serve `destination: modelrig-served`; " +
+                "otherwise remove `destination` or set it to `direct`.",
+        });
+    }
+    if (!(0, raw_support_1.providersServing)("modelrig-served").includes(provider)) {
+        const served = (0, raw_support_1.providersServing)("modelrig-served").join(", ");
+        throw new failures_1.RigFailureError({
+            class: "invariant_violation",
+            message: `provider ${provider} cannot be modelrig-served`,
+            fixHint: `provider ${provider} cannot be modelrig-served; served providers: ${served}. ` +
+                "Declare a served-capable candidate (fireworks/deepinfra), or set `destination: direct`.",
+        });
+    }
+}

package/dist/run/routing-docs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routing-docs.d.ts","sourceRoot":"","sources":["../../src/run/routing-docs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAItD,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,UAAU,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE/E,MAAM,WAAW,gBAAgB;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,yEAAyE;IACzE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,kBAAkB;IAClB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,GAAG;QAAE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3E;AAED,yCAAyC;AACzC,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAK1E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,aAAa,EAiGpD,CAAC;AAwBF;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAoB7E;AAED;;;;+DAI+D;AAC/D,wBAAgB,iBAAiB,IAAI,SAAS,YAAY,EAAE,CAE3D;AA0BD;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAW7C;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAE5D"}
+{"version":3,"file":"routing-docs.d.ts","sourceRoot":"","sources":["../../src/run/routing-docs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAItD,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,UAAU,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE/E,MAAM,WAAW,gBAAgB;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,yEAAyE;IACzE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,kBAAkB;IAClB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,GAAG;QAAE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3E;AAED,yCAAyC;AACzC,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAK1E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,aAAa,EAsGpD,CAAC;AAwBF;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAoB7E;AAED;;;;+DAI+D;AAC/D,wBAAgB,iBAAiB,IAAI,SAAS,YAAY,EAAE,CAE3D;AA0BD;;;;;GAKG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAW7C;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAE5D"}

package/dist/run/routing-docs.js

@@ -52,10 +52,15 @@ exports.ROUTING_BOUNDARY = [
     },
     {
         id: "B2",
-        status: "not_built",
-        capability: "Structure on the raw lane",
-        statement: '`runRaw` never validates or repairs; `responseFormat: "json_object"` shapes MIME, not schema, so `meta.validated` stays false — structure on the raw lane is ruled out by design, and the path is to graduate that step to a route.',
-        tracking: "ruled schema-free on the raw lane; re-request on file",
+        status: "by_design",
+        capability: "Repair on the raw lane",
+        // R2 (issue #6) narrowed this entry: `responseSchema` now VALIDATES on the
+        // raw lane (native directive + client-side Ajv, a miss is `content_invalid`).
+        // What stays out by design is the ladder — no repair rung, no retry budget,
+        // no fall-through — so `meta.validated` stays false on this lane. The
+        // tripwire keeps watching for the route-grade `outputSchema` contract.
+        statement: '`runRaw` validates a declared `responseSchema` (the provider\'s native structured-output directive plus a client-side Ajv check; a miss is a billed, terminal `content_invalid`) but never repairs, never retries, and never falls through — `meta.validated` stays false because no ladder stands behind the check, `responseFormat: "json_object"` shapes MIME only, and a schema miss you want recovered means graduating that step to a route.',
+        tracking: "route-bundles.md — raw-lane responseSchema (validate, never repair)",
         tripwire: { file: "src/run/raw.ts", mustNotMatch: /readonly outputSchema\??:/ },
     },
     {
@@ -96,7 +101,7 @@ exports.ROUTING_BOUNDARY = [
         id: "B7",
         status: "by_design",
         capability: "Automatic model swap",
-        statement: "Nothing changes what serves a route without a bake-off and an explicit human approval (`modelrig swap execute <id> --approve`).",
+        statement: "No automated change to what serves a route happens without a bake-off and human approval (`modelrig swap execute <id> --approve`); you (or your agent) can change it directly at any time — instant, versioned, reversible.",
         tracking: "optimization-loop.md — human-approved swaps only",
         // No file tripwire: the P6 never-silent-swap invariant is covered by its
         // own dev-rule tests (spec §5.3).

package/dist/run/run.d.ts

@@ -9,10 +9,12 @@
 import type { LoadedRoutes } from "../routes/loader";
 import type { ProviderAdapter } from "../types/provider";
 import type { RigManifest } from "../routes/manifest";
-import type { RunOptions, RunResult } from "../types/route";
+import type { RouteBundle, RunOptions, RunResult } from "../types/route";
+import type { CapabilityFlag } from "../types/provider";
 import type { TelemetryStore } from "../types/telemetry";
 import type { CaptureStore } from "../telemetry/capture";
 import type { CapabilityLookup, RunMode } from "./resolve";
+import type { ServeFetch, ServeTransportConfig } from "../gateway/serve-client";
 import type { SearchProvider } from "./grounding";
 import type { StreamDeltaSink } from "./dispatch";
 import type { TaskSettingsResolver } from "../settings/task-settings";
@@ -56,6 +58,33 @@ export interface RunDeps {
      * trial variant; `live` drops trial candidates before minting and rejects a
      * trial variant. Absent ⇒ live ⇒ byte-identical to the pre-R3 loop. */
     readonly mode?: RunMode;
+    readonly managedServingEnabled?: boolean;
+    /** K1 (managed-serving-keyless §2/§3): the hosted-gateway transport config
+     * (ingest host + `rig_sk_` key), resolved from the `api`-mode export in
+     * `index.ts`. Read ONLY when `managedServingEnabled` is on AND the resolved
+     * destination is `modelrig-served`. Absent there ⇒ the served run fails closed
+     * (no hosted control plane / no key — never a silent `direct` fall back). */
+    readonly serve?: ServeTransportConfig;
+    /** K1: injected `fetch` for the serving transport (tests mock it; NO live
+     * network, NO real key). Absent ⇒ the global `fetch`. */
+    readonly serveFetch?: ServeFetch;
 }
+/** Phase 1 prompt convention: the bundle's system template carries the whole
+ * task (constitution, data, step instructions); the user turn is a terse
+ * trigger. Providers treat long system prompts + short user turns well, and
+ * it keeps the single-template bundle contract of spec §3. Issue #5 (R1): a
+ * route that declares `prompt.user` replaces this trigger with its rendered
+ * user template — the per-call delta a cache handle cannot carry in the system
+ * slot (see `userTurnFor`). */
+export declare const USER_DIRECTIVE = "Produce the required output now, following the system instructions exactly.";
+/** The user turn for one primary attempt (issue #5, R1): the route's rendered
+ * `prompt.user` template when declared — same variables, capability
+ * conditionals and `x-trust` removal as the system template — else the fixed
+ * trigger (byte-identical to pre-R1). Pure; exported for the run tests. */
+export declare function userTurnFor(route: Pick<RouteBundle, "userTemplate">, ctx: {
+    readonly variables: Record<string, unknown>;
+    readonly capabilities: ReadonlySet<CapabilityFlag>;
+    readonly variableTrust?: Readonly<Record<string, "untrusted">>;
+}): string;
 export declare function run(deps: RunDeps, routeName: string, opts: RunOptions): Promise<RunResult>;
 //# sourceMappingURL=run.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/run/run.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAMrD,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,mBAAmB,CAAC;AAGvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAS3D,OAAO,KAAK,EAAE,cAAc,EAAoC,MAAM,aAAa,CAAC;AAUpF,OAAO,KAAK,EAAe,eAAe,EAAE,MAAM,YAAY,CAAC;AAQ/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACxD,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,+EAA+E;IAC/E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC;;gDAE4C;IAC5C,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IACzC,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IACvC;2EACuE;IACvE,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACxC;;0BAEsB;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IACxC,qDAAqD;IACrD,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C;;;mFAG+E;IAC/E,QAAQ,CAAC,aAAa,CAAC,EAAE,eAAe,CAAC;IACzC;;;;;uDAKmD;IACnD,QAAQ,CAAC,QAAQ,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAChD;;;;2EAIuE;IACvE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB;AAsBD,wBAAsB,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAwkBhG"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/run/run.ts"],"names":[],"mappings":"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"}