@wrenai/genbi 0.0.3 → 0.0.5

package/dist/index.html

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/png" href="/wrenai_logo.png" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>GenBI</title>
-    <script type="module" crossorigin src="/assets/index-Bo--QMUN.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Xs4q7pNo.css">
+    <script type="module" crossorigin src="/assets/index-DsH129tV.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-A_Wrq7Ey.css">
   </head>
   <body>
     <div id="root"></div>

package/dist-server/harness/bundle/schema.d.ts

@@ -49,11 +49,18 @@ declare const capabilitySchema: z.ZodObject<{
 declare const outputSchemaSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 declare const agentSchema: z.ZodUnion<readonly [z.ZodObject<{
     id: z.ZodString;
+    entrypoint: z.ZodOptional<z.ZodBoolean>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        step: z.ZodString;
+        alias: z.ZodString;
+        component: z.ZodString;
+    }, z.core.$strict>>>;
     verb: z.ZodString;
     component_type: z.ZodString;
     realization_kind: z.ZodString;
     trigger: z.ZodString;
     outcome: z.ZodString;
+    brief: z.ZodOptional<z.ZodString>;
     steps: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         tier: z.ZodString;
@@ -92,6 +99,18 @@ declare const agentSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strict>, z.ZodObject<{
     id: z.ZodString;
+    entrypoint: z.ZodOptional<z.ZodBoolean>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        step: z.ZodString;
+        alias: z.ZodString;
+        component: z.ZodString;
+    }, z.core.$strict>>>;
+    capability_inspection: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        capability: z.ZodString;
+        outcome: z.ZodString;
+        provided_by: z.ZodString;
+        criticality: z.ZodString;
+    }, z.core.$strip>>>;
     verb: z.ZodString;
     component_type: z.ZodString;
     realization_kind: z.ZodString;
@@ -118,11 +137,18 @@ export declare const bundleSchema: z.ZodObject<{
     target: z.ZodString;
     agents: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         id: z.ZodString;
+        entrypoint: z.ZodOptional<z.ZodBoolean>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            step: z.ZodString;
+            alias: z.ZodString;
+            component: z.ZodString;
+        }, z.core.$strict>>>;
         verb: z.ZodString;
         component_type: z.ZodString;
         realization_kind: z.ZodString;
         trigger: z.ZodString;
         outcome: z.ZodString;
+        brief: z.ZodOptional<z.ZodString>;
         steps: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             tier: z.ZodString;
@@ -161,6 +187,18 @@ export declare const bundleSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strict>, z.ZodObject<{
         id: z.ZodString;
+        entrypoint: z.ZodOptional<z.ZodBoolean>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            step: z.ZodString;
+            alias: z.ZodString;
+            component: z.ZodString;
+        }, z.core.$strict>>>;
+        capability_inspection: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            capability: z.ZodString;
+            outcome: z.ZodString;
+            provided_by: z.ZodString;
+            criticality: z.ZodString;
+        }, z.core.$strip>>>;
         verb: z.ZodString;
         component_type: z.ZodString;
         realization_kind: z.ZodString;

package/dist-server/harness/bundle/schema.js

@@ -33,6 +33,7 @@ const capabilitySchema = z.object({
     provided_by: z.string(),
     criticality: z.string(),
 });
+const dependencySchema = z.object({ step: z.string(), alias: z.string(), component: z.string() }).strict();
 // output_schema is a nested JSON Schema document. The harness stores it as-is
 // and does not interpret it until a later milestone validates output against it.
 const outputSchemaSchema = z.record(z.string(), z.unknown());
@@ -40,31 +41,38 @@ const outputSchemaSchema = z.record(z.string(), z.unknown());
 // silently discard an `availability` marker: doing so would turn a redacted
 // unavailable declaration into an executable-looking component downstream.
 //
-// Strictness has a cost worth naming, because it has already been paid once.
-// IR 0.5 added an optional component-level `brief`, and no key for it is
-// declared below. Warble omits the field entirely while no profile sets one, so
-// nothing fails today — but the first time a profile author writes `brief:` on a
-// component, the next dispatch emits that key, `loadBundle` rejects the bundle,
-// and `GET /api/harness` starts returning 500 for a reason that has nothing to
-// do with the annotation someone just added. That is a deliberate deferral, not
-// an oversight: adding a key for a field nothing populates would be guessing at
-// its shape. Declare it here when a profile first needs it.
+// IR 0.5 added an optional component-level `brief`: free-form framing text a
+// profile author writes on a mounted component, shared across every one of
+// its steps (Warble's `docs/spec/authoring.md`, "brief — authored framing
+// shared across every step"). It is declared only on the available variant
+// below — an unavailable component (see `unavailableAgentSchema`) has no
+// executable steps for it to frame, so there is nothing for it to reach.
 const availableAgentSchema = z.object({
     id: z.string(),
+    entrypoint: z.boolean().optional(),
+    dependencies: z.array(dependencySchema).optional(),
     verb: z.string(),
     component_type: z.string(),
     realization_kind: z.string(),
     trigger: z.string(),
     outcome: z.string(),
+    brief: z.string().optional(),
     steps: z.array(stepSchema),
     guardrails: z.record(z.string(), guardrailSchema),
     tools: z.array(toolSchema),
     output_schema: outputSchemaSchema,
     capabilities: z.array(capabilitySchema),
 }).strict();
-/** Read-only manifest variant for a declared component this target cannot execute. */
+/**
+ * Read-only manifest variant for a declared component this target cannot
+ * execute. Carries no `brief`: this branch has no executable steps and no
+ * rendering path for framing text to reach.
+ */
 const unavailableAgentSchema = z.object({
     id: z.string(),
+    entrypoint: z.boolean().optional(),
+    dependencies: z.array(dependencySchema).optional(),
+    capability_inspection: z.array(capabilitySchema).optional(),
     verb: z.string(),
     component_type: z.string(),
     realization_kind: z.string(),

package/dist-server/harness/bundle/version.js

@@ -6,7 +6,7 @@ export class BundleCompatError extends Error {
     }
 }
 export const HARNESS_SUPPORT = {
-    irVersion: "0.6",
+    irVersion: "0.9",
     bundleVersions: ["0.1"],
 };
 function parseVersion(version) {

package/dist-server/harness/cli-args.d.ts

@@ -1,6 +1,7 @@
 import type { AuthChoice, LoginProbe } from "./auth/index.js";
 import type { Deployment } from "./compliance/index.js";
 import type { AdapterSpec } from "./providers/index.js";
+import { type Zone } from "./providers/index.js";
 import type { RouteResult } from "./route/types.js";
 /**
  * Parsed CLI flags after normalization. Kept separate from `node:util`'s
@@ -25,6 +26,10 @@ export interface CliFlags {
     readonly tierAdapters?: readonly string[];
     /** Hybrid mode, dispatched: `--models-config <path>`, forwarded verbatim to `warble-agent-sdk chat`. */
     readonly modelsConfig?: string;
+    /** Hybrid privacy split, in-process: `--tier-binding <path>`, a JSON tier binding document (tiers + disclosure_policy + roles). */
+    readonly tierBindingFile?: string;
+    /** In-process: `--zone-dry-run` prints the zone audit of the composed plan and exits without running a model. */
+    readonly zoneDryRun?: boolean;
     /** Dispatched only: `--chat-timeout-ms <n>`, overrides `spawnChat`'s default 10-minute hang guard. See `DispatchedOptions.chatTimeoutMs`. */
     readonly chatTimeoutMs?: number;
 }
@@ -91,13 +96,16 @@ export declare const EXIT_REFUSAL = 2;
 export declare function determineExitCode(result: RouteResult): number;
 /** api-key config from `--api-key`/`--model`; `undefined` when neither is set (so the adapter's own env lookup applies). */
 export declare function buildApiKeyConfig(flags: CliFlags): Record<string, unknown> | undefined;
-/** gateway config from `--endpoint`/`--model`/`--api-key`; `undefined` when none are set (so `deriveAdapterSpec` loud-fails). */
+/** gateway (pi-ai) config from `--provider`/`--model`/`--endpoint`/`--api-key`; `undefined` when none are set (so `deriveAdapterSpec` loud-fails). */
 export declare function buildGatewayConfig(flags: CliFlags): Record<string, unknown> | undefined;
 /** One parsed `--tier-adapter` entry, before it's turned into an `AdapterSpec`. */
 interface ParsedTierAdapterFlag {
+    /** A bare tier name or a mount-qualified `<mount>/<tier>` key. */
     readonly tier: string;
     readonly mode: string;
-    readonly fields: Pick<CliFlags, "adapter" | "apiKey" | "model" | "endpoint">;
+    readonly fields: Pick<CliFlags, "adapter" | "apiKey" | "model" | "endpoint" | "provider">;
+    /** The deployment zone declared for this tier, when the entry carries `zone=`. */
+    readonly zone?: Zone;
 }
 /**
  * Parses one hybrid-mode `--tier-adapter <tier>=<mode>[:<field>=<value>,...]`

package/dist-server/harness/cli-args.js

@@ -1,4 +1,5 @@
 import { detectAndPick } from "./auth/index.js";
+import { ZONES } from "./providers/index.js";
 import { deriveAdapterSpec } from "./route/adapter-spec.js";
 /** Thrown for user-facing CLI misuse (bad/missing flags), surfaced as a top-level `error:` line. */
 export class CliUsageError extends Error {
@@ -166,11 +167,13 @@ export function buildApiKeyConfig(flags) {
         config["model"] = flags.model;
     return Object.keys(config).length > 0 ? config : undefined;
 }
-/** gateway config from `--endpoint`/`--model`/`--api-key`; `undefined` when none are set (so `deriveAdapterSpec` loud-fails). */
+/** gateway (pi-ai) config from `--provider`/`--model`/`--endpoint`/`--api-key`; `undefined` when none are set (so `deriveAdapterSpec` loud-fails). */
 export function buildGatewayConfig(flags) {
     const config = {};
+    if (flags.provider !== undefined)
+        config["provider"] = flags.provider;
     if (flags.endpoint !== undefined)
-        config["baseURL"] = flags.endpoint;
+        config["baseUrl"] = flags.endpoint;
     if (flags.model !== undefined)
         config["model"] = flags.model;
     if (flags.apiKey !== undefined)
@@ -178,7 +181,7 @@ export function buildGatewayConfig(flags) {
     return Object.keys(config).length > 0 ? config : undefined;
 }
 const TIER_ADAPTER_ALLOWED_MODES = new Set(["api-key", "local", "gateway"]);
-const TIER_ADAPTER_ALLOWED_FIELDS = new Set(["adapter", "apiKey", "model", "endpoint"]);
+const TIER_ADAPTER_ALLOWED_FIELDS = new Set(["adapter", "apiKey", "model", "endpoint", "provider", "zone"]);
 /**
  * Parses one hybrid-mode `--tier-adapter <tier>=<mode>[:<field>=<value>,...]`
  * entry — e.g. `cheap=local:endpoint=http://localhost:11434/v1,model=llama3.1`
@@ -201,7 +204,11 @@ export function parseTierAdapterFlag(raw) {
         throw new CliUsageError(`--tier-adapter "${raw}": mode must be one of api-key|local|gateway (a hybrid tier has no ` +
             `subscription adapter of its own), got "${mode}"`);
     }
+    if (tier.startsWith("/") || tier.endsWith("/") || tier.split("/").length > 2) {
+        throw new CliUsageError(`--tier-adapter "${raw}": tier must be "<tier>" or "<mount>/<tier>", got "${tier}"`);
+    }
     const fields = {};
+    let zone;
     if (fieldsRaw.length > 0) {
         for (const pair of fieldsRaw.split(",")) {
             const pairEq = pair.indexOf("=");
@@ -210,12 +217,20 @@ export function parseTierAdapterFlag(raw) {
             }
             const key = pair.slice(0, pairEq);
             if (!TIER_ADAPTER_ALLOWED_FIELDS.has(key)) {
-                throw new CliUsageError(`--tier-adapter "${raw}": unknown field "${key}" (allowed: adapter, apiKey, model, endpoint)`);
+                throw new CliUsageError(`--tier-adapter "${raw}": unknown field "${key}" (allowed: adapter, apiKey, model, endpoint, provider, zone)`);
+            }
+            const value = pair.slice(pairEq + 1);
+            if (key === "zone") {
+                if (!ZONES.includes(value)) {
+                    throw new CliUsageError(`--tier-adapter "${raw}": zone must be one of ${ZONES.join("|")}, got "${value}"`);
+                }
+                zone = value;
+                continue;
             }
-            fields[key] = pair.slice(pairEq + 1);
+            fields[key] = value;
         }
     }
-    return { tier, mode, fields };
+    return { tier, mode, fields, ...(zone !== undefined ? { zone } : {}) };
 }
 /**
  * Builds the hybrid-mode per-tier `AdapterSpec` map from every `--tier-adapter`
@@ -231,13 +246,14 @@ export function parseTierAdapterFlag(raw) {
 export function buildTierBindingFromFlags(raw) {
     const tiers = {};
     for (const entry of raw) {
-        const { tier, mode, fields } = parseTierAdapterFlag(entry);
+        const { tier, mode, fields, zone } = parseTierAdapterFlag(entry);
         if (tier in tiers) {
             throw new CliUsageError(`--tier-adapter names tier "${tier}" more than once`);
         }
         try {
             const authChoice = buildExplicitAuthChoice(mode, fields); // `mode` was already restricted to api-key|local|gateway above, so this is never "subscription".
-            tiers[tier] = deriveAdapterSpec(authChoice, fields.model !== undefined ? { model: fields.model } : {});
+            const spec = deriveAdapterSpec(authChoice, fields.model !== undefined ? { model: fields.model } : {});
+            tiers[tier] = zone !== undefined ? { ...spec, zone } : spec;
         }
         catch (error) {
             throw new CliUsageError(`--tier-adapter "${entry}": ${error instanceof Error ? error.message : String(error)}`);

package/dist-server/harness/cli.js

@@ -1,20 +1,32 @@
 #!/usr/bin/env node
 import { parseArgs } from "node:util";
 import { createDefaultLoginProbe } from "./auth/index.js";
-import { buildTierBindingFromFlags, determineExitCode, parseChatTimeoutMs, resolveAuthChoice, resolveDeployment, validateRequiredInputs, } from "./cli-args.js";
+import { buildTierBindingFromFlags, CliUsageError, determineExitCode, parseChatTimeoutMs, resolveAuthChoice, resolveDeployment, validateRequiredInputs, } from "./cli-args.js";
 import { enforceCompliance } from "./compliance/index.js";
-import { resolveDefaultProfileSource, route } from "./route/index.js";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { generatePreparedContextAndCatalog, resolveContextLoader } from "./compile/context-loader.js";
+import { buildCapabilityCard } from "./components/capability-card.js";
+import { executionPlanFor } from "./components/display.js";
+import { defaultEntry } from "./components/in-process.js";
+import { describeZoneDryRun, formatZoneDryRun } from "./components/zone-dry-run.js";
+import { readTierBindingFile } from "./providers/index.js";
+import { describeBundle, resolveDefaultProfileSource, route } from "./route/index.js";
 const USAGE = `Usage: wren-harness <question> --project <dir> [options]
 
 Options:
   --project <dir>         User's wren project directory (required)
   --profile <dir>         Warble profile source directory (default: this package's profiles/genbi-default)
   --mode <mode>           subscription | api-key | local | gateway (default: see policy below)
-  --provider <name>       subscription mode: claude | codex (default: claude)
-  --adapter <name>        api-key mode: provider registry adapter id (e.g. anthropic)
-  --api-key <key>         api-key mode: API key (omit to rely on the adapter's own env var lookup)
-  --model <name>          api-key/local mode: model name
-  --endpoint <url>        local/gateway mode: endpoint URL
+  --provider <name>       subscription mode: claude | codex (default: claude);
+                          gateway mode: pi-ai provider id (e.g. openrouter, amazon-bedrock)
+  --adapter <name>        api-key mode: provider registry adapter id (e.g. openai, anthropic)
+  --api-key <key>         api-key mode: API key (omit to rely on the adapter's own env var lookup);
+                          gateway mode: key sent to the pi-ai provider (never read from its env vars)
+  --model <name>          api-key/local/gateway mode: model name
+  --endpoint <url>        local mode: endpoint URL; gateway mode: optional custom
+                          OpenAI-compatible base URL for the --provider name
   --warble-bin <path>     Explicit warble binary (default: the installed @warble/cli, then PATH)
   --agent-sdk-bin <path>  Explicit warble-agent-sdk CLI (subscription mode only)
   --out <dir>             subscription mode: run output directory
@@ -32,6 +44,17 @@ Options:
                           per-tier YAML config, forwarded verbatim as --models-config <path> to
                           "warble-agent-sdk chat". Known limitation: warble's render stage still
                           wall-hits on non-"render: none" components under a non-Anthropic tier.
+  --tier-binding <path>   Hybrid privacy split, in-process only: a JSON tier binding document
+                          {"tiers": {"<tier>"|"<mount>/<tier>": {"adapter","config","zone"}},
+                           "disclosure_policy": {...}, "roles": {"judge": "<key>", "render": "<key>"}}.
+                          Keys may be mount-qualified so a caller and callee sharing a tier name bind
+                          different models. Mutually exclusive with --tier-adapter. A zone on any entry
+                          (or a disclosure_policy / roles block) arms the zone gate, which rejects a
+                          public or unset zone on any callee or data-bearing step before any model runs.
+  --zone-dry-run          In-process only: compile the profile, print every step's component, tier,
+                          binding key, zone, adapter, model, endpoint host and thinking setting plus
+                          every alias call edge, run the zone gate and exit (0 ok, 1 gate violation).
+                          Starts no model, opens no network connection and needs no credentials.
   --chat-timeout-ms <n>   dispatched only (subscription): overrides the default 10-minute hang guard
                           on a "warble-agent-sdk chat" invocation. Raise this for a legitimately
                           slower cold-start turn (e.g. right after onboarding a project) rather
@@ -74,6 +97,8 @@ async function main() {
             deployment: { type: "string" },
             "tier-adapter": { type: "string", multiple: true },
             "models-config": { type: "string" },
+            "tier-binding": { type: "string" },
+            "zone-dry-run": { type: "boolean" },
             "chat-timeout-ms": { type: "string" },
             help: { type: "boolean" },
         },
@@ -103,6 +128,8 @@ async function main() {
         ...(values.deployment !== undefined ? { deployment: values.deployment } : {}),
         ...(values["tier-adapter"] !== undefined ? { tierAdapters: values["tier-adapter"] } : {}),
         ...(values["models-config"] !== undefined ? { modelsConfig: values["models-config"] } : {}),
+        ...(values["tier-binding"] !== undefined ? { tierBindingFile: values["tier-binding"] } : {}),
+        ...(values["zone-dry-run"] === true ? { zoneDryRun: true } : {}),
         ...(chatTimeoutMs !== undefined ? { chatTimeoutMs } : {}),
     };
     const question = positionals.join(" ");
@@ -123,7 +150,46 @@ async function main() {
     // Error, caught like any other error below) if the wrong one is supplied
     // for the resolved authChoice.mode, so no separate CLI-level guard is
     // duplicated here.
-    const tierBinding = flags.tierAdapters !== undefined ? buildTierBindingFromFlags(flags.tierAdapters) : undefined;
+    if (flags.tierAdapters !== undefined && flags.tierBindingFile !== undefined) {
+        throw new CliUsageError("--tier-adapter and --tier-binding are mutually exclusive; declare the binding in one place");
+    }
+    const fileBinding = flags.tierBindingFile !== undefined ? await readTierBindingFile(flags.tierBindingFile) : undefined;
+    const tierBinding = fileBinding?.tiers ?? (flags.tierAdapters !== undefined ? buildTierBindingFromFlags(flags.tierAdapters) : undefined);
+    const zoneOptions = {
+        ...(tierBinding !== undefined ? { tierBinding } : {}),
+        ...(fileBinding?.disclosurePolicy !== undefined ? { disclosurePolicy: fileBinding.disclosurePolicy } : {}),
+        ...(fileBinding?.roles !== undefined ? { zoneRoles: fileBinding.roles } : {}),
+    };
+    if (flags.zoneDryRun === true) {
+        if (authChoice.mode === "subscription") {
+            throw new CliUsageError("--zone-dry-run audits the in-process composed runtime; it does not apply to subscription mode");
+        }
+        const bundle = await describeBundle({ authChoice, profileSource, userProject: project,
+            ...(flags.warbleBin !== undefined ? { warbleBin: flags.warbleBin } : {}) });
+        if (bundle.vercel_bundle_version !== "0.2") {
+            throw new CliUsageError("--zone-dry-run needs a composed (vercel bundle 0.2) profile; this profile compiled to the legacy agent format");
+        }
+        const plan = executionPlanFor(bundle);
+        if (!plan)
+            throw new Error("Composed display has no trusted execution plan");
+        const binding = { tiers: tierBinding ?? {}, ...(fileBinding?.disclosurePolicy !== undefined ? { disclosurePolicy: fileBinding.disclosurePolicy } : {}),
+            ...(fileBinding?.roles !== undefined ? { roles: fileBinding.roles } : {}) };
+        // The card public-zone steps would receive: generated by code from the bound project, no model involved.
+        const scratch = await mkdtemp(path.join(os.tmpdir(), "genbi-zone-dry-run-"));
+        let card;
+        try {
+            const catalogPath = path.join(scratch, "catalog.json");
+            await generatePreparedContextAndCatalog(resolveContextLoader().bin, path.resolve(project), path.join(scratch, "context.json"), catalogPath);
+            card = buildCapabilityCard(JSON.parse(await readFile(catalogPath, "utf8")), binding.disclosurePolicy ? { disclosure: binding.disclosurePolicy } : {});
+        }
+        finally {
+            await rm(scratch, { recursive: true, force: true });
+        }
+        const dryRun = describeZoneDryRun(plan, defaultEntry(plan), binding, { card: { digest: card.digest, bytes: card.bytes, truncated: card.truncated } });
+        process.stdout.write(formatZoneDryRun(dryRun));
+        process.exitCode = dryRun.exitCode;
+        return;
+    }
     const result = await route({
         authChoice,
         profileSource,
@@ -134,7 +200,7 @@ async function main() {
         ...(flags.warbleBin !== undefined ? { warbleBin: flags.warbleBin } : {}),
         ...(flags.agentSdkBin !== undefined ? { agentSdkBin: flags.agentSdkBin } : {}),
         ...(flags.out !== undefined ? { outDir: flags.out } : {}),
-        ...(tierBinding !== undefined ? { tierBinding } : {}),
+        ...zoneOptions,
         ...(flags.modelsConfig !== undefined ? { modelsConfig: flags.modelsConfig } : {}),
         ...(flags.chatTimeoutMs !== undefined ? { chatTimeoutMs: flags.chatTimeoutMs } : {}),
     });

package/dist-server/harness/compile/cache.js

@@ -5,13 +5,13 @@ import os from "node:os";
 import path from "node:path";
 /**
  * Deterministic on-disk slot name for a cache key — order-independent, one directory per (profile,
- * context, mode, provider-fragment-hash, warble-identity, hub-dir). An absent `hubDir` (no
- * `--hub-dir` passed, so warble's compiled-in default applied) hashes as the empty string, which is
- * a distinct value from any real root rather than an alias for one.
+ * context, mode, provider-fragment-hash, warble-identity, context-loader-identity, hub-dir). An
+ * absent `hubDir` (no `--hub-dir` passed, so warble's compiled-in default applied) hashes as the
+ * empty string, which is a distinct value from any real root rather than an alias for one.
  */
 function keyDigest(key) {
     return createHash("sha256")
-        .update(`${key.profileHash}:${key.contextFingerprint}:${key.mode}:${key.providerFragmentHash}:${key.warbleIdentity}:${key.hubDir ?? ""}`)
+        .update(`${key.profileHash}:${key.contextFingerprint}:${key.mode}:${key.providerFragmentHash}:${key.warbleIdentity}:${key.contextLoaderIdentity}:${key.hubDir ?? ""}`)
         .digest("hex");
 }
 /**

package/dist-server/harness/compile/compose-profile.d.ts

@@ -1,31 +1,68 @@
 /**
- * Copies `profileSource` into `destDir`, then rewrites its context binding's `project:` field to
- * point at `userProject` (absolute path) instead of the profile's own fixture binding. Returns the
- * composed profile's directory (safe to pass straight to `warble compile`).
+ * Copies `profileSource` into `destDir` and rebinds its context to `userProject`, producing a
+ * composed profile directory that is safe to pass straight to `warble compile`.
+ *
+ * The profile's context binding is a **prepared** binding (`kind: prepared`): Warble does not read
+ * the user's semantic layer itself, it reads a JSON *document* that WrenAI's own generator
+ * (`wren-context-loader`) produces. So rebinding is two writes, not one:
+ *
+ * 1. Run the generator over `userProject` and write its document over the profile's committed
+ *    fixture document, at the path the binding's `document:` field already names.
+ * 2. Rewrite the binding's `project:` line to `userProject` (absolute).
+ *
+ * `project:` stays the layer's **identity** and never becomes the document path. That exact
+ * substitution shipped once in Warble and put the filename into every compiled prompt, telling the
+ * agent it was working on a project called `context.json`; Warble now guards against it, and this
+ * side must not hand it a binding that tries.
+ *
+ * Because the generated document is written *to the path the binding already declares*, `document:`
+ * needs no rewriting at all — the composed binding differs from the committed one only in
+ * `project:`. Note that `document:` (like `project:`) resolves relative to the **Warble project
+ * root** (the composed directory), not relative to the binding file that declares it.
  *
  * The binding file to rewrite is *not* hardcoded to `context/binding.yml` — it's read from the
  * copied `profile.yml`'s own `context: project: <path>` pointer (the documented Warble mechanism:
  * "profile mounts context via `context: project: <path-to-binding.yml>`"), so this works for any
- * profile following that shape, not just `genbi-default`. The resolved binding path is confined to
- * the composed directory: a `../`-laden pointer that escapes it is a loud {@link PathTraversalError}
- * (reusing the exec module's shared traversal error rather than reading/overwriting an arbitrary
- * host file).
+ * profile following that shape, not just `genbi-default`. Both the binding path and the resolved
+ * document path are confined to the composed directory: a `../`-laden pointer that escapes it is a
+ * loud {@link PathTraversalError} (reusing the exec module's shared traversal error rather than
+ * reading/overwriting an arbitrary host file).
  *
- * Both `profile.yml` and the binding file are small, flat YAML where only a single scalar matters
- * here — regex extraction/rewrite is used deliberately instead of pulling in a full YAML parser
- * dependency for that. Both the pointer lookup and the `project:` rewrite assert *exactly one*
- * match and loud-fail on zero or multiple (a duplicate top-level `project:` would otherwise leave a
- * stale line that last-key-wins YAML parsing could silently bind to the wrong project). If a Warble
- * profile ever grows a more elaborate `context:` block (e.g. multiple context sources), this needs
- * revisiting.
+ * Both `profile.yml` and the binding file are small, flat YAML where only a few scalars matter here
+ * — regex extraction/rewrite is used deliberately instead of pulling in a full YAML parser
+ * dependency for that. Every lookup asserts *exactly one* match and loud-fails on zero or multiple
+ * (a duplicate top-level `project:` would otherwise leave a stale line that last-key-wins YAML
+ * parsing could silently bind to the wrong project). If a Warble profile ever grows a more
+ * elaborate `context:` block (e.g. multiple context sources), this needs revisiting.
  */
 export declare function composeUserProfile(options: {
     readonly profileSource: string;
     readonly userProject: string;
     readonly destDir: string;
+    /**
+     * The resolved `wren-context-loader` binary (see `resolveContextLoaderBinary`). Required, not
+     * optional-with-a-default: there is no fallback path that skips the generator, and making the
+     * caller supply it keeps that structural rather than a comment.
+     */
+    readonly contextLoaderBin: string;
 }): Promise<string>;
 /** Extracts the single `context: project: <path>` pointer from a profile.yml's text. */
 export declare function extractContextBindingPath(profileYamlText: string, sourcePath: string): string;
+/**
+ * Asserts the binding declares exactly one top-level `kind: prepared`.
+ *
+ * A **missing** `kind:` is rejected rather than tolerated. Omitting it selects Warble's serde
+ * default (`wren_project`), i.e. Warble's own built-in MDL adapter — so a binding without the line
+ * would compile perfectly well while quietly ignoring the document this function's caller just
+ * generated. Since Warble emits neither `kind` nor `document` into the IR, that divergence is
+ * invisible in the compiled artifact; the only place it can be caught is here.
+ */
+export declare function assertPreparedBindingKind(bindingText: string, sourcePath: string): void;
+/**
+ * Extracts the single top-level `document: <path>` field naming where the prepared-context document
+ * lives, relative to the Warble project root (NOT to the binding file's own directory).
+ */
+export declare function extractBindingDocumentPath(bindingText: string, sourcePath: string): string;
 /**
  * Replaces the single top-level `project:` line in a context-binding YAML's text, preserving
  * surrounding comments. Asserts exactly one top-level `project:` — a second one would survive the