modelrig 0.9.0 → 0.10.0

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;AAWxB,OAAO,EAAE,sBAAsB,EAAE,kCAAkC,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AAE/H;;;;;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;AAscD;;;;;;;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;AASH,OAAO,KAAK,EAKV,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAaxB,OAAO,EAAE,sBAAsB,EAAE,kCAAkC,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AAE/H;;;;;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;AA+BD,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC;IAChC,IAAI,IAAI,SAAS,WAAW,EAAE,CAAC;CAChC;AA2aD;;;;;;;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

@@ -14,13 +14,17 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const yaml_1 = require("yaml");
 const failures_1 = require("../types/failures");
+const provider_1 = require("../types/provider");
 const fingerprint_1 = require("../registry/fingerprint");
 const cache_lint_1 = require("./cache-lint");
+const destination_loader_1 = require("./destination-loader"); // U2 (D-2): validated `destination` field (carved out for the LOC cap)
 const sampling_config_1 = require("./sampling-config");
 const loader_warnings_1 = require("./loader-warnings");
 const screen_loader_1 = require("./screen-loader");
+const prompt_loader_1 = require("./prompt-loader"); // issue #5 (R1): `prompt.user` + the prompt block (moved out for the LOC cap)
 const mask_loader_1 = require("./mask-loader");
 const objective_loader_1 = require("./objective-loader");
+const output_loader_1 = require("./output-loader"); // issue #1: `output: text` (prose) + the schema reader (moved out for the LOC cap)
 // Re-exported so existing importers of "./loader" keep resolving these advisories
 // (they live in ./loader-warnings to hold loader.ts under the 700-LOC cap).
 var loader_warnings_2 = require("./loader-warnings");
@@ -43,13 +47,11 @@ class RouteConfigError extends Error {
     }
 }
 exports.RouteConfigError = RouteConfigError;
-const PROVIDERS = new Set([
-    "gemini",
-    "openai",
-    "deepseek",
-    "anthropic",
-    "grok",
-]);
+// Provider allow-set for routable candidates and repair models (M-S1) — every
+// known ProviderId, now INCLUDING the ModelRig-hosted aggregator hosts
+// (fireworks/deepinfra/zai). Sourced from PROVIDER_IDS so it stays in lockstep
+// with the union (compacted from an inline literal to hold the 700-LOC cap).
+const PROVIDERS = new Set(provider_1.PROVIDER_IDS);
 const REQUIREMENTS = new Set([
     "schema_conformant",
     "grounded",
@@ -314,31 +316,6 @@ function parseVariants(raw, routeCandidates, problems) {
     }
     return out;
 }
-function readSchema(schemaRaw, bundleDir, problems) {
-    if (schemaRaw === null || schemaRaw === undefined)
-        return null;
-    if (typeof schemaRaw !== "string" || schemaRaw === "") {
-        problems.push("schema must be a relative path or null");
-        return null;
-    }
-    const schemaPath = (0, node_path_1.resolve)(bundleDir, schemaRaw);
-    if (!(0, node_fs_1.existsSync)(schemaPath)) {
-        problems.push(`schema file not found: ${schemaRaw}`);
-        return null;
-    }
-    try {
-        const parsed = JSON.parse((0, node_fs_1.readFileSync)(schemaPath, "utf8"));
-        if (!isRecord(parsed)) {
-            problems.push(`schema file ${schemaRaw} must contain a JSON object`);
-            return null;
-        }
-        return parsed;
-    }
-    catch (err) {
-        problems.push(`schema file ${schemaRaw} is not valid JSON: ${err.message}`);
-        return null;
-    }
-}
 function loadBundleFile(filePath) {
     const problems = [];
     let doc;
@@ -365,12 +342,14 @@ function loadBundleFile(filePath) {
     const candidates = parseCandidates(doc.candidates, problems);
     const require = parseStringList(doc.require, "require", REQUIREMENTS, problems);
     const prefer = parseStringList(doc.prefer, "prefer", PREFERENCES, problems);
-    const outputSchema = readSchema(doc.schema, bundleDir, problems);
+    const outputSchema = (0, output_loader_1.readSchema)(doc.schema, bundleDir, problems);
     const policy = parsePolicy(doc.policy, problems);
     // Phase 3 (bundle v2, all additive): variants, repair, capture opt-in,
     // grounding-inject query template.
     const variants = parseVariants(doc.variants, candidates, problems);
     const repair = parseRepair(doc.repair, "repair", candidates, problems);
+    // Issue #1: `output: text` (prose) — a load error when it contradicts schema:/require:/repair:.
+    const output = (0, output_loader_1.parseOutputBlock)(doc.output, { outputSchema, schemaDeclared: doc.schema !== undefined && doc.schema !== null, require, repair, variants }, problems);
     const capture = doc.capture ?? false;
     if (typeof capture !== "boolean") {
         problems.push("capture must be a boolean");
@@ -408,26 +387,12 @@ function loadBundleFile(filePath) {
     const mask = (0, mask_loader_1.parseMaskBlock)(doc.mask, bundleDir, problems);
     const screen = (0, screen_loader_1.parseScreenBlock)(doc.screen, problems);
     const classification = (0, screen_loader_1.parseClassificationAndPhiGate)(doc.classification, { mask, screen, require }, problems);
-    let systemTemplate = "";
-    let variables = [];
-    let variableTrust;
-    if (!isRecord(doc.prompt) || typeof doc.prompt.system !== "string") {
-        problems.push("prompt.system must be a relative path");
-    }
-    else {
-        const promptPath = (0, node_path_1.resolve)(bundleDir, doc.prompt.system);
-        if (!(0, node_fs_1.existsSync)(promptPath)) {
-            problems.push(`prompt.system file not found: ${doc.prompt.system}`);
-        }
-        else {
-            systemTemplate = (0, node_fs_1.readFileSync)(promptPath, "utf8");
-        }
-        // Screening S2 (SC-0 B3): parse names + optional per-variable x-trust.
-        const parsed = (0, screen_loader_1.parseVariables)(doc.prompt.variables ?? [], problems);
-        variables = parsed.names;
-        variableTrust = parsed.trust;
-    }
-    (0, screen_loader_1.pushUndeclaredVariableProblems)(systemTemplate, groundingQuery, variables, problems);
+    const destination = (0, destination_loader_1.parseDestination)(doc.destination, problems); // Unified Route U2 (D-2)
+    // `prompt.system` / `prompt.user` (issue #5, R1) / `prompt.variables` (+ S2
+    // x-trust) — parsed in prompt-loader.ts; both templates are files relative to
+    // the bundle and share one declared-variable list.
+    const { systemTemplate, userTemplate, variables, variableTrust } = (0, prompt_loader_1.parsePromptBlock)(doc.prompt, bundleDir, problems);
+    (0, screen_loader_1.pushUndeclaredVariableProblems)(systemTemplate, groundingQuery, variables, problems, userTemplate);
     if (problems.length > 0) {
         throw new RouteConfigError("invalid route bundle", { file: filePath, problems });
     }
@@ -462,14 +427,22 @@ function loadBundleFile(filePath) {
     const xTrustWarning = (0, loader_warnings_1.untrustedShapedVariableWarning)(route, variables, variableTrust);
     if (xTrustWarning !== null)
         console.warn(`modelrig: ${xTrustWarning}`);
+    // Issue #5 (R1) advisory: a cached route with a Gemini candidate, a non-empty
+    // system template and no `prompt.user` — a handle would deliver the template
+    // as the user turn (never dropped); name the rule so the shape is deliberate.
+    const cachedPromptWarning = (0, prompt_loader_1.cachedRouteSystemOnlyWarning)(route, cache, candidates, systemTemplate, userTemplate);
+    if (cachedPromptWarning !== null)
+        console.warn(`modelrig: ${cachedPromptWarning}`);
     return Object.freeze({
         route: route,
         version: version,
         outputSchema: outputSchema === null ? null : Object.freeze(outputSchema),
+        ...output, // outputKind/outputMinChars — present ONLY for `output: text` (json ⇒ nothing added)
         candidates: Object.freeze(candidates),
         require: Object.freeze(require),
         prefer: Object.freeze(prefer),
         systemTemplate,
+        ...(userTemplate !== undefined ? { userTemplate } : {}), // issue #5 (R1): present ONLY when declared (absent ⇒ unchanged bundle_sha)
         variables: Object.freeze(variables),
         policy,
         ...(repair !== undefined ? { repair } : {}),
@@ -481,7 +454,7 @@ function loadBundleFile(filePath) {
         ...(variableTrust !== undefined ? { variableTrust } : {}),
         ...(mask !== undefined ? { mask } : {}),
         ...(screen !== undefined ? { screen } : {}),
-        ...(classification !== undefined ? { classification } : {}),
+        ...(classification !== undefined ? { classification } : {}), ...(destination !== undefined ? { destination } : {}),
         // Network-effect instrumentation (spec WS6): computed once at load,
         // stamped on every telemetry row for this route.
         fingerprintCell: (0, fingerprint_1.fingerprintSchema)(outputSchema)?.cellKey ?? null,

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

@@ -0,0 +1,42 @@
+/**
+ * Route OUTPUT contract at load — the `schema:` file reader and the `output:`
+ * block (GitLab issue #1, incident 2026-10-11: a prose route had no way to say
+ * "my output is not JSON" and was rejected `content_invalid` on every call).
+ *
+ * Carved out of routes/loader.ts (which sits at the 700-LOC cap, dev-rule P1):
+ * `readSchema` is a PURE MOVE; `parseOutputBlock` is new.
+ *
+ * YAML forms accepted for `output:`:
+ *   (absent)                          → json  (the default; byte-identical)
+ *   output: json                      → json  (explicit; identical to absent)
+ *   output: text                      → text  (prose/markdown, returned verbatim)
+ *   output: { kind: text, min_chars: N } → text with a declared length floor
+ *   output: { kind: json }            → json
+ *
+ * The parsed result OMITS `outputKind` for json so a JSON route's bundle (and
+ * its `bundle_sha`) is unchanged; only `text` is ever carried.
+ */
+import type { RepairPolicy, Requirement, RouteVariant } from "../types/route";
+export declare const OUTPUT_KINDS: ReadonlySet<string>;
+export declare const PROSE_DOCS_ANCHOR = "route-bundles.md#prose-and-markdown-output-output-text";
+/** Resolve + parse the bundle's `schema:` file (null / absent ⇒ schema-less). */
+export declare function readSchema(schemaRaw: unknown, bundleDir: string, problems: string[]): object | null;
+export interface ParsedOutputBlock {
+    /** Present ONLY for `text` (json ⇒ omitted ⇒ byte-identical bundle). */
+    readonly outputKind?: "text";
+    readonly outputMinChars?: number;
+}
+/** What the loader already parsed that an `output: text` declaration must be
+ * consistent with — each conflict is a LOAD error that teaches, never a run-time
+ * surprise. */
+export interface OutputBlockContext {
+    readonly outputSchema: object | null;
+    readonly schemaDeclared: boolean;
+    readonly require: readonly Requirement[];
+    readonly repair: RepairPolicy | undefined;
+    readonly variants: readonly RouteVariant[];
+}
+/** Parse the bundle's `output:` key. Pushes teaching problems; returns `{}` for
+ * json (absent / explicit) so the bundle spread adds nothing. */
+export declare function parseOutputBlock(raw: unknown, ctx: OutputBlockContext, problems: string[]): ParsedOutputBlock;
+//# sourceMappingURL=output-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"output-loader.d.ts","sourceRoot":"","sources":["../../src/routes/output-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAc,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE1F,eAAO,MAAM,YAAY,EAAE,WAAW,CAAC,MAAM,CAAyC,CAAC;AAGvF,eAAO,MAAM,iBAAiB,2DAA2D,CAAC;AAM1F,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAsBnG;AAED,MAAM,WAAW,iBAAiB;IAChC,wEAAwE;IACxE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED;;eAEe;AACf,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;CAC5C;AAED;iEACiE;AACjE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,iBAAiB,CAqD7G"}

package/dist/routes/output-loader.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Route OUTPUT contract at load — the `schema:` file reader and the `output:`
+ * block (GitLab issue #1, incident 2026-10-11: a prose route had no way to say
+ * "my output is not JSON" and was rejected `content_invalid` on every call).
+ *
+ * Carved out of routes/loader.ts (which sits at the 700-LOC cap, dev-rule P1):
+ * `readSchema` is a PURE MOVE; `parseOutputBlock` is new.
+ *
+ * YAML forms accepted for `output:`:
+ *   (absent)                          → json  (the default; byte-identical)
+ *   output: json                      → json  (explicit; identical to absent)
+ *   output: text                      → text  (prose/markdown, returned verbatim)
+ *   output: { kind: text, min_chars: N } → text with a declared length floor
+ *   output: { kind: json }            → json
+ *
+ * The parsed result OMITS `outputKind` for json so a JSON route's bundle (and
+ * its `bundle_sha`) is unchanged; only `text` is ever carried.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROSE_DOCS_ANCHOR = exports.OUTPUT_KINDS = void 0;
+exports.readSchema = readSchema;
+exports.parseOutputBlock = parseOutputBlock;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+exports.OUTPUT_KINDS = new Set(["json", "text"]);
+const OUTPUT_BLOCK_KEYS = new Set(["kind", "min_chars"]);
+exports.PROSE_DOCS_ANCHOR = "route-bundles.md#prose-and-markdown-output-output-text";
+function isRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** Resolve + parse the bundle's `schema:` file (null / absent ⇒ schema-less). */
+function readSchema(schemaRaw, bundleDir, problems) {
+    if (schemaRaw === null || schemaRaw === undefined)
+        return null;
+    if (typeof schemaRaw !== "string" || schemaRaw === "") {
+        problems.push("schema must be a relative path or null");
+        return null;
+    }
+    const schemaPath = (0, node_path_1.resolve)(bundleDir, schemaRaw);
+    if (!(0, node_fs_1.existsSync)(schemaPath)) {
+        problems.push(`schema file not found: ${schemaRaw}`);
+        return null;
+    }
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(schemaPath, "utf8"));
+        if (!isRecord(parsed)) {
+            problems.push(`schema file ${schemaRaw} must contain a JSON object`);
+            return null;
+        }
+        return parsed;
+    }
+    catch (err) {
+        problems.push(`schema file ${schemaRaw} is not valid JSON: ${err.message}`);
+        return null;
+    }
+}
+/** Parse the bundle's `output:` key. Pushes teaching problems; returns `{}` for
+ * json (absent / explicit) so the bundle spread adds nothing. */
+function parseOutputBlock(raw, ctx, problems) {
+    if (raw === undefined || raw === null)
+        return {};
+    let kind;
+    let minChars;
+    if (typeof raw === "string") {
+        kind = raw;
+    }
+    else if (isRecord(raw)) {
+        for (const key of Object.keys(raw)) {
+            if (!OUTPUT_BLOCK_KEYS.has(key)) {
+                problems.push(`output.${key} is not a known key — the block is {kind: json|text, min_chars?: integer >= 1}`);
+            }
+        }
+        kind = raw.kind;
+        if (raw.min_chars !== undefined) {
+            if (typeof raw.min_chars !== "number" || !Number.isInteger(raw.min_chars) || raw.min_chars < 1) {
+                problems.push("output.min_chars must be an integer >= 1");
+            }
+            else {
+                minChars = raw.min_chars;
+            }
+        }
+    }
+    else {
+        problems.push(`output must be "json", "text", or {kind, min_chars?} — got ${JSON.stringify(raw)}`);
+        return {};
+    }
+    if (typeof kind !== "string" || !exports.OUTPUT_KINDS.has(kind)) {
+        problems.push(`output "${String(kind)}" is not one of [json, text] — write \`output: text\` for a prose/markdown route, ` +
+            `or omit it for JSON (the default)`);
+        return {};
+    }
+    if (kind === "json") {
+        if (minChars !== undefined)
+            problems.push("output.min_chars applies to output: text only — a JSON route conforms to its schema instead");
+        return {};
+    }
+    // kind === "text": the prose contract must not contradict the JSON machinery.
+    if (ctx.schemaDeclared || ctx.outputSchema !== null) {
+        problems.push("output: text cannot be combined with schema: — a prose route has no JSON Schema to conform to. " +
+            "Remove `schema:` (or set it to null), or drop `output: text` to serve JSON");
+    }
+    if (ctx.require.includes("schema_conformant")) {
+        problems.push("output: text cannot require schema_conformant — there is no schema; remove it from `require`");
+    }
+    const repairDeclared = ctx.repair !== undefined || ctx.variants.some((v) => v.repair !== undefined);
+    if (repairDeclared) {
+        problems.push("repair: is the JSON repair rung and never runs on an output: text route — remove it (a prose " +
+            "response that fails min_chars is retried from the content_invalid budget instead)");
+    }
+    return { outputKind: "text", ...(minChars !== undefined ? { outputMinChars: minChars } : {}) };
+}

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

@@ -0,0 +1,49 @@
+/**
+ * The bundle's `prompt:` block at load — `prompt.system`, the per-call
+ * `prompt.user` (GitLab issue #5, R1), and `prompt.variables`.
+ *
+ * Carved out of routes/loader.ts (which sits at the 700-LOC cap, dev-rule P1):
+ * the `prompt.system` + `variables` handling is a PURE MOVE; `prompt.user` and
+ * the cache/system-only advisory are new.
+ *
+ * YAML forms accepted for `prompt:`:
+ *   prompt: { system: <path>, variables: [...] }                 → today (byte-identical)
+ *   prompt: { system: <path>, user: <path>, variables: [...] }   → system + per-call user turn
+ *   prompt: { user: <path>, variables: [...] }                   → user turn only (empty system)
+ *
+ * Both templates are files relative to the bundle (same rule as `schema:`);
+ * both render with the same variables, capability conditionals and `x-trust`
+ * removal. `prompt.user` must be a non-empty file — an empty user turn next to
+ * a cache handle would send the handle and nothing else, the exact trap R1
+ * closes.
+ */
+import type { CandidateSpec } from "../types/route";
+export declare const CACHE_PROMPT_DOCS_ANCHOR = "caching-lifecycle.md#a-cache-handle-changes-where-the-template-is-delivered";
+export interface ParsedPromptBlock {
+    readonly systemTemplate: string;
+    /** Present ONLY when `prompt.user` was declared (absent ⇒ byte-identical bundle). */
+    readonly userTemplate?: string;
+    readonly variables: readonly string[];
+    readonly variableTrust?: Record<string, "untrusted">;
+}
+/**
+ * Parse the bundle's `prompt:` block. `prompt.system` stays REQUIRED unless
+ * `prompt.user` is declared (a user-turn-only route has an empty system
+ * template — the shape a Gemini cache handle wants, since the cache already
+ * holds the system content). Returns `systemTemplate: ""` on any problem so the
+ * caller's later checks stay total; the collected problems fail the load.
+ */
+export declare function parsePromptBlock(raw: unknown, bundleDir: string, problems: string[]): ParsedPromptBlock;
+/**
+ * Issue #5 (R1) advisory, P4 "errors teach": a route that opts into caching
+ * (`cache: auto`) AND has a Gemini candidate AND renders a non-empty system
+ * template with NO `prompt.user` is the shape that loses content the moment a
+ * customer passes a Gemini cache handle on `rig.run` — the handle forbids
+ * `systemInstruction`, so the rendered template is delivered as the user turn
+ * (never dropped), but the author almost certainly meant the cache to hold the
+ * prefix and `prompt.user` to hold the delta. Warn once at load naming the
+ * rule. Non-fatal: the route loads and serves as declared. Pure — unit-tested
+ * directly. Returns the warning line, or null.
+ */
+export declare function cachedRouteSystemOnlyWarning(route: string, cache: boolean, candidates: readonly CandidateSpec[], systemTemplate: string, userTemplate: string | undefined): string | null;
+//# sourceMappingURL=prompt-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-loader.d.ts","sourceRoot":"","sources":["../../src/routes/prompt-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpD,eAAO,MAAM,wBAAwB,gFAAgF,CAAC;AAMtH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,qFAAqF;IACrF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACtD;AAkBD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,iBAAiB,CAiCvG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,EACd,UAAU,EAAE,SAAS,aAAa,EAAE,EACpC,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,CAYf"}

package/dist/routes/prompt-loader.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * The bundle's `prompt:` block at load — `prompt.system`, the per-call
+ * `prompt.user` (GitLab issue #5, R1), and `prompt.variables`.
+ *
+ * Carved out of routes/loader.ts (which sits at the 700-LOC cap, dev-rule P1):
+ * the `prompt.system` + `variables` handling is a PURE MOVE; `prompt.user` and
+ * the cache/system-only advisory are new.
+ *
+ * YAML forms accepted for `prompt:`:
+ *   prompt: { system: <path>, variables: [...] }                 → today (byte-identical)
+ *   prompt: { system: <path>, user: <path>, variables: [...] }   → system + per-call user turn
+ *   prompt: { user: <path>, variables: [...] }                   → user turn only (empty system)
+ *
+ * Both templates are files relative to the bundle (same rule as `schema:`);
+ * both render with the same variables, capability conditionals and `x-trust`
+ * removal. `prompt.user` must be a non-empty file — an empty user turn next to
+ * a cache handle would send the handle and nothing else, the exact trap R1
+ * closes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CACHE_PROMPT_DOCS_ANCHOR = void 0;
+exports.parsePromptBlock = parsePromptBlock;
+exports.cachedRouteSystemOnlyWarning = cachedRouteSystemOnlyWarning;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const screen_loader_1 = require("./screen-loader");
+exports.CACHE_PROMPT_DOCS_ANCHOR = "caching-lifecycle.md#a-cache-handle-changes-where-the-template-is-delivered";
+function isRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** Read a template file named by `prompt.<key>` relative to the bundle. Pushes
+ * a teaching problem and returns null when the key is not a path or the file is
+ * missing. */
+function readTemplateFile(raw, key, bundleDir, problems) {
+    if (typeof raw !== "string" || raw === "") {
+        problems.push(`prompt.${key} must be a relative path`);
+        return null;
+    }
+    const path = (0, node_path_1.resolve)(bundleDir, raw);
+    if (!(0, node_fs_1.existsSync)(path)) {
+        problems.push(`prompt.${key} file not found: ${raw}`);
+        return null;
+    }
+    return (0, node_fs_1.readFileSync)(path, "utf8");
+}
+/**
+ * Parse the bundle's `prompt:` block. `prompt.system` stays REQUIRED unless
+ * `prompt.user` is declared (a user-turn-only route has an empty system
+ * template — the shape a Gemini cache handle wants, since the cache already
+ * holds the system content). Returns `systemTemplate: ""` on any problem so the
+ * caller's later checks stay total; the collected problems fail the load.
+ */
+function parsePromptBlock(raw, bundleDir, problems) {
+    if (!isRecord(raw)) {
+        problems.push("prompt.system must be a relative path");
+        return { systemTemplate: "", variables: [] };
+    }
+    const userDeclared = raw.user !== undefined && raw.user !== null;
+    let systemTemplate = "";
+    if (raw.system !== undefined && raw.system !== null) {
+        systemTemplate = readTemplateFile(raw.system, "system", bundleDir, problems) ?? "";
+    }
+    else if (!userDeclared) {
+        problems.push("prompt.system must be a relative path");
+    }
+    let userTemplate;
+    if (userDeclared) {
+        const text = readTemplateFile(raw.user, "user", bundleDir, problems);
+        if (text !== null) {
+            if (text.trim() === "") {
+                problems.push(`prompt.user file is empty: ${String(raw.user)} — the user turn must carry content (with a cache handle ` +
+                    `it is the ONLY per-call content the model sees; omit prompt.user to keep the fixed trigger)`);
+            }
+            else {
+                userTemplate = text;
+            }
+        }
+    }
+    const parsed = (0, screen_loader_1.parseVariables)(raw.variables ?? [], problems);
+    return {
+        systemTemplate,
+        ...(userTemplate !== undefined ? { userTemplate } : {}),
+        variables: parsed.names,
+        ...(parsed.trust !== undefined ? { variableTrust: parsed.trust } : {}),
+    };
+}
+/**
+ * Issue #5 (R1) advisory, P4 "errors teach": a route that opts into caching
+ * (`cache: auto`) AND has a Gemini candidate AND renders a non-empty system
+ * template with NO `prompt.user` is the shape that loses content the moment a
+ * customer passes a Gemini cache handle on `rig.run` — the handle forbids
+ * `systemInstruction`, so the rendered template is delivered as the user turn
+ * (never dropped), but the author almost certainly meant the cache to hold the
+ * prefix and `prompt.user` to hold the delta. Warn once at load naming the
+ * rule. Non-fatal: the route loads and serves as declared. Pure — unit-tested
+ * directly. Returns the warning line, or null.
+ */
+function cachedRouteSystemOnlyWarning(route, cache, candidates, systemTemplate, userTemplate) {
+    if (!cache)
+        return null;
+    if (userTemplate !== undefined)
+        return null;
+    if (systemTemplate.trim() === "")
+        return null;
+    if (!candidates.some((c) => c.provider === "gemini"))
+        return null;
+    return (`route "${route}" declares cache: with a Gemini candidate, a non-empty prompt.system and no prompt.user. ` +
+        `A Gemini cache handle (rig.run(..., { cache: { key, provider: "gemini" } })) forbids systemInstruction, so ` +
+        `on a cached dispatch the rendered system template is delivered AS THE USER TURN (prompt_delivery: ` +
+        `"user+cache") — never dropped, but probably not what you meant. Put the shared prefix in the cache ` +
+        `resource and the per-call delta in a \`prompt.user\` template (see ${exports.CACHE_PROMPT_DOCS_ANCHOR}).`);
+}

package/dist/routes/resolved-bundle.d.ts

@@ -27,6 +27,7 @@
 import type { LoadedRoutes } from "./loader";
 import type { ScreenPolicy } from "../screen/types";
 import type { ResolvedMaskPolicy } from "../mask/types";
+import type { Manifest } from "../prompts/manifest";
 import type { CandidateSpec, Preference, RepairPolicy, Requirement, RouteBundle, RoutePolicy, RouteVariant } from "../types/route";
 /**
  * The canonical, JSON-serialisable form of a resolved route bundle. Every field
@@ -39,11 +40,22 @@ export interface ResolvedRouteBundle {
     readonly version: number;
     /** Resolved, parsed JSON Schema (null = unstructured route). Inlined at sync. */
     readonly outputSchema: object | null;
+    /** Issue #1 — `output: text`. Carried ONLY as `"text"` (a json route omits the
+     * key, so its `bundle_sha` is unchanged); the hosted/mirror lane rebuilds the
+     * same prose contract and never JSON-parses the response. `outputMinChars` is
+     * the declared floor, text routes only. Absent ⇒ json ⇒ byte-identical. */
+    readonly outputKind?: "text";
+    readonly outputMinChars?: number;
     readonly candidates: readonly CandidateSpec[];
     readonly require: readonly Requirement[];
     readonly prefer: readonly Preference[];
     /** Raw template text — the prompt FILE, inlined at sync. */
     readonly systemTemplate: string;
+    /** Issue #5 (R1) — the per-call `prompt.user` template, inlined at sync and
+     * carried ONLY when declared (absent ⇒ the fixed trigger ⇒ unchanged
+     * `bundle_sha`), so the hosted/mirror lane renders the same user turn and a
+     * cache handle composes there too. */
+    readonly userTemplate?: string;
     readonly variables: readonly string[];
     readonly policy: RoutePolicy;
     readonly repair?: RepairPolicy;
@@ -81,6 +93,13 @@ export interface ResolvedRouteBundle {
      * always re-resolves on the mirror and needs no export refusal. Absent ⇒ no
      * masking (byte-identical). */
     readonly mask?: ResolvedMaskPolicy;
+    /** PSR-2 (spec §2.1/§3) — the served prompt's assembly manifest (structure-only).
+     * A promote writes the promoted `prompt_versions` row's `manifest` through into
+     * `routes.bundle` alongside the `systemTemplate`, and recomputes `bundle_sha`
+     * over this whole object — so the served projection carries the manifest the
+     * client-fill engine (PSR-2b) resolves against. Absent ⇒ no PSR manifest
+     * (byte-identical to a pre-PSR mirror). Additive & optional. */
+    readonly manifest?: Manifest;
 }
 /** Project an already-loaded (resolved) bundle to its serialisable form. Pure —
  * no filesystem; the loader already followed every file reference. */

package/dist/routes/resolved-bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolved-bundle.d.ts","sourceRoot":"","sources":["../../src/routes/resolved-bundle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EACV,YAAY,EACZ,WAAW,EACX,WAAW,EACX,WAAW,EACX,YAAY,EACb,MAAM,gBAAgB,CAAC;AAExB;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;IACvC,4DAA4D;IAC5D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;iFAC6E;IAC7E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC;IACpD;;;;2BAIuB;IACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAC/D;;;;;;;;;;;mBAWe;IACf,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IACrC;;;;;;;mCAO+B;IAC/B,QAAQ,CAAC,IAAI,CAAC,EAAE,kBAAkB,CAAC;CACpC;AAED;sEACsE;AACtE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,mBAAmB,CAuB3E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAe1D;AAiBD,mEAAmE;AACnE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAEvE;AAED;gFACgF;AAChF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAEtE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,CAkD5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,CAclE"}
+{"version":3,"file":"resolved-bundle.d.ts","sourceRoot":"","sources":["../../src/routes/resolved-bundle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EACV,YAAY,EACZ,WAAW,EACX,WAAW,EACX,WAAW,EACX,YAAY,EACb,MAAM,gBAAgB,CAAC;AAExB;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC;;;+EAG2E;IAC3E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;IACvC,4DAA4D;IAC5D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;;0CAGsC;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;iFAC6E;IAC7E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC;IACpD;;;;2BAIuB;IACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAC/D;;;;;;;;;;;mBAWe;IACf,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IACrC;;;;;;;mCAO+B;IAC/B,QAAQ,CAAC,IAAI,CAAC,EAAE,kBAAkB,CAAC;IACnC;;;;;oEAKgE;IAChE,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CAC9B;AAED;sEACsE;AACtE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,mBAAmB,CA8B3E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAe1D;AAiBD,mEAAmE;AACnE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAEvE;AAED;gFACgF;AAChF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAEtE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,CAoE5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,CAclE"}

package/dist/routes/resolved-bundle.js

@@ -43,10 +43,14 @@ 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 } : {}),
@@ -60,6 +64,9 @@ function resolveRouteBundle(bundle) {
         // 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 } : {}),
     };
 }
 /**
@@ -145,14 +152,28 @@ 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 } : {}),
@@ -171,6 +192,9 @@ function bundleFromResolved(raw) {
         // 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

@@ -35,7 +35,7 @@ export declare function parseClassificationAndPhiGate(raw: unknown, ctx: {
 /** 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;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,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"}