@warble/claude-agent-sdk 0.11.0 → 0.12.0

package/dist/{chunk-3ON7TSGW.js → chunk-7XQ5F6FM.js}

@@ -519,7 +519,33 @@ function parseComponent(value, at) {
     context_precondition: preconditionArray(obj, "context_precondition", at),
     params: paramArray(obj, "params", at),
     eval: obj["eval"] === void 0 || obj["eval"] === null ? null : parseEvalSpec(obj["eval"], `${at}.eval`),
-    brief: optStringU(obj, "brief")
+    brief: optStringU(obj, "brief"),
+    ...slotsField(obj, at)
+  };
+}
+function slotsField(obj, at) {
+  if (obj["slots"] === void 0) return {};
+  const slots = requireArray(obj, "slots", at).map((v, i) => parseSlot(v, `${at}.slots[${i}]`));
+  return { slots };
+}
+function parseSlot(value, at) {
+  const obj = requireObject(value, at);
+  const variantsRaw = requireObject(obj["variants"], `${at}.variants`);
+  const variants = {};
+  for (const [key, text] of Object.entries(variantsRaw)) {
+    if (typeof text !== "string") fail(`${at}.variants.${key} must be a string`);
+    variants[key] = text;
+  }
+  const name = requireString(obj, "name", at);
+  const dflt = requireString(obj, "default", at);
+  if (!(dflt in variants)) {
+    fail(`${at}.default is '${dflt}', which is not one of its variants (${Object.keys(variants).join(", ")})`);
+  }
+  return {
+    name,
+    default: dflt,
+    variants,
+    ...obj["present_when"] === void 0 ? {} : { present_when: obj["present_when"] }
   };
 }
 function parseIr(json2) {
@@ -544,7 +570,8 @@ function parseIr(json2) {
     config,
     components: requireArray(obj, "components", "<root>").map(
       (c, i) => parseComponent(c, `components[${i}]`)
-    )
+    ),
+    ...slotsField(obj, "<root>")
   };
 }
 function distinctTiers(calls) {
@@ -559,6 +586,124 @@ function distinctTiers(calls) {
   return out;
 }
 
+// src/slots.ts
+var SLOT_NAME = /^[a-z_][a-z0-9_]*$/;
+function slotReferences(raw) {
+  const found = [];
+  let cursor = 0;
+  for (; ; ) {
+    const open = raw.indexOf("{{", cursor);
+    if (open === -1) return found;
+    const bodyStart = open + 2;
+    const close = raw.indexOf("}}", bodyStart);
+    if (close === -1) return found;
+    const body = raw.slice(bodyStart, close).trim();
+    if (body.startsWith("slot.")) {
+      const name = body.slice("slot.".length);
+      if (SLOT_NAME.test(name)) found.push({ start: open, end: close + 2, name });
+    }
+    cursor = close + 2;
+  }
+}
+function resolveSlots(decls, supply, scope, unanswered = "fail") {
+  const byName = new Map(decls.map((d) => [d.name, d]));
+  const resolved = /* @__PURE__ */ new Map();
+  const visiting = /* @__PURE__ */ new Set();
+  const resolve3 = (name) => {
+    if (resolved.has(name)) return resolved.get(name);
+    if (visiting.has(name)) {
+      throw new DispatchError(
+        `slot '${name}' in ${scope} is defined in terms of itself: a variant's text references a slot whose own variant references it back (chain: ${[...visiting, name].join(" -> ")}).`
+      );
+    }
+    const decl = byName.get(name);
+    const choice = supply[name];
+    if (choice === null) {
+      resolved.set(name, null);
+      return null;
+    }
+    if (choice === void 0) {
+      if (decl.present_when !== void 0 && unanswered === "fail") {
+        throw new DispatchError(
+          `slot '${name}' in ${scope} declares a present_when condition, and nothing answered it. Supply the slot as a variant name to include it, or as null to remove it; falling back to the default would ship wording for something that may not be there.`
+        );
+      }
+    }
+    const key = choice ?? decl.default;
+    const text = decl.variants[key];
+    if (text === void 0) {
+      throw new DispatchError(
+        `slot '${name}' in ${scope} was given variant '${key}', which it does not declare (declared: ${Object.keys(decl.variants).join(", ")}).`
+      );
+    }
+    visiting.add(name);
+    const expanded = substitute(text, resolve3, byName, scope);
+    visiting.delete(name);
+    resolved.set(name, expanded);
+    return expanded;
+  };
+  for (const decl of decls) resolve3(decl.name);
+  return resolved;
+}
+function substitute(raw, resolve3, byName, scope) {
+  const refs = slotReferences(raw);
+  if (refs.length === 0) return raw;
+  let out = "";
+  let cursor = 0;
+  for (const ref of refs) {
+    if (!byName.has(ref.name)) {
+      throw new DispatchError(
+        `prompt text in ${scope} references slot '${ref.name}', which is neither one of the component's slots nor one of the profile's.`
+      );
+    }
+    out += raw.slice(cursor, ref.start) + (resolve3(ref.name) ?? "");
+    cursor = ref.end;
+  }
+  return out + raw.slice(cursor);
+}
+function applySlots(raw, resolved, scope) {
+  const refs = slotReferences(raw);
+  if (refs.length === 0) return raw;
+  let out = "";
+  let cursor = 0;
+  for (const ref of refs) {
+    if (!resolved.has(ref.name)) {
+      throw new DispatchError(
+        `prompt text in ${scope} references slot '${ref.name}', which is not declared there.`
+      );
+    }
+    out += raw.slice(cursor, ref.start) + (resolved.get(ref.name) ?? "");
+    cursor = ref.end;
+  }
+  return out + raw.slice(cursor);
+}
+function assertNoSlotReferences(raw, owner) {
+  const refs = slotReferences(raw);
+  if (refs.length > 0) {
+    const names = [...new Set(refs.map((r) => r.name))].join(", ");
+    throw new DispatchError(
+      `${owner} still contains unresolved slot reference(s) (${names}) at dispatch. Prompt text must go through slot resolution before it is sent; shipping the placeholder would put literal '{{ slot.\u2026 }}' in front of the model.`
+    );
+  }
+}
+function parseSlotFlags(flags) {
+  const supply = {};
+  for (const flag of flags) {
+    const at = flag.indexOf("=");
+    if (at === -1) {
+      throw new DispatchError(
+        `--slot '${flag}' must be NAME=VARIANT, or NAME= to remove a conditional slot`
+      );
+    }
+    const name = flag.slice(0, at);
+    const variant = flag.slice(at + 1);
+    if (name === "") throw new DispatchError(`--slot '${flag}' has an empty slot name`);
+    if (name in supply) throw new DispatchError(`--slot ${name} was given more than once`);
+    supply[name] = variant === "" ? null : variant;
+  }
+  return supply;
+}
+
 // src/models.ts
 import { parse as parseYaml } from "yaml";
 var STRONG_TIER = "strong";
@@ -766,14 +911,14 @@ function planProviderRouting(node, models, anthropicSplit) {
   }
   return { mode, steps, providers };
 }
-function buildStepMessages(step, question, slots) {
+function buildStepMessages(step, question, artifacts) {
   const parts = [`Question: ${question}`];
-  for (const slot of step.consumes) {
-    const value = slots[slot];
+  for (const artifact of step.consumes) {
+    const value = artifacts[artifact];
     parts.push(
       value === void 0 ? `
-[input '${slot}' was not produced by an earlier step]` : `
-Input '${slot}':
+[input '${artifact}' was not produced by an earlier step]` : `
+Input '${artifact}':
 ${value}`
     );
   }
@@ -1193,9 +1338,9 @@ function buildDriverBody(node) {
       `Run the \`${subagentName(node.verb, call.name)}\` subagent (step \`${call.name}\`) via the Task tool.`
     ];
     if (call.consumes.length > 0) {
-      const sources = call.consumes.map((slot) => {
-        const producer = producers.get(slot);
-        return producer ? `\`${slot}\` (the \`${producer}\` subagent's output)` : `\`${slot}\``;
+      const sources = call.consumes.map((artifact) => {
+        const producer = producers.get(artifact);
+        return producer ? `\`${artifact}\` (the \`${producer}\` subagent's output)` : `\`${artifact}\``;
       }).join(", ");
       parts.push(`Pass it ${sources} as input.`);
     }
@@ -1239,6 +1384,23 @@ function tierCollapseNote(node, model) {
   return `per-step tiers [${steps}] collapsed to single model '${model}'`;
 }
 function buildDispatchPlan(node, report, cfg) {
+  const plan = buildDispatchPlanUnchecked(node, report, cfg);
+  assertPlanHasNoSlotReferences(plan, node.id);
+  return plan;
+}
+function assertPlanHasNoSlotReferences(plan, componentId) {
+  const system = plan.options.systemPrompt;
+  if (typeof system === "string") {
+    assertNoSlotReferences(system, `the system prompt of component '${componentId}'`);
+  }
+  for (const [name, agent] of Object.entries(plan.options.agents ?? {})) {
+    assertNoSlotReferences(agent.prompt, `subagent '${name}' of component '${componentId}'`);
+  }
+  for (const step of plan.meta.stagedSteps) {
+    assertNoSlotReferences(step.prompt, `staged step '${step.name}' of component '${componentId}'`);
+  }
+}
+function buildDispatchPlanUnchecked(node, report, cfg) {
   if (!realizationSupported(node)) {
     throw unsupported("realization_kind", node.realization_kind);
   }
@@ -1524,11 +1686,59 @@ function inspectNodeCapabilities(node, targetId) {
   return inspectCapabilities(node, targetId, localProfile());
 }
 
+// src/fingerprint.ts
+import { createHash } from "crypto";
+var ALGORITHM = "sha256";
+function sha256(text) {
+  return createHash(ALGORITHM).update(text, "utf8").digest("hex");
+}
+function fingerprintSurfaces(surfaces) {
+  const perSurface = {};
+  const parts = [];
+  for (const name of Object.keys(surfaces).sort()) {
+    const text = surfaces[name];
+    perSurface[name] = sha256(text);
+    parts.push(`${name.length}:${name} ${text.length}:${text}`);
+  }
+  return { algorithm: ALGORITHM, digest: sha256(parts.join(" ")), surfaces: perSurface };
+}
+function promptSurfacesOf(options) {
+  const surfaces = {};
+  const system = options.systemPrompt;
+  if (typeof system === "string") surfaces["driver.systemPrompt"] = system;
+  for (const [name, agent] of Object.entries(options.agents ?? {})) {
+    surfaces[`subagent.${name}`] = agent.prompt;
+  }
+  return surfaces;
+}
+function promptSurfacesOfMessages(messages) {
+  return Object.fromEntries(
+    messages.map((message, index) => [`local.${index}.${message.role}`, message.content])
+  );
+}
+function promptSurfaces(plan) {
+  return promptSurfacesOf(plan.options);
+}
+function fingerprintPrompts(plan) {
+  return fingerprintSurfaces(promptSurfaces(plan));
+}
+
 // src/guardrails.ts
 import { resolve as resolvePath, sep as pathSep } from "path";
 function withinScope(abs, scopeAbs) {
   return abs === scopeAbs || abs.startsWith(scopeAbs.endsWith(pathSep) ? scopeAbs : scopeAbs + pathSep);
 }
+function composeCanUseTool(embedder, floor) {
+  if (embedder === void 0) return floor;
+  return async (toolName, input, options) => {
+    const fromEmbedder = await embedder(toolName, input, options);
+    if (fromEmbedder.behavior !== "allow") return fromEmbedder;
+    return floor(toolName, fromEmbedder.updatedInput, options);
+  };
+}
+function composeHooks(embedder, guardHooks) {
+  return { ...embedder, PreToolUse: [...embedder?.PreToolUse ?? [], ...guardHooks] };
+}
 var DESTRUCTIVE = /\b(rm|sudo|dd|mkfs|shutdown|reboot|kill|chmod|chown|mv|cp)\b/;
 var REDIRECTION = /(^|[^>])>>?[^>]/;
 var DOTENV_READER_COMMANDS = /\b(cat|head|tail|less|more|od|xxd|strings|grep|awk|sed)\b/;
@@ -1728,9 +1938,9 @@ function buildToolDriverPrompt(steps) {
   const lines = steps.map((s, i) => {
     const parts = [`${i + 1}. Call the \`dispatch_step\` tool with step="${s.name}".`];
     if (s.consumes.length > 0) {
-      const srcs = s.consumes.map((slot) => {
-        const p = producers.get(slot);
-        return p ? `the text step "${p}" returned` : `"${slot}"`;
+      const srcs = s.consumes.map((artifact) => {
+        const p = producers.get(artifact);
+        return p ? `the text step "${p}" returned` : `"${artifact}"`;
       }).join(", ");
       parts.push(`Pass ${srcs} as the tool's \`inputs\` argument.`);
     }
@@ -1748,6 +1958,9 @@ function buildToolDriverPrompt(steps) {
     "Marshal each step's returned text into the next step's `inputs` exactly as noted above. Your FINAL message MUST be the last executed step's returned text verbatim \u2014 do not summarize it or add commentary."
   ].join("\n");
 }
+var MCP_SERVER_NAME = "warble";
+var DISPATCH_STEP_NAME = "dispatch_step";
+var DISPATCH_STEP_TOOL = `mcp__${MCP_SERVER_NAME}__${DISPATCH_STEP_NAME}`;
 async function runCloudStep(step, question, inputsText, ctx) {
   const options = {
     cwd: ctx.cwd,
@@ -1763,9 +1976,10 @@ ${step.prompt}`,
     canUseTool: ctx.canUseTool,
     // Read never reaches `canUseTool` for an in-cwd path in the real SDK (see guardrails.ts); this
     // hook is the live enforcement point for the +Setup dotenv-read gap's Read side.
-    hooks: { PreToolUse: ctx.hooks },
+    hooks: ctx.hooks,
     env: ctx.env
   };
+  ctx.cfg.onPromptFingerprint?.(fingerprintSurfaces(promptSurfacesOf(options)));
   const msgs = [];
   for await (const m of query({ prompt: stepUserPrompt(question, inputsText), options })) msgs.push(m);
   return requireFinalText(msgs.find(isResult));
@@ -1782,12 +1996,15 @@ async function runHybridTool(plan, cfg) {
   const venvBin = join(cwd, ".venv", "bin");
   const pathEnv = existsSync(venvBin) ? `${venvBin}:${process.env.PATH ?? ""}` : process.env.PATH ?? "";
   const env = { ...process.env, PATH: pathEnv };
+  const stepCanUseTool = composeCanUseTool(plan.options.canUseTool, canUseTool);
+  const stepHooks = composeHooks(plan.options.hooks, hooks);
+  const driverCanUseTool = async (toolName, input, options) => toolName === DISPATCH_STEP_TOOL ? { behavior: "allow", updatedInput: input } : stepCanUseTool(toolName, input, options);
   const steps = plan.meta.stagedSteps;
   const question = plan.prompt;
   const maxTurns = plan.options.maxTurns ?? 40;
   const traceSteps = [];
   const dispatchStep = tool(
-    "dispatch_step",
+    DISPATCH_STEP_NAME,
     "Execute one named step of the task on its own configured model and return its text output.",
     { step: z.string(), inputs: z.string().optional() },
     async (args) => {
@@ -1799,18 +2016,20 @@ async function runHybridTool(plan, cfg) {
       let text;
       if (step.provider === "openai_compat") {
         if (!step.endpoint) throw new DispatchError(`local step '${step.name}' has no endpoint`);
+        const localMessages = [
+          { role: "system", content: step.prompt },
+          { role: "user", content: stepUserPrompt(question, inputsText) }
+        ];
+        cfg.onPromptFingerprint?.(fingerprintSurfaces(promptSurfacesOfMessages(localMessages)));
         text = await callOpenAiCompat({
           endpoint: step.endpoint,
           model: step.model,
-          messages: [
-            { role: "system", content: step.prompt },
-            { role: "user", content: stepUserPrompt(question, inputsText) }
-          ]
+          messages: localMessages
         });
         process.stderr.write(`warble hybrid-tool: step '${step.name}' \u2192 local ${step.model}
 `);
       } else {
-        text = await runCloudStep(step, question, inputsText, { cwd, env, maxTurns, canUseTool, hooks });
+        text = await runCloudStep(step, question, inputsText, { cfg, cwd, env, maxTurns, canUseTool: stepCanUseTool, hooks: stepHooks });
         process.stderr.write(`warble hybrid-tool: step '${step.name}' \u2192 cloud ${step.model}
 `);
       }
@@ -1818,7 +2037,7 @@ async function runHybridTool(plan, cfg) {
       return { content: [{ type: "text", text }] };
     }
   );
-  const server = createSdkMcpServer({ name: "warble", version: "0.0.0", tools: [dispatchStep] });
+  const server = createSdkMcpServer({ name: MCP_SERVER_NAME, version: "0.0.0", tools: [dispatchStep] });
   const driverModel = plan.options.model ?? "sonnet";
   const driverOptions = {
     cwd,
@@ -1827,9 +2046,22 @@ async function runHybridTool(plan, cfg) {
     model: driverModel,
     systemPrompt: buildToolDriverPrompt(steps),
     mcpServers: { warble: server },
-    allowedTools: ["mcp__warble__dispatch_step"],
-    env
+    allowedTools: [DISPATCH_STEP_TOOL],
+    env,
+    // The floor is composed in here too, even though the driver prompt asks this turn to do nothing
+    // but call `dispatch_step`. `allowedTools` does not restrict the toolset — the SDK documents it
+    // as "auto-allowed without prompting" and says to use `tools` to restrict — and `tools` is not
+    // set here, so the default built-in set (Bash, Write, Edit, …) is on the table for this turn.
+    // Composing the floor is therefore the difference between the prompt asking the model not to
+    // reach for them and something actually stopping it.
+    //
+    // This tightens behaviour rather than preserving it: before, no `canUseTool` reached this turn
+    // at all. That is the intended direction — a guardrail floor applying where it previously did
+    // not — and it is why this is not spread conditionally like an embedder-only passthrough.
+    canUseTool: driverCanUseTool,
+    hooks: stepHooks
   };
+  cfg.onPromptFingerprint?.(fingerprintSurfaces(promptSurfacesOf(driverOptions)));
   const msgs = [];
   for await (const m of query({ prompt: question, options: driverOptions })) msgs.push(m);
   const result = msgs.find(isResult);
@@ -1905,10 +2137,10 @@ function tryParseJson(text) {
     return void 0;
   }
 }
-function readFlag(slots, target) {
-  const [slotName, ...path] = target.split(".");
-  if (slotName === void 0) return false;
-  const raw = slots[slotName];
+function readFlag(artifacts, target) {
+  const [artifactName, ...path] = target.split(".");
+  if (artifactName === void 0) return false;
+  const raw = artifacts[artifactName];
   if (raw === void 0) return false;
   let cur = tryParseJson(raw);
   for (const key of path) {
@@ -1922,9 +2154,9 @@ function evaluateGuard(when, state) {
     case "on_failure":
       return state.outcomes[when.target] === "failure";
     case "on_flag":
-      return readFlag(state.slots, when.target);
+      return readFlag(state.artifacts, when.target);
     case "on_missing":
-      return state.slots[when.target] === void 0;
+      return state.artifacts[when.target] === void 0;
     default:
       throw new DispatchError(
         `unknown guard '${when.guard}' (closed vocabulary: on_failure, on_flag, on_missing)`
@@ -2124,13 +2356,14 @@ async function runDispatch(plan, cfg) {
   const env = { ...process.env, PATH: pathEnv };
   const options = {
     ...plan.options,
-    canUseTool,
+    canUseTool: composeCanUseTool(plan.options.canUseTool, canUseTool),
     // Read never reaches `canUseTool` for an in-cwd path in the real SDK (see guardrails.ts); this
     // hook is the live enforcement point for the +Setup dotenv-read gap's Read side.
-    hooks: { ...plan.options.hooks, PreToolUse: [...plan.options.hooks?.PreToolUse ?? [], ...hooks] },
+    hooks: composeHooks(plan.options.hooks, hooks),
     env,
     ...cfg.resume ? { resume: cfg.resume } : {}
   };
+  reportPromptFingerprint(cfg, options);
   const mapper = new ChatEventMapper(plan.meta.verb);
   const messages = [];
   for await (const message of query2({ prompt: plan.prompt, options })) {
@@ -2170,15 +2403,19 @@ function hybridCloudPreamble(cwd) {
     "All data access MUST go through the `wren` CLI \u2014 never raw SQL clients."
   ].join("\n");
 }
-function slotKey(step) {
+function reportPromptFingerprint(cfg, options) {
+  cfg.onPromptFingerprint?.(fingerprintSurfaces(promptSurfacesOf(options)));
+}
+function artifactKey(step) {
   return step.produces ?? step.name;
 }
-async function executeStep(step, slots, ctx, tolerant) {
-  const messages = buildStepMessages(step, ctx.plan.prompt, slots);
+async function executeStep(step, artifacts, ctx, tolerant) {
+  const messages = buildStepMessages(step, ctx.plan.prompt, artifacts);
   const userPrompt = messages.find((m) => m.role === "user")?.content ?? ctx.plan.prompt;
   try {
     if (step.provider === "openai_compat") {
       if (!step.endpoint) throw new DispatchError(`local step '${step.name}' has no endpoint`);
+      ctx.cfg.onPromptFingerprint?.(fingerprintSurfaces(promptSurfacesOfMessages(messages)));
       const text2 = await callOpenAiCompat({ endpoint: step.endpoint, model: step.model, messages });
       ctx.steps.push({ model: `openai_compat:${step.model}`, parent_tool_use_id: step.name, usage: null });
       process.stderr.write(`warble hybrid: step '${step.name}' \u2192 local ${step.model}
@@ -2199,9 +2436,10 @@ ${step.prompt}`,
       canUseTool: ctx.canUseTool,
       // Read never reaches `canUseTool` for an in-cwd path in the real SDK (see guardrails.ts); this
       // hook is the live enforcement point for the +Setup dotenv-read gap's Read side.
-      hooks: { PreToolUse: ctx.hooks },
+      hooks: ctx.hooks,
       env: ctx.env
     };
+    reportPromptFingerprint(ctx.cfg, stepOptions);
     const msgs = [];
     for await (const message of query2({ prompt: userPrompt, options: stepOptions })) {
       msgs.push(message);
@@ -2237,16 +2475,17 @@ async function runHybridStaged(plan, cfg) {
   const venvBin = join3(cwd, ".venv", "bin");
   const pathEnv = existsSync2(venvBin) ? `${venvBin}:${process.env.PATH ?? ""}` : process.env.PATH ?? "";
   const env = { ...process.env, PATH: pathEnv };
-  const slots = {};
+  const artifacts = {};
   const outcomes = {};
   const steps = [];
   let finalText = "";
   let totalCost = 0;
   const startedAll = Date.now();
   const execCtx = {
+    cfg,
     cwd,
-    canUseTool,
-    hooks,
+    canUseTool: composeCanUseTool(plan.options.canUseTool, canUseTool),
+    hooks: composeHooks(plan.options.hooks, hooks),
     env,
     plan,
     steps,
@@ -2270,7 +2509,7 @@ async function runHybridStaged(plan, cfg) {
       const preceding = i > 0 ? stagedSteps[i - 1] : null;
       const precedingIdentity = preceding === null ? null : { name: preceding.name, produces: preceding.produces };
       const decision = classifyConditionalStep(step.when, step.consumes, precedingIdentity, {
-        slots,
+        artifacts,
         outcomes
       });
       if (decision.kind === "skip") {
@@ -2279,11 +2518,11 @@ async function runHybridStaged(plan, cfg) {
         continue;
       }
       if (decision.kind === "repair") {
-        let lastFailureText = slots[decision.target.produces ?? decision.target.name] ?? "";
+        let lastFailureText = artifacts[decision.target.produces ?? decision.target.name] ?? "";
         const { recovered, attempts } = await runRepairLoop(DEFAULT_MAX_REPAIR_ATTEMPTS, async () => {
-          const attempt = await executeStep(step, slots, execCtx, true);
+          const attempt = await executeStep(step, artifacts, execCtx, true);
           outcomes[step.name] = attempt.outcome;
-          slots[slotKey(step)] = attempt.text;
+          artifacts[artifactKey(step)] = attempt.text;
           if (attempt.outcome === "success") finalText = attempt.text;
           else lastFailureText = attempt.text;
           return { failed: attempt.outcome === "failure" };
@@ -2300,9 +2539,9 @@ async function runHybridStaged(plan, cfg) {
         continue;
       }
     }
-    const outcome = await executeStep(step, slots, execCtx, failureGuardTargets.has(step.name));
+    const outcome = await executeStep(step, artifacts, execCtx, failureGuardTargets.has(step.name));
     outcomes[step.name] = outcome.outcome;
-    slots[slotKey(step)] = outcome.text;
+    artifacts[artifactKey(step)] = outcome.text;
     if (outcome.outcome === "success") finalText = outcome.text;
   }
   const trace = {
@@ -2363,24 +2602,52 @@ function prepareDispatch(input) {
     }
     scoped = [node];
   }
+  const supply = input.slots ?? {};
   const components = scoped.map((node) => {
-    const report = resolveNodeCapabilities(node, target);
-    return buildPreparedComponent(node, report, input, target, models);
+    const resolved = resolveSlotsForNode(node, ir, supply);
+    const withSlots = resolved === null ? node : applyNodeSlots(node, resolved);
+    const report = resolveNodeCapabilities(withSlots, target);
+    return buildPreparedComponent(withSlots, report, input, target, models);
   });
   return { target, components };
 }
+function resolveSlotsForNode(node, ir, supply, unanswered = "fail") {
+  const decls = [...ir.slots ?? [], ...node.slots ?? []];
+  if (decls.length === 0) return null;
+  return resolveSlots(decls, supply, `component '${node.id}'`, unanswered);
+}
+function applyNodeSlots(node, resolved) {
+  const scope = `component '${node.id}'`;
+  return {
+    ...node,
+    ...node.brief === void 0 ? {} : { brief: applySlots(node.brief, resolved, scope) },
+    prompt_fragment: applySlots(node.prompt_fragment, resolved, scope),
+    llm_calls: node.llm_calls.map((call) => ({
+      ...call,
+      prompt: applySlots(call.prompt, resolved, scope)
+    }))
+  };
+}
 function prepareDisplayManifest(input) {
   const ir = typeof input.ir === "string" ? parseIr(input.ir) : input.ir;
   assertSupportedIrVersion(ir.warble_ir_version);
   const target = input.target ?? DEFAULT_TARGET;
   const models = input.models ?? ModelConfig.default();
   models.validate(ir);
+  const supply = input.slots ?? {};
   const components = ir.components.map((node) => {
-    const report = inspectNodeCapabilities(node, target);
+    const resolved = resolveSlotsForNode(node, ir, supply, "default");
+    const withSlots = resolved === null ? node : applyNodeSlots(node, resolved);
+    const report = inspectNodeCapabilities(withSlots, target);
     if (report.some((entry2) => entry2.outcome === "fail")) {
-      return { id: node.id, node, availability: { status: "unavailable", reason: UNAVAILABLE_COMPONENT_REASON } };
+      return {
+        id: withSlots.id,
+        node: withSlots,
+        availability: { status: "unavailable", reason: UNAVAILABLE_COMPONENT_REASON }
+      };
     }
-    return buildPreparedComponent(node, report, input, target, models);
+    const prepared = buildPreparedComponent(withSlots, report, input, target, models);
+    return { id: prepared.id, node: prepared.node, report: prepared.report };
   });
   return { target, components };
 }
@@ -2790,6 +3057,10 @@ export {
   SUPPORTED_IR_VERSIONS,
   parseIr,
   distinctTiers,
+  resolveSlots,
+  applySlots,
+  assertNoSlotReferences,
+  parseSlotFlags,
   ModelConfig,
   resolveStagedSteps,
   distinctProviders,
@@ -2810,6 +3081,12 @@ export {
   resolveCapabilities,
   resolveNodeCapabilities,
   inspectNodeCapabilities,
+  fingerprintSurfaces,
+  promptSurfacesOf,
+  promptSurfaces,
+  fingerprintPrompts,
+  composeCanUseTool,
+  composeHooks,
   makeReadOnlyGuard,
   buildChatRequest,
   extractCompletionText,
@@ -2841,4 +3118,4 @@ export {
   ChatSession,
   createChatSession
 };
-//# sourceMappingURL=chunk-3ON7TSGW.js.map
+//# sourceMappingURL=chunk-7XQ5F6FM.js.map