modelrig 0.3.0 → 0.5.0

package/dist/routes/loader-warnings.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Non-fatal loader advisories — extracted from loader.ts (kept it under the
+ * 700-LOC cap). Each is a pure function returning a warning line or null; the
+ * loader console.warns them after a bundle loads. Unit-tested directly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayRootSchemaWarning = arrayRootSchemaWarning;
+exports.unreferencedTrialCandidatesWarning = unreferencedTrialCandidatesWarning;
+/**
+ * CE-2 A5 co-item: warn (non-fatal) when a route's output schema has an ARRAY
+ * root. OpenAI strict structured output (`response_format: json_schema`, strict)
+ * requires a top-level OBJECT — an array-root schema cannot use strict
+ * enforcement on OpenAI candidates and silently falls back to non-strict there
+ * (the walkthrough §10 provider-matrix gap). The route still LOADS and serves as
+ * declared; the fix is to wrap the array in an object property so strict
+ * enforcement holds across every provider. Returns the warning line, or null.
+ */
+function arrayRootSchemaWarning(route, outputSchema) {
+    if (outputSchema === null)
+        return null;
+    const rootType = outputSchema.type;
+    if (rootType !== "array")
+        return null;
+    return (`route "${route}" declares an output schema whose ROOT is type: "array". OpenAI strict ` +
+        `structured output requires a top-level object, so strict enforcement cannot apply on OpenAI ` +
+        `candidates (they fall back to non-strict there). Wrap the array in an object property ` +
+        `(e.g. { "type": "object", "properties": { "items": <your array> } }) to keep strict ` +
+        `enforcement across providers. The route loads and serves as declared.`);
+}
+/**
+ * Declare-first dead-declaration warning (routing-console spec §4.4): a `trial`
+ * candidate that no variant references can never be reached — not live (trial
+ * candidates are dropped on every live path) and not in a bake-off (a bake-off
+ * replays a NAMED variant, and no variant narrows to it). Warn so the author
+ * either adds the `trial-<provider>-<model>` variant the declare flow emits or
+ * removes the dangling candidate. Non-fatal (the route still loads and serves
+ * its live candidates as declared). Pure — unit-tested directly. Returns the
+ * warning line, or null when every trial candidate is referenced.
+ */
+function unreferencedTrialCandidatesWarning(route, candidates, variants) {
+    const referenced = new Set();
+    for (const v of variants) {
+        for (const c of v.candidates ?? [])
+            referenced.add(`${c.provider}/${c.model}`);
+    }
+    const dangling = candidates
+        .filter((c) => c.trial === true && !referenced.has(`${c.provider}/${c.model}`))
+        .map((c) => `${c.provider}/${c.model}`);
+    if (dangling.length === 0)
+        return null;
+    return (`route "${route}" declares trial candidate(s) [${dangling.join(", ")}] that no variant references. ` +
+        `A trial candidate is declared but never served live; it is only reachable through a bake-off of a ` +
+        `variant that narrows to it. Add a variant (e.g. { name: "trial-${dangling[0].replace("/", "-")}", ` +
+        `candidates: [<that candidate>] }) to bake it off, or remove the dangling declaration.`);
+}

package/dist/routes/loader.d.ts

@@ -4,17 +4,7 @@
  * resolves schema/prompt paths relative to the bundle file, freezes.
  */
 import type { RouteBundle } from "../types/route";
-/**
- * CE-2 A5 co-item: warn (non-fatal) when a route's output schema has an ARRAY
- * root. OpenAI strict structured output (`response_format: json_schema`, strict)
- * requires a top-level OBJECT — an array-root schema cannot use strict
- * enforcement on OpenAI candidates and silently falls back to non-strict there
- * (the walkthrough §10 provider-matrix gap). The route still LOADS and serves as
- * declared; the fix is to wrap the array in an object property so strict
- * enforcement holds across every provider. Returns the warning line, or null.
- * Pure — unit-tested directly.
- */
-export declare function arrayRootSchemaWarning(route: string, outputSchema: object | null): string | null;
+export { arrayRootSchemaWarning, unreferencedTrialCandidatesWarning } from "./loader-warnings";
 /**
  * Structured config error thrown for any invalid bundle (never a raw Error).
  * Load-time problems are deliberately NOT RigFailures — the failure taxonomy

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

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/routes/loader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,KAAK,EAKV,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAMxB;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAWhG;AAED;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;gBAEzB,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;KAAO;CAOxF;AAiCD,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC;IAChC,IAAI,IAAI,SAAS,WAAW,EAAE,CAAC;CAChC;AA4ZD;;;;;;;GAOG;AACH;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,CAItF;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,YAAY,CAyB1F;AAED;;yBAEyB;AACzB,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE,CA6CtE;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CA2C1D"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/routes/loader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,KAAK,EAKV,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAUxB,OAAO,EAAE,sBAAsB,EAAE,kCAAkC,EAAE,MAAM,mBAAmB,CAAC;AAE/F;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;gBAEzB,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;KAAO;CAOxF;AAiCD,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC;IAChC,IAAI,IAAI,SAAS,WAAW,EAAE,CAAC;CAChC;AAucD;;;;;;;GAOG;AACH;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,CAItF;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,YAAY,CAyB1F;AAED;;yBAEyB;AACzB,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE,CA6CtE;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CA2C1D"}

package/dist/routes/loader.js

@@ -5,8 +5,7 @@
  * resolves schema/prompt paths relative to the bundle file, freezes.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteConfigError = void 0;
-exports.arrayRootSchemaWarning = arrayRootSchemaWarning;
+exports.RouteConfigError = exports.unreferencedTrialCandidatesWarning = exports.arrayRootSchemaWarning = void 0;
 exports.loadRoutesWithExtra = loadRoutesWithExtra;
 exports.mergeLoadedRoutes = mergeLoadedRoutes;
 exports.validateRoutesDir = validateRoutesDir;
@@ -19,28 +18,13 @@ const fingerprint_1 = require("../registry/fingerprint");
 const template_1 = require("./template");
 const cache_lint_1 = require("./cache-lint");
 const sampling_config_1 = require("./sampling-config");
-/**
- * CE-2 A5 co-item: warn (non-fatal) when a route's output schema has an ARRAY
- * root. OpenAI strict structured output (`response_format: json_schema`, strict)
- * requires a top-level OBJECT — an array-root schema cannot use strict
- * enforcement on OpenAI candidates and silently falls back to non-strict there
- * (the walkthrough §10 provider-matrix gap). The route still LOADS and serves as
- * declared; the fix is to wrap the array in an object property so strict
- * enforcement holds across every provider. Returns the warning line, or null.
- * Pure — unit-tested directly.
- */
-function arrayRootSchemaWarning(route, outputSchema) {
-    if (outputSchema === null)
-        return null;
-    const rootType = outputSchema.type;
-    if (rootType !== "array")
-        return null;
-    return (`route "${route}" declares an output schema whose ROOT is type: "array". OpenAI strict ` +
-        `structured output requires a top-level object, so strict enforcement cannot apply on OpenAI ` +
-        `candidates (they fall back to non-strict there). Wrap the array in an object property ` +
-        `(e.g. { "type": "object", "properties": { "items": <your array> } }) to keep strict ` +
-        `enforcement across providers. The route loads and serves as declared.`);
-}
+const loader_warnings_1 = require("./loader-warnings");
+// Re-exported so existing importers of "./loader" keep resolving these pure
+// advisories (they now live in ./loader-warnings to hold loader.ts under the
+// 700-LOC cap).
+var loader_warnings_2 = require("./loader-warnings");
+Object.defineProperty(exports, "arrayRootSchemaWarning", { enumerable: true, get: function () { return loader_warnings_2.arrayRootSchemaWarning; } });
+Object.defineProperty(exports, "unreferencedTrialCandidatesWarning", { enumerable: true, get: function () { return loader_warnings_2.unreferencedTrialCandidatesWarning; } });
 /**
  * Structured config error thrown for any invalid bundle (never a raw Error).
  * Load-time problems are deliberately NOT RigFailures — the failure taxonomy
@@ -101,7 +85,18 @@ function parseCandidates(raw, problems) {
             problems.push(`candidates[${i}].provider "${c.provider}" is not a known provider`);
             continue;
         }
-        out.push(Object.freeze({ provider: c.provider, model: c.model }));
+        // Declare-first `trial` flag (routing-console spec §4.4): declared, never
+        // live-served. Optional; only `true` is carried so an absent/false flag
+        // leaves the candidate byte-identical to a pre-R3 candidate.
+        if (c.trial !== undefined && typeof c.trial !== "boolean") {
+            problems.push(`candidates[${i}].trial must be a boolean`);
+            continue;
+        }
+        out.push(Object.freeze({
+            provider: c.provider,
+            model: c.model,
+            ...(c.trial === true ? { trial: true } : {}),
+        }));
     }
     return out;
 }
@@ -223,6 +218,13 @@ function parseRepair(raw, field, candidates, problems) {
             problems.push(`${field}.repair_model (${repairModel.provider}/${repairModel.model}) is not in the route's declared candidates`);
             repairModel = null;
         }
+        // Declare-first (spec §4.4): the repair model dispatches LIVE, so a `trial`
+        // candidate (declared, never live-served) must not be one — reject at load.
+        const rm = repairModel;
+        if (rm !== null && candidates.some((c) => c.provider === rm.provider && c.model === rm.model && c.trial === true)) {
+            problems.push(`${field}.repair_model (${rm.provider}/${rm.model}) is a trial candidate and cannot be a live repair model`);
+            repairModel = null;
+        }
     }
     if (maxRepairs === 2 && repairModel === null) {
         problems.push(`${field}.max_repairs=2 requires repair_model (attempt 2 is the designated repair model)`);
@@ -271,6 +273,14 @@ function parseVariants(raw, routeCandidates, problems) {
                 }
             }
         }
+        // trialOnly (routing-console spec §4.4): a variant whose candidates ALL map
+        // to declared `trial` candidates is a trial variant — valid for a bake-off,
+        // a live config error. Computed from the route-level trial flags (a variant
+        // narrows a subset; the flag lives on the declared candidate), so an empty
+        // or inherited candidate list is never trial-only.
+        const trialOnly = candidates !== undefined &&
+            candidates.length > 0 &&
+            candidates.every((vc) => routeCandidates.some((rc) => rc.provider === vc.provider && rc.model === vc.model && rc.trial === true));
         if (v.prompt_override !== undefined && v.prompt_append !== undefined) {
             problems.push(`${field} sets both prompt_override and prompt_append — they are mutually exclusive`);
         }
@@ -293,6 +303,7 @@ function parseVariants(raw, routeCandidates, problems) {
                 ? { json: v.json }
                 : {}),
             ...(repair !== undefined ? { repair } : {}),
+            ...(trialOnly ? { trialOnly: true } : {}),
         }));
     }
     return out;
@@ -440,10 +451,17 @@ function loadBundleFile(filePath) {
     }
     // CE-2 A5 co-item: an array-root schema cannot use OpenAI strict enforcement —
     // warn once at load so the incompatibility is deliberate, never silent.
-    const arrayRootWarning = arrayRootSchemaWarning(route, outputSchema);
+    const arrayRootWarning = (0, loader_warnings_1.arrayRootSchemaWarning)(route, outputSchema);
     if (arrayRootWarning !== null) {
         console.warn(`modelrig: ${arrayRootWarning}`);
     }
+    // Declare-first dead-declaration warning (spec §4.4): a trial candidate no
+    // variant references is unreachable — warn so the dangling declaration is
+    // deliberate, never silent.
+    const trialWarning = (0, loader_warnings_1.unreferencedTrialCandidatesWarning)(route, candidates, variants);
+    if (trialWarning !== null) {
+        console.warn(`modelrig: ${trialWarning}`);
+    }
     return Object.freeze({
         route: route,
         version: version,

package/dist/routes/sampling-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampling-config.d.ts","sourceRoot":"","sources":["../../src/routes/sampling-config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAMjE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAAE,GACjB,cAAc,GAAG,SAAS,CAmC5B;AAED;yEACyE;AACzE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,SAAS,aAAa,EAAE,GACnC,MAAM,GAAG,IAAI,CAaf"}
+{"version":3,"file":"sampling-config.d.ts","sourceRoot":"","sources":["../../src/routes/sampling-config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAMjE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAAE,GACjB,cAAc,GAAG,SAAS,CAgD5B;AAED;yEACyE;AACzE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,SAAS,aAAa,EAAE,GACnC,MAAM,GAAG,IAAI,CAaf"}

package/dist/routes/sampling-config.js

@@ -27,6 +27,17 @@ function parseSampling(raw, field, problems) {
         problems.push(`${field} must be an object {temperature?, top_p?, max_output_tokens?}`);
         return undefined;
     }
+    // Reject unknown keys — the sampling block is a closed 3-key set, and its whole
+    // reason to exist is that sampling params must never vanish SILENTLY. A typo
+    // (`temperatur`, `maxOutputTokens` camelCase, `top-p`) would otherwise leave the
+    // block empty and run at the adapter default — the exact silent-drop CE-6 kills.
+    // So here (unlike the lenient rest of `policy`) an unknown key is a config error.
+    const KNOWN = new Set(["temperature", "top_p", "max_output_tokens"]);
+    for (const key of Object.keys(raw)) {
+        if (!KNOWN.has(key)) {
+            problems.push(`${field} has unknown key "${key}" — allowed: temperature, top_p, max_output_tokens (snake_case)`);
+        }
+    }
     const out = {};
     const t = raw.temperature;
     if (t !== undefined) {

package/dist/run/dispatch.d.ts

@@ -11,7 +11,8 @@
 import type { AdapterRequest, AdapterResult, CandidateRef, ProviderAdapter } from "../types/provider";
 import type { RigFailure } from "../types/failures";
 import type { RouteBundle, RunMeta, RunOptions, RunResult, RunTags } from "../types/route";
-import type { TelemetryStore } from "../types/telemetry";
+import type { TelemetryRung, TelemetryStore } from "../types/telemetry";
+import type { LadderKeyMinter } from "./ladder-key";
 /** One telemetry attempt row's inputs — shared with run.ts's recordAttempt so
  * the tool-call helper here can record through the same closure. */
 export interface AttemptTelemetry {
@@ -34,6 +35,10 @@ export interface AttemptTelemetry {
     readonly repairedBy?: string;
     /** Addendum A1: model had no pricing entry (cost recorded as honest 0). */
     readonly pricingMissing?: boolean;
+    /** Explicit ladder-rung hint (R1 review, F1). Only the tool-call path sets it
+     * (`tool_call`); every other rung is derived in the recorder from the
+     * repaired_by / pre-dispatch / primary-vs-retry signals. */
+    readonly rung?: TelemetryRung;
 }
 /** run.ts's recordAttempt, threaded in so the tool-call path records through
  * the same ledger/tenancy closure the rest of the loop uses. */
@@ -41,7 +46,11 @@ export type RecordAttempt = (attempt: AttemptTelemetry) => string;
 /** Record the grounding-inject search's own telemetry row (WS3): a $-only line
  * under the synthetic "search" provider. Extracted from run.ts to keep it under
  * the LOC cap; behaviour is byte-identical to the prior inline recorder. */
-export declare function recordSearchCostRow(telemetry: TelemetryStore, route: RouteBundle, effectiveTags: RunTags, servedVariant: string | null, searchProviderId: string, costUsd: number): void;
+export declare function recordSearchCostRow(telemetry: TelemetryStore, route: RouteBundle, effectiveTags: RunTags, servedVariant: string | null, searchProviderId: string, costUsd: number, ladder: LadderKeyMinter): void;
+/** Schema coaching for the json_mode rung — ported from the production DeepSeek
+ * provider's schema-in-prompt guidance (minLength-is-a-FLOOR etc.). Lives here
+ * with the other request-shaping helpers to keep run.ts under the LOC cap. */
+export declare function jsonModeCoaching(schema: object): string;
 /** Side-channel for streaming: the run loop hands raw text deltas here as the
  * serving adapter streams. Absent => buffered dispatch via `adapter.call()`
  * (identical to pre-Phase-A behavior). */
@@ -86,6 +95,9 @@ export interface ToolCallResultParts {
     readonly attemptsByClass: RunMeta["attemptsByClass"];
     readonly servedVariant: string | null;
     readonly pricingMissing: boolean;
+    /** The call's ladder-key id (spec §2.1 R0) — surfaced on the tool-call meta so
+     * it matches the recorded row's `call_id`. */
+    readonly callId: string;
 }
 /**
  * Record a tool-call turn and build its RunResult (spec §4.4). A tool call is

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

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

package/dist/run/dispatch.js

@@ -11,6 +11,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.recordSearchCostRow = recordSearchCostRow;
+exports.jsonModeCoaching = jsonModeCoaching;
 exports.buildAdapterRequest = buildAdapterRequest;
 exports.buildRepairAdapterRequest = buildRepairAdapterRequest;
 exports.dispatchCandidate = dispatchCandidate;
@@ -21,7 +22,11 @@ const cache_handle_1 = require("./cache-handle");
 /** Record the grounding-inject search's own telemetry row (WS3): a $-only line
  * under the synthetic "search" provider. Extracted from run.ts to keep it under
  * the LOC cap; behaviour is byte-identical to the prior inline recorder. */
-function recordSearchCostRow(telemetry, route, effectiveTags, servedVariant, searchProviderId, costUsd) {
+function recordSearchCostRow(telemetry, route, effectiveTags, servedVariant, searchProviderId, costUsd, ladder) {
+    // Ladder key (spec §2.1 R0): the search-cost row belongs to the same call and
+    // rides the same monotonic seq; candidate_index is the candidate this search
+    // grounds for (the current one — the run loop set it before the search).
+    const ladderKey = ladder.stamp();
     telemetry.record({
         id: (0, node_crypto_1.randomUUID)(),
         ts: new Date().toISOString(),
@@ -41,15 +46,33 @@ function recordSearchCostRow(telemetry, route, effectiveTags, servedVariant, sea
         ttfbMs: null,
         failureClass: null,
         attemptsJson: "{}",
-        tagsJson: JSON.stringify(effectiveTags),
+        // Rung tag (R1 review, F1): the grounding-inject search-cost row.
+        tagsJson: JSON.stringify({ ...effectiveTags, rung: "search" }),
         fingerprintCell: route.fingerprintCell,
         servedVariant,
         repairedBy: null,
         pricingMissing: false,
         cacheKey: null,
         prefixFingerprint: null,
+        callId: ladderKey.callId,
+        attemptSeq: ladderKey.attemptSeq,
+        candidateIndex: ladderKey.candidateIndex,
     });
 }
+/** Schema coaching for the json_mode rung — ported from the production DeepSeek
+ * provider's schema-in-prompt guidance (minLength-is-a-FLOOR etc.). Lives here
+ * with the other request-shaping helpers to keep run.ts under the LOC cap. */
+function jsonModeCoaching(schema) {
+    return ("\n\n---\nOUTPUT FORMAT (STRICT): Respond with a SINGLE valid JSON object and nothing else — " +
+        'no markdown fences, no introductory text, no sign-off. Your response MUST start with "{" and ' +
+        'end with "}". Sanitize every nested string so embedded quotes/brackets do not break the root ' +
+        "JSON escaping. The object MUST conform to this JSON Schema — match key names and types " +
+        "EXACTLY, include ALL required fields, and do not add commentary fields. CRITICAL: where the " +
+        "schema sets a minLength on a narrative/prose field, that is a FLOOR, not a target — write " +
+        "thorough, non-repetitive analysis that comfortably EXCEEDS the minimum (do not pad with " +
+        "repetition; add real substance). When unsure how long to make a prose field, write more, " +
+        `not less:\n\n${JSON.stringify(schema)}`);
+}
 /** Build the primary-attempt AdapterRequest — adds the grounding hint and the
  * unified tools/toolChoice passthrough (spec §4.4). */
 function buildAdapterRequest(parts) {
@@ -165,6 +188,11 @@ function emitToolCallResult(record, parts) {
         ...(result.usage.ttfbMs !== undefined ? { ttfbMs: result.usage.ttfbMs } : {}),
         failure: null,
         pricingMissing: parts.pricingMissing,
+        // Rung tag (R1 review, F1): a tool-call turn is a real model call but NOT a
+        // schema-validated serve — the recorder cannot tell it from a primary, so it
+        // is stamped explicitly. The rollup counts it as a tool-call turn, never a
+        // dispatch or a serve (its cost still counts).
+        rung: "tool_call",
     });
     return {
         output: null,
@@ -185,6 +213,7 @@ function emitToolCallResult(record, parts) {
             attemptsByClass,
             servedVariant,
             repairedBy: null,
+            callId: parts.callId,
             toolCalls: result.toolCalls,
         },
     };

package/dist/run/ladder-key.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The per-call telemetry ladder key — routing-console spec §2.1 / §4.1 (R0).
+ *
+ * One `callId` is minted per `rig.run` / `runStream` / `runBundle` / `runRaw`
+ * invocation and shared by EVERY telemetry row that call writes (primary, retry,
+ * repair, grounding-search, tool-call). `attemptSeq` is a 1-based counter that
+ * is monotonic across all of those rows, and `candidateIndex` is the position of
+ * the candidate the row is about within the call's effective declared list.
+ *
+ * The minter owns the seq counter and the current candidate index so the run
+ * loop does not have to thread them through every `recordAttempt` call site
+ * (run.ts sits at its LOC cap). The loop calls `setCandidateIndex` as the
+ * candidate iterator advances; the recorder (and the search-cost recorder) call
+ * `stamp()` once per row. A repair row is stamped DURING the current candidate's
+ * turn — before the iterator advances — so it inherits that candidate's index,
+ * which IS "the candidate being repaired" per spec §2.1.
+ */
+/** One stamped ladder key — the three fields persisted onto a telemetry row. */
+export interface LadderKey {
+    readonly callId: string;
+    readonly attemptSeq: number;
+    readonly candidateIndex: number | null;
+}
+/** Hands out ladder keys for a single call. Created once per invocation. */
+export interface LadderKeyMinter {
+    /** The `call_id` shared by every row of this invocation. */
+    readonly callId: string;
+    /** Record the candidate the run loop is currently attempting. Every later
+     * `stamp()` reads this value; a null clears it (no active candidate). */
+    setCandidateIndex(index: number | null): void;
+    /** Stamp the next row: bump `attempt_seq` (1-based, monotonic) and read the
+     * current `candidate_index`. */
+    stamp(): LadderKey;
+}
+/**
+ * Build a ladder-key minter. `callId` defaults to a fresh uuid; the raw lane and
+ * tests may pass one in. Pure but for the uuid — no I/O, no shared state.
+ */
+export declare function createLadderKeyMinter(callId?: string): LadderKeyMinter;
+//# sourceMappingURL=ladder-key.d.ts.map

package/dist/run/ladder-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ladder-key.d.ts","sourceRoot":"","sources":["../../src/run/ladder-key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,gFAAgF;AAChF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC;AAED,4EAA4E;AAC5E,MAAM,WAAW,eAAe;IAC9B,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;6EACyE;IACzE,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IAC9C;oCACgC;IAChC,KAAK,IAAI,SAAS,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,GAAE,MAAqB,GAAG,eAAe,CAapF"}

package/dist/run/ladder-key.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * The per-call telemetry ladder key — routing-console spec §2.1 / §4.1 (R0).
+ *
+ * One `callId` is minted per `rig.run` / `runStream` / `runBundle` / `runRaw`
+ * invocation and shared by EVERY telemetry row that call writes (primary, retry,
+ * repair, grounding-search, tool-call). `attemptSeq` is a 1-based counter that
+ * is monotonic across all of those rows, and `candidateIndex` is the position of
+ * the candidate the row is about within the call's effective declared list.
+ *
+ * The minter owns the seq counter and the current candidate index so the run
+ * loop does not have to thread them through every `recordAttempt` call site
+ * (run.ts sits at its LOC cap). The loop calls `setCandidateIndex` as the
+ * candidate iterator advances; the recorder (and the search-cost recorder) call
+ * `stamp()` once per row. A repair row is stamped DURING the current candidate's
+ * turn — before the iterator advances — so it inherits that candidate's index,
+ * which IS "the candidate being repaired" per spec §2.1.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLadderKeyMinter = createLadderKeyMinter;
+const node_crypto_1 = require("node:crypto");
+/**
+ * Build a ladder-key minter. `callId` defaults to a fresh uuid; the raw lane and
+ * tests may pass one in. Pure but for the uuid — no I/O, no shared state.
+ */
+function createLadderKeyMinter(callId = (0, node_crypto_1.randomUUID)()) {
+    let attemptSeq = 0;
+    let candidateIndex = null;
+    return {
+        callId,
+        setCandidateIndex(index) {
+            candidateIndex = index;
+        },
+        stamp() {
+            attemptSeq += 1;
+            return { callId, attemptSeq, candidateIndex };
+        },
+    };
+}

package/dist/run/raw-defaults.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Raw-lane defaults (#245, spec R1–R3) — the SINGLE source of truth for what
+ * `rig.runRaw` sends when the caller omits a knob, and the generator behind the
+ * published defaults table.
+ *
+ * WHY ITS OWN FILE: `raw.ts` sits near the 700-LOC invariant cap, and this table
+ * is the CE-9/`raw-support.ts` pattern — a code constant the runtime reads AND
+ * the docs generator renders, so the published table can never drift from the
+ * behaviour. `raw.ts` imports `RAW_TIMEOUT_DEFAULT_MS` and resolves the effective
+ * timeout from it; the docs builder injects `renderRawDefaults()` at the
+ * `<!-- RAW_DEFAULTS -->` marker in `route-bundles.md` and into llms.txt. The
+ * drift test asserts the rendered `timeoutMs` default is read from THIS constant
+ * (never retyped), so the table and the dispatch agree by construction.
+ */
+import type { ServiceTier } from "../types/provider";
+/**
+ * R1 — the tier-aware raw-lane timeout default (ms). A raw passthrough should not
+ * be shorter-fused than the tier it advertises: `standard`/`priority` target up
+ * to 5 min (grounded + large prompts routinely exceed the old 120 s even at
+ * standard), `flex` targets the 15-minute budget ModelRig advertises. An explicit
+ * `RawRunInput.timeoutMs` always wins; this is only the fallback, and a `timeout`
+ * failure on the raw lane teaches the tier + budget in its `fixHint`.
+ */
+export declare const RAW_TIMEOUT_DEFAULT_MS: Record<ServiceTier, number>;
+/** One row of the generated defaults table (R2/R3). */
+export interface RawDefaultRow {
+    /** The `RawRunInput` field this row documents. */
+    readonly knob: string;
+    /** The value sent when the caller omits the knob — DERIVED from the constant
+     * the runtime uses where one exists (timeoutMs), so it cannot drift. */
+    readonly default: string;
+    /** The teaching note rendered in the table cell. */
+    readonly note: string;
+}
+/**
+ * The defaults table (R2/R3) — every behavioural `RawRunInput` knob and what the
+ * raw lane does when the caller omits it. `provider`/`model`/`apiKey`/
+ * `systemPrompt`/`userPrompt` are the call itself, not defaultable knobs, so they
+ * are not listed. Exhaustive over the optional knobs the raw lane exposes; a new
+ * knob added to `RawRunInput` should gain a row here (and the `route-bundles`
+ * coverage test guards the important ones).
+ */
+export declare const RAW_DEFAULTS: readonly RawDefaultRow[];
+/**
+ * Render the defaults table as a Markdown table, FROM `RAW_DEFAULTS` (never a
+ * hand-written twin — R2/R3). Consumed by the docs generator
+ * (scripts/build-docs-site.ts) at the `<!-- RAW_DEFAULTS -->` marker and in
+ * llms.txt, so the published table and the runtime defaults derive from one
+ * source.
+ */
+export declare function renderRawDefaults(): string;
+//# sourceMappingURL=raw-defaults.d.ts.map

package/dist/run/raw-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-defaults.d.ts","sourceRoot":"","sources":["../../src/run/raw-defaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAI9D,CAAC;AAEF,uDAAuD;AACvD,MAAM,WAAW,aAAa;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;4EACwE;IACxE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAeD;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,aAAa,EA6DhD,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAK1C"}

package/dist/run/raw-defaults.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Raw-lane defaults (#245, spec R1–R3) — the SINGLE source of truth for what
+ * `rig.runRaw` sends when the caller omits a knob, and the generator behind the
+ * published defaults table.
+ *
+ * WHY ITS OWN FILE: `raw.ts` sits near the 700-LOC invariant cap, and this table
+ * is the CE-9/`raw-support.ts` pattern — a code constant the runtime reads AND
+ * the docs generator renders, so the published table can never drift from the
+ * behaviour. `raw.ts` imports `RAW_TIMEOUT_DEFAULT_MS` and resolves the effective
+ * timeout from it; the docs builder injects `renderRawDefaults()` at the
+ * `<!-- RAW_DEFAULTS -->` marker in `route-bundles.md` and into llms.txt. The
+ * drift test asserts the rendered `timeoutMs` default is read from THIS constant
+ * (never retyped), so the table and the dispatch agree by construction.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RAW_DEFAULTS = exports.RAW_TIMEOUT_DEFAULT_MS = void 0;
+exports.renderRawDefaults = renderRawDefaults;
+/**
+ * R1 — the tier-aware raw-lane timeout default (ms). A raw passthrough should not
+ * be shorter-fused than the tier it advertises: `standard`/`priority` target up
+ * to 5 min (grounded + large prompts routinely exceed the old 120 s even at
+ * standard), `flex` targets the 15-minute budget ModelRig advertises. An explicit
+ * `RawRunInput.timeoutMs` always wins; this is only the fallback, and a `timeout`
+ * failure on the raw lane teaches the tier + budget in its `fixHint`.
+ */
+exports.RAW_TIMEOUT_DEFAULT_MS = {
+    standard: 300000,
+    priority: 300000,
+    flex: 900000,
+};
+/** Render `${ms} ms` as whole seconds (both defaults are whole-second values). */
+function secs(ms) {
+    return `${ms / 1000} s`;
+}
+/** The tier-aware `timeoutMs` default, rendered FROM `RAW_TIMEOUT_DEFAULT_MS`
+ * (never a retyped literal — the drift test locks this to the constant). */
+function timeoutDefaultCell() {
+    return `${secs(exports.RAW_TIMEOUT_DEFAULT_MS.standard)} (standard, priority) · ${secs(exports.RAW_TIMEOUT_DEFAULT_MS.flex)} (flex)`;
+}
+/**
+ * The defaults table (R2/R3) — every behavioural `RawRunInput` knob and what the
+ * raw lane does when the caller omits it. `provider`/`model`/`apiKey`/
+ * `systemPrompt`/`userPrompt` are the call itself, not defaultable knobs, so they
+ * are not listed. Exhaustive over the optional knobs the raw lane exposes; a new
+ * knob added to `RawRunInput` should gain a row here (and the `route-bundles`
+ * coverage test guards the important ones).
+ */
+exports.RAW_DEFAULTS = [
+    {
+        knob: "timeoutMs",
+        default: timeoutDefaultCell(),
+        note: "tier-aware wall-clock deadline; an explicit `timeoutMs` always wins, and a `timeout` failure carries a `fixHint` naming the tier + budget",
+    },
+    {
+        knob: "serviceTier",
+        default: "standard",
+        note: "forwarded to the adapter; `meta.servedTier` reports what actually served. On `flex`, set `timeoutMs` in minutes (default 900 s)",
+    },
+    {
+        knob: "temperature",
+        default: "adapter default — not sent",
+        note: "absent ⇒ no `temperature` on the request (byte-identical dispatch)",
+    },
+    {
+        knob: "topP",
+        default: "adapter default — not sent",
+        note: "absent ⇒ no `topP` on the request (byte-identical dispatch)",
+    },
+    {
+        knob: "maxOutputTokens",
+        default: "adapter default — not sent",
+        note: "absent ⇒ no output-token cap on the request (byte-identical dispatch)",
+    },
+    {
+        knob: "grounding",
+        default: "absent ⇒ byte-identical",
+        note: "native provider grounding; provider support per the raw-lane knob matrix",
+    },
+    {
+        knob: "reasoning",
+        default: "absent ⇒ byte-identical",
+        note: "reasoning/thinking effort; provider support per the raw-lane knob matrix",
+    },
+    {
+        knob: "responseFormat",
+        default: "absent ⇒ byte-identical",
+        note: "syntactic-JSON forcing (mime-shaping only); provider support per the raw-lane knob matrix",
+    },
+    {
+        knob: "cache",
+        default: "none",
+        note: "customer cache handle passed through verbatim when supplied; ModelRig never creates, refreshes, or deletes the resource",
+    },
+    {
+        knob: "tags",
+        default: "none",
+        note: "`lane=raw` and `rung=primary` are stamped by the SDK and cannot be overridden by a caller tag",
+    },
+    {
+        knob: "tools / toolChoice",
+        default: "none",
+        note: "absent ⇒ no tools declared; on the raw lane a grounding-originated `functionCall` part is NOT a tool-call turn",
+    },
+    {
+        knob: "stepKey",
+        default: "auto — `tags.step`, else `<provider>/<model>#<n>` inside a run context",
+        note: "names the ground-truth step a run context records for this call (G1); explicit key wins; no run context ⇒ no step",
+    },
+];
+/**
+ * Render the defaults table as a Markdown table, FROM `RAW_DEFAULTS` (never a
+ * hand-written twin — R2/R3). Consumed by the docs generator
+ * (scripts/build-docs-site.ts) at the `<!-- RAW_DEFAULTS -->` marker and in
+ * llms.txt, so the published table and the runtime defaults derive from one
+ * source.
+ */
+function renderRawDefaults() {
+    const header = "| Knob | Default | Note |";
+    const sep = "|---|---|---|";
+    const rows = exports.RAW_DEFAULTS.map((r) => `| \`${r.knob}\` | ${r.default} | ${r.note} |`);
+    return [header, sep, ...rows].join("\n");
+}