@tangle-network/agent-runtime 0.52.0 → 0.54.0

package/dist/{chunk-2OU7ZQPD.js → chunk-JTH2FPCK.js}

@@ -1,10 +1,18 @@
 import {
+  UI_LENSES
+} from "./chunk-WIR4HOOJ.js";
+import {
+  AgentEvalError,
   AnalystError,
+  NotFoundError,
   PlannerError,
   RuntimeRunStateError,
   ValidationError,
   extractLlmCallEvent
-} from "./chunk-GSUO5QS6.js";
+} from "./chunk-VLF5RHEQ.js";
+import {
+  buildLoopSpanNodes
+} from "./chunk-G3RGMA7C.js";
 
 // src/durable/spawn-journal.ts
 import { createHash } from "crypto";
@@ -206,8 +214,8 @@ var InMemorySpawnJournal = class {
   }
 };
 var FileSpawnJournal = class {
-  constructor(path) {
-    this.path = path;
+  constructor(path2) {
+    this.path = path2;
   }
   path;
   async loadTree(root) {
@@ -277,8 +285,8 @@ var FileSpawnJournal = class {
   }
   async appendRecord(record) {
     const fs = await import("fs/promises");
-    const path = await import("path");
-    await fs.mkdir(path.dirname(this.path), { recursive: true });
+    const path2 = await import("path");
+    await fs.mkdir(path2.dirname(this.path), { recursive: true });
     const fh = await fs.open(this.path, "a");
     try {
       await fh.write(`${JSON.stringify(record)}
@@ -648,246 +656,6 @@ function deterministicCompletion(check) {
   };
 }
 
-// src/runtime/personify/analyst.ts
-var judgeEvidenceUri = /^(verdict|judge|score)\b/i;
-var assertTraceDerivedFindings = (findings) => {
-  for (const f of findings) {
-    for (const ref of f.evidence_refs ?? []) {
-      if (ref.kind === "metric" && judgeEvidenceUri.test(ref.uri)) {
-        throw new PlannerError(
-          `steer-firewall: finding ${stringifySafe(f.finding_id)} cites judge-derived evidence (${stringifySafe(ref.uri)}); findings fed to a combinator's steer decision must be trace-derived, not judge-derived (selector \u2260 judge)`
-        );
-      }
-    }
-  }
-};
-function createScopeAnalyst(scope, options) {
-  if (!options.analyst || typeof options.analyst.act !== "function") {
-    throw new AnalystError("createScopeAnalyst: analyst must be an Agent with an act() method");
-  }
-  const label = options.label ?? "analyst";
-  return {
-    async analyze(input) {
-      const task = options.buildTask(input);
-      const spawned = scope.spawn(options.analyst, task, {
-        budget: options.budget,
-        label
-      });
-      if (!spawned.ok) {
-        throw new AnalystError(
-          `createScopeAnalyst: analyst spawn refused by the conserved pool (${spawned.reason}); cannot steer node ${stringifySafe(input.nodeId)} on an unrun analyst`
-        );
-      }
-      const settled = await drainAnalystSettlement(scope, spawned.handle.id);
-      const findings = readAnalystFindings(settled);
-      assertTraceDerivedFindings(findings);
-      return findings;
-    }
-  };
-}
-async function drainAnalystSettlement(scope, analystId) {
-  for (; ; ) {
-    const settled = await scope.next();
-    if (settled === null) {
-      throw new AnalystError(
-        `createScopeAnalyst: scope drained before analyst ${stringifySafe(analystId)} settled`
-      );
-    }
-    if (settled.handle.id === analystId) return settled;
-  }
-}
-function readAnalystFindings(settled) {
-  if (settled.kind === "down") {
-    throw new AnalystError(
-      `createScopeAnalyst: analyst ${stringifySafe(settled.handle.id)} settled down (${settled.infra ? "infra" : "result"}): ${stringifySafe(settled.reason)}`
-    );
-  }
-  const out = settled.out;
-  if (!Array.isArray(out)) {
-    throw new PlannerError(
-      `createScopeAnalyst: analyst ${stringifySafe(settled.handle.id)} must return AnalystFinding[], got ${stringifySafe(out)}`
-    );
-  }
-  return out;
-}
-function registryScopeAnalyst(registry, buildInputs) {
-  return {
-    async analyze(input) {
-      const projection = buildInputs(input);
-      const result = await registry.run(projection.runId, projection.inputs, projection.opts);
-      const findings = result.findings;
-      assertTraceDerivedFindings(findings);
-      return findings;
-    }
-  };
-}
-function buildSteerContext(findings, settledSoFar) {
-  assertTraceDerivedFindings(findings);
-  const lastValidScore = observedBestScore(settledSoFar);
-  return {
-    findings,
-    settledSoFar,
-    ...lastValidScore !== void 0 ? { lastValidScore } : {}
-  };
-}
-function observedBestScore(settledSoFar) {
-  let best;
-  for (const s of settledSoFar) {
-    if (s.kind !== "done") continue;
-    const v = s.verdict;
-    if (!v || v.valid !== true || typeof v.score !== "number") continue;
-    if (best === void 0 || v.score > best) best = v.score;
-  }
-  return best;
-}
-
-// src/runtime/driver.ts
-function createDriver(options) {
-  if (typeof options.planner !== "function") {
-    throw new ValidationError("createDriver: planner must be a function");
-  }
-  const maxIterations = options.maxIterations ?? 8;
-  if (!Number.isFinite(maxIterations) || maxIterations <= 0) {
-    throw new ValidationError("createDriver: maxIterations must be > 0");
-  }
-  const maxFanout = options.maxFanout ?? 4;
-  if (!Number.isFinite(maxFanout) || maxFanout < 1) {
-    throw new ValidationError("createDriver: maxFanout must be >= 1");
-  }
-  let pending;
-  return {
-    name: options.name ?? "dynamic",
-    async plan(task, history) {
-      if (history.length >= maxIterations) {
-        pending = { kind: "stop", rationale: `maxIterations (${maxIterations}) reached` };
-        return [];
-      }
-      const analyses = options.analyze && history.length > 0 ? await runAnalyze(options.analyze, task, history) : void 0;
-      if (options.complete && history.length > 0) {
-        const verdict = await runComplete(options.complete, task, history);
-        if (completionAuthorizes(verdict, options.completionPolicy)) {
-          pending = {
-            kind: "stop",
-            rationale: `complete (${verdict.determinism}): ${verdict.reasons ?? "satisfied"}`
-          };
-          return [];
-        }
-      }
-      const move = await options.planner({
-        task,
-        history,
-        iterationsSpent: history.length,
-        iterationsRemaining: maxIterations - history.length,
-        ...analyses ? { analyses } : {}
-      });
-      pending = validateMove(move, maxFanout);
-      if (pending.kind === "select") {
-        const iter = history[pending.index];
-        if (!iter || iter.output === void 0) {
-          throw new PlannerError(
-            `dynamic planner select.index ${pending.index} is not a completed iteration with output (history length ${history.length})`
-          );
-        }
-      }
-      switch (pending.kind) {
-        case "refine":
-          return [pending.task];
-        case "fanout":
-          return pending.tasks;
-        case "stop":
-        case "select":
-          return [];
-      }
-    },
-    decide() {
-      return pending?.kind === "stop" || pending?.kind === "select" ? "done" : "continue";
-    },
-    describePlan() {
-      if (!pending) return void 0;
-      const out = { kind: pending.kind };
-      if (pending.rationale !== void 0) out.rationale = pending.rationale;
-      if ((pending.kind === "refine" || pending.kind === "fanout") && pending.parentIndex !== void 0) {
-        out.parentIndex = pending.parentIndex;
-      }
-      return out;
-    },
-    selectWinner(history) {
-      if (pending?.kind !== "select") return void 0;
-      const iter = history[pending.index];
-      if (!iter || iter.output === void 0) return void 0;
-      return {
-        task: iter.task,
-        output: iter.output,
-        verdict: iter.verdict,
-        iterationIndex: iter.index,
-        agentRunName: iter.agentRunName
-      };
-    }
-  };
-}
-function validateMove(move, maxFanout) {
-  if (!move || typeof move !== "object" || typeof move.kind !== "string") {
-    throw new PlannerError(`dynamic planner returned a non-move value: ${stringifySafe(move)}`);
-  }
-  switch (move.kind) {
-    case "refine":
-      return move;
-    case "stop":
-      return move;
-    case "select": {
-      if (!Number.isInteger(move.index) || move.index < 0) {
-        throw new PlannerError(
-          `dynamic planner select move must carry a non-negative integer index, got ${stringifySafe(move.index)}`
-        );
-      }
-      return move;
-    }
-    case "fanout": {
-      if (!Array.isArray(move.tasks) || move.tasks.length === 0) {
-        throw new PlannerError("dynamic planner fanout move must carry a non-empty tasks[]");
-      }
-      if (move.tasks.length <= maxFanout) return move;
-      return {
-        kind: "fanout",
-        tasks: move.tasks.slice(0, maxFanout),
-        rationale: `${move.rationale ?? ""} [clamped ${move.tasks.length}\u2192${maxFanout}]`.trim()
-      };
-    }
-    default:
-      throw new PlannerError(
-        `dynamic planner returned unknown move kind: ${stringifySafe(move.kind)}`
-      );
-  }
-}
-async function runAnalyze(analyze2, task, history) {
-  const findings = await analyze2({ task, history });
-  if (!Array.isArray(findings)) {
-    throw new PlannerError(
-      `createDriver: analyze hook must return AnalystFinding[], got ${stringifySafe(findings)}`
-    );
-  }
-  assertTraceDerivedFindings(findings);
-  return findings;
-}
-async function runComplete(complete, task, history) {
-  const verdict = await complete.assess({ task, history });
-  if (!verdict || typeof verdict.done !== "boolean" || verdict.determinism !== "deterministic" && verdict.determinism !== "probabilistic") {
-    throw new PlannerError(
-      `createDriver: complete.assess must return a CompletionVerdict {done, determinism}, got ${stringifySafe(verdict)}`
-    );
-  }
-  return verdict;
-}
-function renderAnalyses(findings) {
-  if (findings.length === 0) return "";
-  const rows = findings.map((f) => {
-    const action = f.recommended_action ? ` \u2192 ${f.recommended_action}` : "";
-    return `  - [${f.severity}/${f.area}] ${f.claim}${action} (conf ${f.confidence.toFixed(2)})`;
-  });
-  return `Trace-analyst findings (diagnosis of the attempts so far \u2014 steer from these, not the verdict score alone):
-${rows.join("\n")}`;
-}
-
 // src/runtime/observe.ts
 import { makeFinding } from "@tangle-network/agent-eval";
 var observerId = "observe/trace";
@@ -2231,7 +1999,126 @@ function createMcpEnvironment(opts) {
   };
 }
 
+// src/runtime/personify/analyst.ts
+var judgeEvidenceUri = /^(verdict|judge|score)\b/i;
+var assertTraceDerivedFindings = (findings) => {
+  for (const f of findings) {
+    for (const ref of f.evidence_refs ?? []) {
+      if (ref.kind === "metric" && judgeEvidenceUri.test(ref.uri)) {
+        throw new PlannerError(
+          `steer-firewall: finding ${stringifySafe(f.finding_id)} cites judge-derived evidence (${stringifySafe(ref.uri)}); findings fed to a combinator's steer decision must be trace-derived, not judge-derived (selector \u2260 judge)`
+        );
+      }
+    }
+  }
+};
+function createScopeAnalyst(scope, options) {
+  if (!options.analyst || typeof options.analyst.act !== "function") {
+    throw new AnalystError("createScopeAnalyst: analyst must be an Agent with an act() method");
+  }
+  const label = options.label ?? "analyst";
+  return {
+    async analyze(input) {
+      const task = options.buildTask(input);
+      const spawned = scope.spawn(options.analyst, task, {
+        budget: options.budget,
+        label
+      });
+      if (!spawned.ok) {
+        throw new AnalystError(
+          `createScopeAnalyst: analyst spawn refused by the conserved pool (${spawned.reason}); cannot steer node ${stringifySafe(input.nodeId)} on an unrun analyst`
+        );
+      }
+      const settled = await drainAnalystSettlement(scope, spawned.handle.id);
+      const findings = readAnalystFindings(settled);
+      assertTraceDerivedFindings(findings);
+      return findings;
+    }
+  };
+}
+async function drainAnalystSettlement(scope, analystId) {
+  for (; ; ) {
+    const settled = await scope.next();
+    if (settled === null) {
+      throw new AnalystError(
+        `createScopeAnalyst: scope drained before analyst ${stringifySafe(analystId)} settled`
+      );
+    }
+    if (settled.handle.id === analystId) return settled;
+  }
+}
+function readAnalystFindings(settled) {
+  if (settled.kind === "down") {
+    throw new AnalystError(
+      `createScopeAnalyst: analyst ${stringifySafe(settled.handle.id)} settled down (${settled.infra ? "infra" : "result"}): ${stringifySafe(settled.reason)}`
+    );
+  }
+  const out = settled.out;
+  if (!Array.isArray(out)) {
+    throw new PlannerError(
+      `createScopeAnalyst: analyst ${stringifySafe(settled.handle.id)} must return AnalystFinding[], got ${stringifySafe(out)}`
+    );
+  }
+  return out;
+}
+function registryScopeAnalyst(registry, buildInputs) {
+  return {
+    async analyze(input) {
+      const projection = buildInputs(input);
+      const result = await registry.run(projection.runId, projection.inputs, projection.opts);
+      const findings = result.findings;
+      assertTraceDerivedFindings(findings);
+      return findings;
+    }
+  };
+}
+function buildSteerContext(findings, settledSoFar) {
+  assertTraceDerivedFindings(findings);
+  const lastValidScore = observedBestScore(settledSoFar);
+  return {
+    findings,
+    settledSoFar,
+    ...lastValidScore !== void 0 ? { lastValidScore } : {}
+  };
+}
+function observedBestScore(settledSoFar) {
+  let best;
+  for (const s of settledSoFar) {
+    if (s.kind !== "done") continue;
+    const v = s.verdict;
+    if (!v || v.valid !== true || typeof v.score !== "number") continue;
+    if (best === void 0 || v.score > best) best = v.score;
+  }
+  return best;
+}
+
 // src/runtime/supervise/scope.ts
+var nestedScopeSeamKey = "nested-scope";
+function makeNestedScopeSeam(args, childNodeId) {
+  return {
+    depth: args.depth,
+    ...args.maxDepth !== void 0 ? { maxDepth: args.maxDepth } : {},
+    journalRoot: args.root,
+    mount(nestedRoot, signal) {
+      return createScope({
+        parentId: childNodeId,
+        root: nestedRoot,
+        pool: args.pool,
+        journal: args.journal,
+        blobs: args.blobs,
+        executors: args.executors,
+        // Re-seed the parent's NON-recursion seams (sandbox/router for leaf grandchildren);
+        // the nested scope adds its OWN nested-scope seam per child in `spawn`.
+        seams: args.seams,
+        depth: args.depth + 1,
+        ...args.maxDepth !== void 0 ? { maxDepth: args.maxDepth } : {},
+        signal,
+        ...args.now ? { now: args.now } : {},
+        ...args.hooks ? { hooks: args.hooks } : {}
+      });
+    }
+  };
+}
 function createScope(args) {
   const children = /* @__PURE__ */ new Map();
   let spawnOrdinal = 0;
@@ -2258,7 +2145,10 @@ function createScope(args) {
       const cascadeAbort = () => childAbort.abort();
       if (args.signal.aborted) childAbort.abort();
       else args.signal.addEventListener("abort", cascadeAbort, { once: true });
-      const ctx = { signal: childAbort.signal, seams: args.seams };
+      const ctx = {
+        signal: childAbort.signal,
+        seams: { ...args.seams, [nestedScopeSeamKey]: makeNestedScopeSeam(args, id) }
+      };
       const executor = resolved.value(spec, ctx);
       const handle = {
         id,
@@ -3020,8 +2910,8 @@ var InMemoryCorpus = class {
   }
 };
 var FileCorpus = class {
-  constructor(path) {
-    this.path = path;
+  constructor(path2) {
+    this.path = path2;
   }
   path;
   async append(record) {
@@ -3085,8 +2975,8 @@ var FileCorpus = class {
   }
   async appendLine(record) {
     const fs = await import("fs/promises");
-    const path = await import("path");
-    await fs.mkdir(path.dirname(this.path), { recursive: true });
+    const path2 = await import("path");
+    await fs.mkdir(path2.dirname(this.path), { recursive: true });
     const fh = await fs.open(this.path, "a");
     try {
       await fh.write(`${JSON.stringify(record)}
@@ -3135,16 +3025,170 @@ function isNoEntError2(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 
-// src/runtime/supervise/runtime.ts
-import { spawn } from "child_process";
-import { estimateCost as estimateCost2, isModelPriced as isModelPriced2 } from "@tangle-network/agent-eval";
-
-// src/runtime/router-client.ts
-import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
-async function routerChatWithUsage(cfg, messages, opts) {
-  const url = `${cfg.routerBaseUrl.replace(/\/$/, "")}/chat/completions`;
-  const headers = { "content-type": "application/json", authorization: `Bearer ${cfg.routerKey}` };
-  let temperature = opts?.temperature ?? 0.2;
+// src/runtime/supervise/driver-executor.ts
+var driverRuntime = "driver";
+var driverRole = "driver";
+function driverChild(name, driver, journal) {
+  const spec = {
+    profile: { name, metadata: { role: driverRole } },
+    harness: null,
+    driver,
+    journal
+  };
+  return {
+    name,
+    executorSpec: spec,
+    act() {
+      throw new ValidationError(
+        `driverChild: "${name}" was run directly; a driver child runs through its nested-scope executor`
+      );
+    }
+  };
+}
+function isDriverSpec(spec) {
+  const role = spec.profile.metadata?.role;
+  if (role !== driverRole) return false;
+  const driver = spec.driver;
+  if (!isAgent(driver)) {
+    throw new ValidationError(
+      "driverExecutor: a driver-role spec must carry a `driver` Agent to run inside its nested scope"
+    );
+  }
+  return true;
+}
+var driverExecutorFactory = (spec, ctx) => {
+  if (!isDriverSpec(spec)) {
+    throw new ValidationError(
+      'driverExecutorFactory: spec is not a driver child (no role:"driver" marker)'
+    );
+  }
+  const driver = spec.driver;
+  const journal = spec.journal;
+  const seam = readNestedScopeSeam(ctx);
+  let artifact;
+  return {
+    runtime: driverRuntime,
+    async execute(task, signal) {
+      const nestedRoot = nestedTreeKey(seam, journal);
+      await journal.beginTree(nestedRoot, (/* @__PURE__ */ new Date(0)).toISOString());
+      const nestedScope = seam.mount(nestedRoot, signal);
+      const out = await driver.act(task, nestedScope);
+      const settled = await loadSettled(journal, nestedRoot);
+      const spent = sumSpend(settled);
+      const verdict = deriveDeliveryVerdict(settled);
+      artifact = {
+        outRef: `${driverRuntime}:${nestedRoot}`,
+        out,
+        spent,
+        ...verdict ? { verdict } : {}
+      };
+      return artifact;
+    },
+    teardown() {
+      return Promise.resolve({ destroyed: true });
+    },
+    resultArtifact() {
+      if (!artifact) {
+        throw new ValidationError("driverExecutor: resultArtifact() read before execute()");
+      }
+      return artifact;
+    }
+  };
+};
+function withDriverExecutor(base) {
+  return {
+    register: base.register.bind(base),
+    resolve(spec) {
+      const role = spec.profile.metadata?.role;
+      if (role === driverRole && !spec.executor) {
+        return { succeeded: true, value: driverExecutorFactory };
+      }
+      return base.resolve(spec);
+    }
+  };
+}
+function nestedTreeKey(seam, journal) {
+  return `${seam.journalRoot}/d${nextNestOrdinal(journal)}`;
+}
+var nestCounters = /* @__PURE__ */ new WeakMap();
+function nextNestOrdinal(journal) {
+  let c = nestCounters.get(journal);
+  if (!c) {
+    c = { n: 0 };
+    nestCounters.set(journal, c);
+  }
+  return c.n++;
+}
+async function loadSettled(journal, nestedRoot) {
+  const events = await journal.loadTree(nestedRoot);
+  if (events === void 0) {
+    throw new ValidationError(
+      `driverExecutor: nested tree '${nestedRoot}' missing from the journal after run (corrupted log)`
+    );
+  }
+  return events.filter(
+    (ev) => ev.kind === "settled"
+  );
+}
+function sumSpend(settled) {
+  const total = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
+  for (const ev of settled) {
+    total.iterations += ev.spent.iterations;
+    total.tokens.input += ev.spent.tokens.input;
+    total.tokens.output += ev.spent.tokens.output;
+    total.usd += ev.spent.usd;
+    total.ms += ev.spent.ms;
+  }
+  return total;
+}
+function deriveDeliveryVerdict(settled) {
+  let sawChild = false;
+  let anyValid = false;
+  let bestValidScore;
+  let bestDoneScore;
+  for (const ev of settled) {
+    sawChild = true;
+    if (ev.status !== "done") continue;
+    const score = ev.verdict?.score;
+    if (score !== void 0 && (bestDoneScore === void 0 || score > bestDoneScore)) {
+      bestDoneScore = score;
+    }
+    if (ev.verdict?.valid === true) {
+      anyValid = true;
+      if (score !== void 0 && (bestValidScore === void 0 || score > bestValidScore)) {
+        bestValidScore = score;
+      }
+    }
+  }
+  if (!sawChild) return void 0;
+  return {
+    valid: anyValid,
+    score: anyValid ? bestValidScore ?? 1 : bestDoneScore ?? 0
+  };
+}
+function readNestedScopeSeam(ctx) {
+  const seam = ctx.seams[nestedScopeSeamKey];
+  if (!seam || typeof seam.mount !== "function") {
+    throw new ValidationError(
+      `driverExecutor: missing required seam "${nestedScopeSeamKey}" \u2014 a driver child must be spawned through a Scope that seeds it (the keystone scope does)`
+    );
+  }
+  return seam;
+}
+function isAgent(value) {
+  return typeof value === "object" && value !== null && typeof value.act === "function" && typeof value.name === "string";
+}
+
+// src/runtime/supervise/runtime.ts
+import { spawn } from "child_process";
+import { estimateCost as estimateCost2, isModelPriced as isModelPriced2 } from "@tangle-network/agent-eval";
+
+// src/runtime/router-client.ts
+import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
+async function routerChatWithUsage(cfg, messages, opts) {
+  const url = `${cfg.routerBaseUrl.replace(/\/$/, "")}/chat/completions`;
+  const headers = { "content-type": "application/json", authorization: `Bearer ${cfg.routerKey}` };
+  let temperature = opts?.temperature ?? 0.2;
   let lastErr = "";
   for (let attempt = 0; attempt < 5; attempt += 1) {
     const res = await fetch(url, {
@@ -3194,7 +3238,8 @@ async function routerChatWithTools(cfg, messages, tools, opts) {
       messages,
       tools,
       tool_choice: opts?.toolChoice ?? "auto",
-      temperature: opts?.temperature ?? 0.3
+      temperature: opts?.temperature ?? 0.3,
+      ...opts?.maxTokens ? { max_tokens: opts.maxTokens } : {}
     }),
     ...opts?.signal ? { signal: opts.signal } : {}
   });
@@ -3218,7 +3263,7 @@ async function routerChatWithTools(cfg, messages, tools, opts) {
 }
 async function routerToolLoop(cfg, system, user, tools, execute, opts) {
   const maxTurns = opts?.maxTurns ?? 4;
-  const messages = [
+  const messages = opts?.initialMessages ? [...opts.initialMessages] : [
     { role: "system", content: system },
     { role: "user", content: user }
   ];
@@ -3229,6 +3274,7 @@ async function routerToolLoop(cfg, system, user, tools, execute, opts) {
   for (let turn = 1; turn <= maxTurns; turn += 1) {
     const r = await routerChatWithTools(cfg, messages, tools, {
       ...opts?.temperature !== void 0 ? { temperature: opts.temperature } : {},
+      ...opts?.maxTokens ? { maxTokens: opts.maxTokens } : {},
       ...opts?.signal ? { signal: opts.signal } : {}
     });
     if (r.usage) {
@@ -3237,7 +3283,7 @@ async function routerToolLoop(cfg, system, user, tools, execute, opts) {
     }
     if (r.content) lastText = r.content;
     if (r.toolCalls.length === 0)
-      return { final: lastText, turns: turn, toolCalls, toolTrace, usage };
+      return { final: lastText, turns: turn, toolCalls, toolTrace, usage, messages };
     messages.push({
       role: "assistant",
       content: r.content ?? "",
@@ -3265,7 +3311,7 @@ async function routerToolLoop(cfg, system, user, tools, execute, opts) {
       toolTrace.push({ name: tc.name, args: tc.arguments, result: out });
     }
   }
-  return { final: lastText, turns: maxTurns, toolCalls, toolTrace, usage };
+  return { final: lastText, turns: maxTurns, toolCalls, toolTrace, usage, messages };
 }
 
 // src/runtime/supervise/runtime.ts
@@ -4037,14 +4083,22 @@ function createSupervisor() {
     if (actOutcome.ok) {
       pool2.assertNoOpenTickets();
       const out = actOutcome.out;
-      const outRef = contentAddress(out);
-      await opts.blobs.put(outRef, out);
+      if (out !== void 0) {
+        const outRef = contentAddress(out);
+        await opts.blobs.put(outRef, out);
+        return {
+          kind: "winner",
+          out,
+          outRef,
+          tree,
+          spentTotal: await spentTotalFromJournal(journal, opts.runId)
+        };
+      }
       return {
-        kind: "winner",
-        out,
-        outRef,
+        kind: "no-winner",
+        reason: classifyNoWinner(controller, pool2, opts, breaker),
         tree,
-        spentTotal: await spentTotalFromJournal(journal, opts.runId)
+        downCount: breaker.downCount()
       };
     }
     return {
@@ -4245,7 +4299,7 @@ function createShapeContext(persona, budget, analyst) {
         executorSpec: spec,
         act() {
           throw new ValidationError(
-            `personify: spawned child "${name}" was run as a driver; its executorSpec drives a leaf`
+            `personify: spawned child "${name}" was run directly; its executorSpec drives it (a leaf, or \u2014 for a driver child \u2014 a nested scope through the recursive driver-executor)`
           );
         }
       };
@@ -4279,7 +4333,8 @@ async function runPersonified(options) {
     ...options.maxRestarts !== void 0 ? { maxRestarts: options.maxRestarts } : {},
     ...options.withinMs !== void 0 ? { withinMs: options.withinMs } : {},
     ...options.now ? { now: options.now } : {},
-    ...options.signal ? { signal: options.signal } : {}
+    ...options.signal ? { signal: options.signal } : {},
+    ...options.hooks ? { hooks: options.hooks } : {}
   };
   return supervisor.run(rootAgent, options.task, supervisorOpts);
 }
@@ -4309,13 +4364,13 @@ function resolveShapeBudget(root, over) {
 var defaultFanout = 3;
 function personaRegistry(persona) {
   const { registry, seams } = persona.executors;
-  if (registry) return registry;
+  if (registry) return withDriverExecutor(registry);
   if (!seams) {
     throw new ValidationError(
       `personify: persona "${persona.name}" supplies neither a registry nor seams`
     );
   }
-  return withSeams(createExecutorRegistry(), seams);
+  return withDriverExecutor(withSeams(createExecutorRegistry(), seams));
 }
 function withSeams(base, seams) {
   return {
@@ -4682,59 +4737,41 @@ import { pairedBootstrap, paretoFrontier } from "@tangle-network/agent-eval";
 import { createChatClient, estimateCost as estimateCost3, isModelPriced as isModelPriced3 } from "@tangle-network/agent-eval";
 var taskNudge = "Use the available tools to bring the artifact to the required final state. Address EVERY distinct change the request implies. After each tool result, check what remains and continue. Re-read the values you set to confirm they took. Reply DONE only once every required change is made and verified.";
 async function runShot(surface, _task, handle, tools, messages, opts, modelOverride) {
-  const innerTurns = opts.innerTurns ?? 4;
-  let completions = 0;
-  let toolCalls = 0;
   let toolErrors = 0;
-  const tokens = { input: 0, output: 0 };
-  for (let t = 0; t < innerTurns; t += 1) {
-    const res = await fetch(`${opts.routerBaseUrl.replace(/\/$/, "")}/chat/completions`, {
-      method: "POST",
-      headers: { "content-type": "application/json", authorization: `Bearer ${opts.routerKey}` },
-      body: JSON.stringify({
-        model: modelOverride ?? opts.model,
-        messages,
-        tools,
-        tool_choice: "auto",
-        temperature: opts.temperature ?? 0.7,
-        ...opts.maxTokens ? { max_tokens: opts.maxTokens } : {}
-      })
-    });
-    if (!res.ok) throw new Error(`router ${res.status}: ${(await res.text()).slice(0, 200)}`);
-    completions += 1;
-    const data = await res.json();
-    if (typeof data.usage?.prompt_tokens === "number") tokens.input += data.usage.prompt_tokens;
-    if (typeof data.usage?.completion_tokens === "number")
-      tokens.output += data.usage.completion_tokens;
-    const msg = data.choices?.[0]?.message;
-    if (!msg) break;
-    const calls = msg.tool_calls ?? [];
-    messages.push({
-      role: "assistant",
-      content: msg.content ?? "",
-      ...calls.length ? { tool_calls: calls } : {}
-    });
-    if (calls.length === 0) break;
-    for (const call of calls) {
-      toolCalls += 1;
-      let args = {};
-      try {
-        args = JSON.parse(call.function.arguments || "{}");
-      } catch {
-        toolErrors += 1;
-      }
-      let out;
-      try {
-        out = await surface.call(handle, call.function.name, args);
-        if (out.startsWith("ERROR:")) toolErrors += 1;
-      } catch (e) {
-        toolErrors += 1;
-        out = `ERROR: ${e instanceof Error ? e.message : String(e)}`;
-      }
-      messages.push({ role: "tool", tool_call_id: call.id, content: out });
+  const execute = async (name, args) => {
+    try {
+      const out = await surface.call(handle, name, args);
+      if (out.startsWith("ERROR:")) toolErrors += 1;
+      return out;
+    } catch (e) {
+      toolErrors += 1;
+      return `ERROR: ${e instanceof Error ? e.message : String(e)}`;
     }
-  }
-  return { messages, completions, toolCalls, toolErrors, tokens };
+  };
+  const r = await routerToolLoop(
+    {
+      routerBaseUrl: opts.routerBaseUrl,
+      routerKey: opts.routerKey,
+      model: modelOverride ?? opts.model
+    },
+    "",
+    "",
+    tools,
+    execute,
+    {
+      maxTurns: opts.innerTurns ?? 4,
+      temperature: opts.temperature ?? 0.7,
+      initialMessages: messages,
+      ...opts.maxTokens ? { maxTokens: opts.maxTokens } : {}
+    }
+  );
+  return {
+    messages: r.messages,
+    completions: r.turns,
+    toolCalls: r.toolCalls,
+    toolErrors,
+    tokens: r.usage
+  };
 }
 function compactTrajectory(messages) {
   return messages.filter((m) => m.role === "assistant" || m.role === "tool").map((m) => {
@@ -4915,7 +4952,7 @@ function analystExecutor(opts) {
   };
 }
 function agenticRegistry(surface, opts) {
-  return {
+  const leaves = {
     register() {
       throw new Error("agenticRegistry: register unsupported");
     },
@@ -4925,13 +4962,14 @@ function agenticRegistry(surface, opts) {
       return { succeeded: true, value: factory };
     }
   };
+  return withDriverExecutor(leaves);
 }
 function leaf(name, role) {
   const agent = {
     name,
     executorSpec: { profile: { name, metadata: { role } }, harness: null },
     act() {
-      throw new Error(`agentic: spawned leaf "${name}" run as a driver`);
+      throw new Error(`agentic: spawned child "${name}" was run directly (the executor drives it)`);
     }
   };
   return agent;
@@ -6186,135 +6224,2812 @@ ${summary}`,
   };
 }
 
-// src/runtime/verifier-environment.ts
-var submitTool = {
-  type: "function",
-  function: {
-    name: "submit_answer",
-    description: "Submit your answer for evaluation. You may submit more than once \u2014 the best-scoring submission counts. Submit the COMPLETE final answer, not a fragment.",
-    parameters: {
-      type: "object",
-      properties: { answer: { type: "string", description: "The complete final answer." } },
-      required: ["answer"]
+// src/runtime/supervise/completion-gate.ts
+function gateOnDeliverable(inner, deliverable) {
+  let gated;
+  const check = async (out, baseScore) => {
+    let delivered;
+    try {
+      delivered = await deliverable.check(out) === true;
+    } catch {
+      delivered = false;
     }
-  }
-};
-function createVerifierEnvironment(opts) {
-  if (opts.extraTools?.length && !opts.callExtra) {
-    throw new Error(`${opts.name}: extraTools requires callExtra`);
-  }
-  const states = /* @__PURE__ */ new Map();
-  let seq = 0;
+    return { valid: delivered, score: baseScore ?? (delivered ? 1 : 0) };
+  };
   return {
-    name: opts.name,
-    async open(task) {
-      seq += 1;
-      const handle = { id: `${opts.name}-${seq}`, surface: opts.name };
-      states.set(handle.id, { task, submissions: [] });
-      return handle;
-    },
-    async tools() {
-      return [submitTool, ...opts.extraTools ?? []];
-    },
-    async call(handle, name, args) {
-      const state = states.get(handle.id);
-      if (!state) return "ERROR: workspace closed";
-      if (name === "submit_answer") {
-        const answer = String(args.answer ?? "").trim();
-        if (!answer) return "ERROR: empty answer";
-        state.submissions.push(answer);
-        return `submission ${state.submissions.length} recorded`;
-      }
-      if (opts.callExtra && opts.extraTools?.some((t) => t.function.name === name)) {
-        try {
-          return await opts.callExtra(state.task, name, args);
-        } catch (e) {
-          return `ERROR: ${e instanceof Error ? e.message : String(e)}`;
-        }
-      }
-      return `ERROR: unknown tool ${name}`;
-    },
-    // Keep-best across submissions — the measured law (workers reach correct answers,
-    // then revise past them; final-state scoring undersells every strategy).
-    async score(task, handle) {
-      const state = states.get(handle.id);
-      if (!state || state.submissions.length === 0) return { passes: 0, total: 1, errored: 0 };
-      let best = { passes: 0, total: 1, errored: 0 };
-      const ratio = (s) => s.total > 0 ? s.passes / s.total : 0;
-      for (const answer of state.submissions) {
-        const s = await opts.check(task, answer);
-        if (ratio(s) > ratio(best)) best = s;
+    runtime: inner.runtime,
+    ...inner.budgetExempt !== void 0 ? { budgetExempt: inner.budgetExempt } : {},
+    ...inner.deliver ? { deliver: (m) => inner.deliver?.(m) } : {},
+    execute(task, signal) {
+      const r = inner.execute(task, signal);
+      if (isAsyncIterable3(r)) {
+        return (async function* () {
+          for await (const ev of r) yield ev;
+          const art = inner.resultArtifact();
+          gated = await check(art.out, art.verdict?.score);
+        })();
       }
-      return best;
+      return (async () => {
+        const res = await r;
+        gated = await check(res.out, res.verdict?.score);
+        return { ...res, verdict: gated };
+      })();
     },
-    async close(handle) {
-      states.delete(handle.id);
+    teardown: (grace) => inner.teardown(grace),
+    resultArtifact() {
+      const art = inner.resultArtifact();
+      return { ...art, verdict: gated ?? art.verdict };
     }
   };
 }
+function isAsyncIterable3(v) {
+  return v != null && typeof v[Symbol.asyncIterator] === "function";
+}
 
-// src/runtime/waterfall.ts
-function createWaterfallCollector() {
-  let spans = /* @__PURE__ */ new Map();
-  const onEvent = (event) => {
-    if (event.target === "agent.spawn") {
-      const p = event.payload ?? {};
-      const id = p.childId ?? event.id;
-      spans.set(id, {
-        id,
-        label: p.label ?? id,
-        runId: event.runId,
-        ...event.parentId !== void 0 ? { parentId: event.parentId } : {},
-        startMs: event.timestamp,
-        status: "running",
-        usd: 0,
-        tokens: { input: 0, output: 0 }
-      });
-      return;
-    }
-    if (event.target === "agent.child") {
-      const p = event.payload ?? {};
-      const id = p.childId;
-      if (!id) return;
-      const span = spans.get(id);
-      if (!span) return;
-      span.endMs = event.timestamp;
-      span.status = p.status === "down" ? "down" : "done";
-      span.usd = p.spent?.usd ?? 0;
-      span.tokens = {
-        input: p.spent?.tokens?.input ?? 0,
-        output: p.spent?.tokens?.output ?? 0
+// src/runtime/supervise/authoring.ts
+function asAuthoredProfile(raw) {
+  const p = raw;
+  if (!p || typeof p.systemPrompt !== "string" || p.systemPrompt.trim().length === 0) return null;
+  return {
+    name: typeof p.name === "string" && p.name.length > 0 ? p.name : "worker",
+    systemPrompt: p.systemPrompt,
+    ...typeof p.model === "string" ? { model: p.model } : {}
+  };
+}
+function supervisorSkill(opts) {
+  return [
+    "You are a SUPERVISOR. You do NOT do the work yourself \u2014 your job is to DESIGN and DRIVE specialist worker agents.",
+    "",
+    "For the task you are given:",
+    "1. DECOMPOSE it into the smallest set of sub-tasks a single focused worker can each deliver.",
+    "2. For EACH sub-task, AUTHOR a worker by calling spawn_worker with a COMPLETE `profile`:",
+    "   \u2022 name: a short id for the worker.",
+    '   \u2022 systemPrompt: rich, specific instructions for THIS sub-task \u2014 tell the worker exactly what to produce, how to use its tools fully, and what "done" means. Never a one-liner; write the prompt a power-user would write.',
+    "   \u2022 model: the model best suited to this sub-task (omit to use the default).",
+    "   NEVER spawn a worker with an empty profile. The quality of the worker IS the quality of the profile you write.",
+    "3. await_next to collect each worker. Its result says valid:true only if the deployable check passed.",
+    "4. If a worker did NOT deliver, AUTHOR A NEW worker whose systemPrompt names the SPECIFIC failure and how to fix it \u2014 never just retry the same prompt.",
+    "5. Stop (reply with no tool call) once the work is delivered. You cannot declare done yourself \u2014 only a delivered (valid:true) worker counts.",
+    ...opts?.goal ? ["", `The goal: ${opts.goal}`] : []
+  ].join("\n");
+}
+function authoredWorker(profile, opts) {
+  let artifact;
+  const model = profile.model ?? opts.cfg.model;
+  const inner = {
+    runtime: "router",
+    async execute(_t, signal) {
+      const res = await routerChatWithUsage(
+        { ...opts.cfg, model },
+        [
+          { role: "system", content: profile.systemPrompt },
+          { role: "user", content: opts.taskPrompt }
+        ],
+        { temperature: opts.temperature ?? 0.4, ...signal ? { signal } : {} }
+      );
+      artifact = {
+        outRef: contentAddress(res.content),
+        out: res.content,
+        spent: {
+          iterations: 1,
+          tokens: res.usage ?? { input: 0, output: 0 },
+          usd: res.costUsd ?? 0,
+          ms: 0
+        }
       };
-      if (typeof p.score === "number") span.score = p.score;
+      return artifact;
+    },
+    teardown: () => Promise.resolve({ destroyed: true }),
+    resultArtifact: () => {
+      if (!artifact) throw new Error("authoredWorker: resultArtifact read before execute");
+      return artifact;
     }
   };
-  const report = () => {
-    const all = [...spans.values()].sort((a, b) => a.startMs - b.startMs);
-    const start = all[0]?.startMs ?? 0;
-    const end = Math.max(start, ...all.map((s) => s.endMs ?? s.startMs));
-    const byKind = {};
-    let totalUsd = 0;
-    const totalTokens2 = { input: 0, output: 0 };
-    for (const s of all) {
-      totalUsd += s.usd;
-      totalTokens2.input += s.tokens.input;
-      totalTokens2.output += s.tokens.output;
-      const kind = s.label.includes(":") ? s.label.split(":")[0] : s.label;
-      const k = byKind[kind] ??= { count: 0, ms: 0, usd: 0, tokens: { input: 0, output: 0 } };
-      k.count += 1;
-      k.ms += (s.endMs ?? s.startMs) - s.startMs;
-      k.usd += s.usd;
-      k.tokens.input += s.tokens.input;
-      k.tokens.output += s.tokens.output;
-    }
-    return { spans: all, totalMs: end - start, totalUsd, totalTokens: totalTokens2, byKind };
+  const gated = gateOnDeliverable(inner, opts.deliverable);
+  const spec = {
+    profile: { name: profile.name },
+    harness: null,
+    executor: gated
   };
-  const render = (opts) => {
-    const { spans: all, totalMs, totalUsd, byKind } = report();
-    if (all.length === 0) return "(no spans observed)";
-    const width = opts?.width ?? 48;
-    const maxRows = opts?.maxRows ?? 60;
-    const start = all[0]?.startMs ?? 0;
+  return { name: profile.name, act: async () => "", executorSpec: spec };
+}
+
+// src/mcp/tools/coordination.ts
+var idArg = { type: "string", description: "The workerId returned by spawn_worker." };
+function createCoordinationTools(opts) {
+  let stopped = false;
+  let reason;
+  let questionSeq = 0;
+  const ledger = [];
+  const questions = [];
+  const questionPolicy = opts.questionPolicy ?? "auto";
+  const str = (v, field) => {
+    if (typeof v !== "string" || v.length === 0)
+      throw new Error(`coordination tools: "${field}" must be a non-empty string`);
+    return v;
+  };
+  const obj = (raw) => {
+    if (!raw || typeof raw !== "object")
+      throw new Error("coordination tools: arguments must be an object");
+    return raw;
+  };
+  const level = (v) => {
+    if (v === "worker" || v === "driver" || v === "loop") return v;
+    throw new Error('coordination tools: "level" must be worker, driver, or loop');
+  };
+  const urgency = (v) => {
+    if (v === "continue-without" || v === "blocks-step" || v === "blocks-run") return v;
+    throw new Error(
+      'coordination tools: "urgency" must be continue-without, blocks-step, or blocks-run'
+    );
+  };
+  const recordSettled = (s) => {
+    const w = s.kind === "done" ? {
+      id: s.handle.id,
+      status: "done",
+      score: s.verdict?.score ?? 0,
+      valid: s.verdict?.valid ?? false,
+      outRef: s.outRef
+    } : { id: s.handle.id, status: "down", reason: s.reason };
+    ledger.push(w);
+    return w;
+  };
+  const nextQuestionId = (from) => `${from}:q${questionSeq++}`;
+  const normalizeQuestion = (q, fallbackFrom) => {
+    const from = str(q.from ?? fallbackFrom, "from");
+    return {
+      id: typeof q.id === "string" && q.id.length > 0 ? q.id : nextQuestionId(from),
+      from,
+      level: level(q.level),
+      question: str(q.question, "question"),
+      reason: str(q.reason, "reason"),
+      ...q.options ? { options: q.options } : {},
+      urgency: urgency(q.urgency)
+    };
+  };
+  const addQuestion = (raw, fallbackFrom, decision) => {
+    const q = normalizeQuestion(raw, fallbackFrom);
+    const existing = questions.find((x) => x.id === q.id);
+    if (existing) return { question: existing, added: false };
+    const effectiveDecision = decision ?? (questionPolicy === "bubble" ? {
+      kind: "escalate",
+      to: "parent",
+      reason: "question policy bubbled to parent"
+    } : void 0);
+    const status = effectiveDecision?.kind === "answer" ? "answered" : effectiveDecision?.kind === "defer" ? "deferred" : effectiveDecision?.kind === "escalate" ? "escalated" : "open";
+    const record = {
+      ...q,
+      status,
+      openedAt: Date.now(),
+      ...effectiveDecision ? { decision: effectiveDecision } : {}
+    };
+    questions.push(record);
+    return { question: record, added: true };
+  };
+  const emitNewQuestion = async (record) => {
+    if (record.added) await opts.onEvent?.({ type: "question", question: record.question });
+    return record.question;
+  };
+  const decideQuestion = (questionId, decision) => {
+    const idx = questions.findIndex((q) => q.id === questionId);
+    if (idx < 0) throw new Error(`unknown questionId ${JSON.stringify(questionId)}`);
+    const prior = questions[idx];
+    const status = decision.kind === "answer" ? "answered" : decision.kind === "defer" ? "deferred" : "escalated";
+    const next = { ...prior, status, decision };
+    questions[idx] = next;
+    return next;
+  };
+  const blockingQuestionsForStop = () => {
+    if (questionPolicy === "auto" || questionPolicy === "bubble") return [];
+    return questions.filter((q) => {
+      const blocking = q.urgency === "blocks-step" || q.urgency === "blocks-run";
+      if (!blocking) return false;
+      if (questionPolicy === "mustDecide") return q.status === "open";
+      return q.status !== "answered" && q.status !== "deferred";
+    });
+  };
+  const tools = [
+    {
+      name: "spawn_worker",
+      description: "Start a worker the driver will drive. `profile` is the worker or another driver; `task` is what it should do. Reserves budget from the conserved pool and fails closed.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          profile: { description: "The worker/driver profile to run." },
+          task: { description: "The task the worker should perform." },
+          label: { type: "string", description: "Optional trace label." }
+        },
+        required: ["profile", "task"]
+      },
+      handler: (raw) => {
+        const a = obj(raw);
+        const agent = opts.makeWorkerAgent(a.profile);
+        const res = opts.scope.spawn(agent, a.task, {
+          budget: opts.perWorker,
+          label: typeof a.label === "string" ? a.label : "worker"
+        });
+        return Promise.resolve(res.ok ? { workerId: res.handle.id } : { error: res.reason });
+      }
+    },
+    {
+      name: "observe_worker",
+      description: "Inspect a worker status, spend, and settled output artifact when available.",
+      inputSchema: { type: "object", properties: { workerId: idArg }, required: ["workerId"] },
+      handler: async (raw) => {
+        const id = str(obj(raw).workerId, "workerId");
+        const node = opts.scope.view.nodes.find((n) => n.id === id);
+        if (!node) return { error: `unknown workerId ${JSON.stringify(id)}` };
+        const output = node.outRef ? await opts.blobs.get(node.outRef) : void 0;
+        return {
+          status: node.status,
+          spent: node.spent,
+          outRef: node.outRef ?? null,
+          output: output ?? null
+        };
+      }
+    },
+    {
+      name: "steer_worker",
+      description: "Deliver an out-of-band instruction to a running worker inbox.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          workerId: idArg,
+          instruction: { type: "string", description: "What the worker should do next." }
+        },
+        required: ["workerId", "instruction"]
+      },
+      handler: (raw) => {
+        const a = obj(raw);
+        const delivered = opts.scope.send(str(a.workerId, "workerId"), {
+          steer: str(a.instruction, "instruction")
+        });
+        return Promise.resolve({ delivered });
+      }
+    },
+    {
+      name: "await_next",
+      description: "Wait for the next spawned worker to settle. Returns { idle: true } when none are live.",
+      inputSchema: { type: "object", properties: {} },
+      handler: async () => {
+        const s = await opts.scope.next();
+        if (!s) return { idle: true };
+        const w = recordSettled(s);
+        return w.status === "done" ? {
+          settled: w.id,
+          status: "done",
+          score: w.score,
+          valid: w.valid,
+          outRef: w.outRef
+        } : { settled: w.id, status: "down", reason: w.reason };
+      }
+    },
+    {
+      name: "list_questions",
+      description: "List questions raised by workers, drivers, or analysts. Blocking stop behavior follows questionPolicy.",
+      inputSchema: { type: "object", properties: {} },
+      handler: () => Promise.resolve({ questions })
+    },
+    {
+      name: "answer_question",
+      description: "Record an answer, deferral, or escalation for a loop question.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          questionId: { type: "string" },
+          answer: { type: "string" },
+          by: { type: "string", description: 'Node id or "user".' },
+          deferReason: { type: "string" },
+          escalateTo: { type: "string", enum: ["parent", "user"] },
+          escalateReason: { type: "string" }
+        },
+        required: ["questionId"]
+      },
+      handler: (raw) => {
+        const a = obj(raw);
+        const questionId = str(a.questionId, "questionId");
+        if (typeof a.answer === "string" && a.answer.length > 0) {
+          return Promise.resolve({
+            question: decideQuestion(questionId, {
+              kind: "answer",
+              answer: a.answer,
+              by: typeof a.by === "string" && a.by.length > 0 ? a.by : "user"
+            })
+          });
+        }
+        if (typeof a.deferReason === "string" && a.deferReason.length > 0) {
+          return Promise.resolve({
+            question: decideQuestion(questionId, {
+              kind: "defer",
+              reason: a.deferReason
+            })
+          });
+        }
+        if (a.escalateTo === "parent" || a.escalateTo === "user") {
+          const escalateReason = typeof a.escalateReason === "string" && a.escalateReason.length > 0 ? a.escalateReason : "driver escalated";
+          return Promise.resolve({
+            question: decideQuestion(questionId, {
+              kind: "escalate",
+              to: a.escalateTo,
+              reason: escalateReason
+            })
+          });
+        }
+        throw new Error("answer_question: provide answer, deferReason, or escalateTo");
+      }
+    },
+    {
+      name: "ask_parent",
+      description: "Raise a question to the parent driver/Pi/user when this driver cannot decide.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          from: { type: "string" },
+          level: { type: "string", enum: ["worker", "driver", "loop"] },
+          question: { type: "string" },
+          reason: { type: "string" },
+          urgency: { type: "string", enum: ["continue-without", "blocks-step", "blocks-run"] }
+        },
+        required: ["from", "level", "question", "reason", "urgency"]
+      },
+      handler: async (raw) => {
+        const a = obj(raw);
+        const from = str(a.from, "from");
+        const q = await emitNewQuestion(
+          addQuestion(
+            {
+              from,
+              level: level(a.level),
+              question: str(a.question, "question"),
+              reason: str(a.reason, "reason"),
+              urgency: urgency(a.urgency)
+            },
+            from,
+            { kind: "escalate", to: "parent", reason: "asked parent" }
+          )
+        );
+        return { question: q };
+      }
+    },
+    {
+      name: "stop",
+      description: "Declare the run complete.",
+      inputSchema: {
+        type: "object",
+        properties: { reason: { type: "string", description: "Why you are stopping." } }
+      },
+      handler: (raw) => {
+        const blocking = blockingQuestionsForStop();
+        if (blocking.length) {
+          return Promise.resolve({
+            stopped: false,
+            error: "unresolved-blocking-questions",
+            questions: blocking
+          });
+        }
+        stopped = true;
+        const r = obj(raw).reason;
+        reason = typeof r === "string" ? r : void 0;
+        return Promise.resolve({ stopped: true });
+      }
+    }
+  ];
+  if (opts.analysts) {
+    tools.push({
+      name: "list_analysts",
+      description: "List trace-analyst lenses available to run over a settled worker.",
+      inputSchema: { type: "object", properties: {} },
+      handler: () => Promise.resolve({ analysts: opts.analysts?.kinds })
+    });
+    tools.push({
+      name: "run_analyst",
+      description: "Apply an analyst lens to a settled worker trace.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          kind: { type: "string", description: "The analyst kind id." },
+          workerId: idArg
+        },
+        required: ["kind", "workerId"]
+      },
+      handler: async (raw) => {
+        const a = obj(raw);
+        const id = str(a.workerId, "workerId");
+        const node = opts.scope.view.nodes.find((n) => n.id === id);
+        if (!node) return { error: `unknown workerId ${JSON.stringify(id)}` };
+        if (!node.outRef)
+          return { error: `worker ${JSON.stringify(id)} has not settled \u2014 no trace to analyze yet` };
+        const trace = await opts.blobs.get(node.outRef);
+        return { findings: await opts.analysts?.run(str(a.kind, "kind"), trace) };
+      }
+    });
+  }
+  return {
+    tools,
+    isStopped: () => stopped,
+    stopReason: () => reason,
+    settled: () => ledger,
+    questions: () => questions
+  };
+}
+
+// src/runtime/supervise/coordination-driver.ts
+function coordinationDriverAgent(opts) {
+  if (typeof opts.chat?.next !== "function") {
+    throw new ValidationError("coordinationDriverAgent: opts.chat.next must be a function");
+  }
+  const maxTurns = opts.maxTurns ?? 16;
+  return {
+    name: opts.name,
+    async act(task, scope) {
+      const coord = createCoordinationTools({
+        scope,
+        blobs: opts.blobs,
+        makeWorkerAgent: opts.makeWorkerAgent,
+        perWorker: opts.perWorker
+      });
+      const byName = new Map(coord.tools.map((t) => [t.name, t]));
+      const toolSpecs = coord.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema
+      }));
+      const system = typeof opts.systemPrompt === "function" ? opts.systemPrompt(task) : opts.systemPrompt;
+      const messages = [{ role: "user", content: stringifyTask(task) }];
+      for (let turn = 0; turn < maxTurns; turn += 1) {
+        if (coord.isStopped()) break;
+        const res = await opts.chat.next({ system, messages, tools: toolSpecs });
+        const calls = res.toolCalls ?? [];
+        if (calls.length === 0) {
+          return finalize2(coord, opts.blobs);
+        }
+        messages.push({ role: "assistant", content: res.content ?? "", toolCalls: calls });
+        for (const tc of calls) {
+          const tool = byName.get(tc.name);
+          const result = tool ? await runTool(tool, tc.arguments) : { error: `unknown tool: ${tc.name}` };
+          messages.push({
+            role: "tool",
+            ...tc.id ? { toolCallId: tc.id } : {},
+            name: tc.name,
+            content: safeJson(result)
+          });
+        }
+      }
+      return finalize2(coord, opts.blobs);
+    }
+  };
+}
+async function runTool(tool, args) {
+  try {
+    return await tool.handler(args);
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : String(e) };
+  }
+}
+async function finalize2(coord, blobs) {
+  const delivered = coord.settled().filter((w) => w.status === "done" && w.valid === true);
+  if (delivered.length === 0) return void 0;
+  let best = delivered[0];
+  for (const w of delivered) if ((w.score ?? 0) > (best.score ?? 0)) best = w;
+  return best.outRef ? await blobs.get(best.outRef) : void 0;
+}
+function stringifyTask(task) {
+  return typeof task === "string" ? task : safeJson(task);
+}
+function safeJson(v) {
+  try {
+    return JSON.stringify(v) ?? String(v);
+  } catch {
+    return String(v);
+  }
+}
+
+// src/runtime/supervise/coordination-mcp.ts
+import { createServer } from "http";
+
+// src/mcp/server.ts
+import { createInterface } from "readline";
+import { Readable, Writable } from "stream";
+
+// src/mcp/feedback-store.ts
+var InMemoryFeedbackStore = class {
+  events = [];
+  async put(event) {
+    this.events.push({ ...event });
+  }
+  async list(filter = {}) {
+    let out = this.events;
+    if (filter.namespace !== void 0) {
+      out = out.filter((event) => event.namespace === filter.namespace);
+    }
+    if (filter.refersToRef !== void 0) {
+      out = out.filter((event) => event.refersTo.ref === filter.refersToRef);
+    }
+    return out.map((event) => ({ ...event }));
+  }
+};
+function eventToSnapshot(event) {
+  const snap = {
+    id: event.id,
+    score: event.rating.score,
+    by: event.by,
+    notes: event.rating.notes,
+    capturedAt: event.capturedAt
+  };
+  if (event.rating.label) snap.label = event.rating.label;
+  return snap;
+}
+
+// src/mcp/delegation-store.ts
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname } from "path";
+var DelegationStateCorruptError = class extends AgentEvalError {
+  constructor(message, options) {
+    super("validation", message, options);
+  }
+};
+var DelegationPersistenceError = class extends AgentEvalError {
+  constructor(message, options) {
+    super("config", message, options);
+  }
+};
+var InMemoryDelegationStore = class {
+  records = /* @__PURE__ */ new Map();
+  async loadAll() {
+    return [...this.records.values()].map(cloneRecord);
+  }
+  async upsert(record) {
+    this.records.set(record.taskId, cloneRecord(record));
+  }
+  async lookupIdempotencyKey(key) {
+    for (const record of this.records.values()) {
+      if (record.idempotencyKey === key) return record.taskId;
+    }
+    return void 0;
+  }
+  async remove(taskIds) {
+    for (const taskId of taskIds) this.records.delete(taskId);
+  }
+};
+var STATE_FORMAT_VERSION = 1;
+var FileDelegationStore = class {
+  filePath;
+  recoverCorrupt;
+  records = /* @__PURE__ */ new Map();
+  loaded = false;
+  writeTail = Promise.resolve();
+  tmpSeq = 0;
+  constructor(options) {
+    this.filePath = options.filePath;
+    this.recoverCorrupt = options.recoverCorrupt ?? false;
+  }
+  async loadAll() {
+    let raw;
+    try {
+      raw = await readFile(this.filePath, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        this.loaded = true;
+        return [];
+      }
+      throw new DelegationPersistenceError(
+        `FileDelegationStore: failed to read ${this.filePath}: ${errorMessage2(err)}`,
+        { cause: err }
+      );
+    }
+    let state;
+    try {
+      state = parsePersistedState(raw);
+    } catch (err) {
+      if (!this.recoverCorrupt) {
+        throw new DelegationStateCorruptError(
+          `FileDelegationStore: state file ${this.filePath} is corrupt (${errorMessage2(err)}). Repair or archive the file, or opt into automatic recovery (recoverCorrupt / AGENT_RUNTIME_DELEGATION_STATE_RECOVER=1) to archive it and start empty.`,
+          { cause: err }
+        );
+      }
+      const archivePath = `${this.filePath}.corrupt-${Date.now()}`;
+      await rename(this.filePath, archivePath);
+      this.loaded = true;
+      return [];
+    }
+    this.records.clear();
+    for (const record of state.records) this.records.set(record.taskId, record);
+    this.loaded = true;
+    return [...this.records.values()].map(cloneRecord);
+  }
+  async upsert(record) {
+    this.assertLoaded("upsert");
+    this.records.set(record.taskId, cloneRecord(record));
+    await this.enqueueWrite();
+  }
+  async lookupIdempotencyKey(key) {
+    this.assertLoaded("lookupIdempotencyKey");
+    for (const record of this.records.values()) {
+      if (record.idempotencyKey === key) return record.taskId;
+    }
+    return void 0;
+  }
+  async remove(taskIds) {
+    this.assertLoaded("remove");
+    let changed = false;
+    for (const taskId of taskIds) {
+      if (this.records.delete(taskId)) changed = true;
+    }
+    if (changed) await this.enqueueWrite();
+  }
+  assertLoaded(op) {
+    if (this.loaded) return;
+    throw new DelegationPersistenceError(
+      `FileDelegationStore: ${op} called before loadAll() \u2014 the on-disk state has not been read yet`
+    );
+  }
+  enqueueWrite() {
+    const write = this.writeTail.then(() => this.writeSnapshot());
+    this.writeTail = write.catch(() => {
+    });
+    return write;
+  }
+  async writeSnapshot() {
+    const state = {
+      version: STATE_FORMAT_VERSION,
+      records: [...this.records.values()]
+    };
+    const payload = `${JSON.stringify(state)}
+`;
+    this.tmpSeq += 1;
+    const tmpPath = `${this.filePath}.tmp-${process.pid}-${this.tmpSeq}`;
+    try {
+      await mkdir(dirname(this.filePath), { recursive: true });
+      await writeFile(tmpPath, payload, "utf8");
+      await rename(tmpPath, this.filePath);
+    } catch (err) {
+      throw new DelegationPersistenceError(
+        `FileDelegationStore: failed to write ${this.filePath}: ${errorMessage2(err)}`,
+        { cause: err }
+      );
+    }
+  }
+};
+function parsePersistedState(raw) {
+  const parsed = JSON.parse(raw);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("top-level value is not an object");
+  }
+  const state = parsed;
+  if (state.version !== STATE_FORMAT_VERSION) {
+    throw new Error(`unsupported state version ${JSON.stringify(state.version)}`);
+  }
+  if (!Array.isArray(state.records)) {
+    throw new Error("`records` is not an array");
+  }
+  for (const record of state.records) {
+    if (record === null || typeof record !== "object") {
+      throw new Error("a record entry is not an object");
+    }
+    const candidate = record;
+    if (typeof candidate.taskId !== "string" || typeof candidate.status !== "string") {
+      throw new Error("a record entry is missing `taskId`/`status`");
+    }
+  }
+  return { version: STATE_FORMAT_VERSION, records: state.records };
+}
+function cloneRecord(record) {
+  return structuredClone(record);
+}
+function errorMessage2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/mcp/delegation-trace.ts
+var DELEGATION_TRACE_MAX_SPANS = 512;
+var DELEGATION_TRACE_MAX_BYTES = 256 * 1024;
+function buildDelegationTraceSpans(events) {
+  return buildLoopSpanNodes(events).map((node) => ({
+    spanId: node.spanId,
+    ...node.parentSpanId !== void 0 ? { parentSpanId: node.parentSpanId } : {},
+    name: node.name,
+    kind: node.kind,
+    startMs: node.startMs,
+    endMs: node.endMs,
+    ...Object.keys(node.attrs).length > 0 ? { meta: node.attrs } : {}
+  }));
+}
+function capDelegationTrace(spans, caps) {
+  const maxSpans = caps?.maxSpans ?? DELEGATION_TRACE_MAX_SPANS;
+  const maxBytes = caps?.maxBytes ?? DELEGATION_TRACE_MAX_BYTES;
+  let start = Math.max(0, spans.length - maxSpans);
+  const sizes = spans.map((span) => JSON.stringify(span).length + 1);
+  let total = 0;
+  for (let i = start; i < sizes.length; i += 1) total += sizes[i];
+  while (start < spans.length - 1 && total > maxBytes) {
+    total -= sizes[start];
+    start += 1;
+  }
+  return { trace: spans.slice(start), truncated: start > 0 };
+}
+function createDelegationTraceCollector(onSpans) {
+  const buffers = /* @__PURE__ */ new Map();
+  const flush = (events) => {
+    const spans = buildDelegationTraceSpans(events);
+    if (spans.length > 0) onSpans(spans);
+  };
+  return {
+    emitter: {
+      emit(event) {
+        const buf = buffers.get(event.runId);
+        if (buf) buf.push(event);
+        else buffers.set(event.runId, [event]);
+        if (event.kind === "loop.ended") {
+          const events = buffers.get(event.runId) ?? [event];
+          buffers.delete(event.runId);
+          flush(events);
+        }
+      }
+    },
+    settle() {
+      for (const events of buffers.values()) flush(events);
+      buffers.clear();
+    }
+  };
+}
+function generateDelegationSpanId() {
+  const bytes = new Uint8Array(8);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 8; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function composeLoopTraceEmitters(...emitters) {
+  const live = emitters.filter((e) => e !== void 0);
+  if (live.length === 0) return void 0;
+  if (live.length === 1) return live[0];
+  return {
+    emit(event) {
+      const pending = [];
+      for (const emitter of live) {
+        const result = emitter.emit(event);
+        if (result) pending.push(result);
+      }
+      if (pending.length > 0) return Promise.all(pending).then(() => void 0);
+    }
+  };
+}
+
+// src/mcp/task-queue.ts
+var DelegationTaskQueue = class _DelegationTaskQueue {
+  records = /* @__PURE__ */ new Map();
+  controllers = /* @__PURE__ */ new Map();
+  byIdempotencyKey = /* @__PURE__ */ new Map();
+  generateId;
+  now;
+  store;
+  resumeDelegate;
+  maxTerminalRecords;
+  onPersistError;
+  traceContext;
+  persistTail = Promise.resolve();
+  persistFailure;
+  constructor(options = {}) {
+    this.generateId = options.generateId ?? randomTaskId;
+    this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    this.store = options.store ?? new InMemoryDelegationStore();
+    this.resumeDelegate = options.resumeDelegate;
+    if (options.maxTerminalRecords !== void 0) {
+      if (!Number.isInteger(options.maxTerminalRecords) || options.maxTerminalRecords < 1) {
+        throw new ValidationError(
+          `DelegationTaskQueue: maxTerminalRecords must be a positive integer, got ${String(options.maxTerminalRecords)}`
+        );
+      }
+    }
+    this.maxTerminalRecords = options.maxTerminalRecords ?? Number.POSITIVE_INFINITY;
+    this.traceContext = options.traceContext;
+    this.onPersistError = options.onPersistError ?? ((error) => {
+      queueMicrotask(() => {
+        throw error;
+      });
+    });
+  }
+  /**
+   * Construct a queue from previously-persisted state. Loads every record
+   * from `options.store`, rebuilds the idempotency index (so a re-submitted
+   * identical task returns the prior taskId and its terminal state), then:
+   *
+   *   - terminal records stay queryable via `status()` / `history()`
+   *   - in-flight records with a `detachedSessionRef` re-attach through
+   *     `options.resumeDelegate` and report `running`
+   *   - other in-flight records settle as failed — their driver died with
+   *     the previous process and the result is unrecoverable
+   *
+   * The retention cap applies to the loaded set as well.
+   */
+  static async restore(options = {}) {
+    const queue = new _DelegationTaskQueue(options);
+    const loaded = await queue.store.loadAll();
+    queue.rehydrate(loaded);
+    return queue;
+  }
+  /**
+   * Kick off a delegation in the background. Returns immediately. The
+   * `taskId` is queryable via `status` once this method returns. Throws
+   * the recorded `DelegationPersistenceError` once the store has failed —
+   * the queue does not accept work it cannot journal.
+   */
+  submit(input) {
+    if (this.persistFailure) throw this.persistFailure;
+    if (input.idempotencyKey) {
+      const existing = this.byIdempotencyKey.get(input.idempotencyKey);
+      if (existing && this.records.has(existing)) {
+        return { taskId: existing, reused: true };
+      }
+    }
+    const taskId = this.generateId();
+    const controller = new AbortController();
+    const record = {
+      taskId,
+      profile: input.profile,
+      namespace: input.namespace,
+      args: input.args,
+      status: "pending",
+      startedAt: this.now(),
+      feedback: [],
+      idempotencyKey: input.idempotencyKey,
+      detachedSessionRef: input.detachedSessionRef,
+      ...this.traceContext !== void 0 ? {
+        traceId: this.traceContext.traceId,
+        ...this.traceContext.parentSpanId !== void 0 ? { parentSpanId: this.traceContext.parentSpanId } : {}
+      } : {}
+    };
+    this.records.set(taskId, record);
+    this.controllers.set(taskId, controller);
+    if (input.idempotencyKey) this.byIdempotencyKey.set(input.idempotencyKey, taskId);
+    this.persist(record);
+    queueMicrotask(() => {
+      this.execute(taskId, input, controller);
+    });
+    return { taskId, reused: false };
+  }
+  /**
+   * Snapshot the current state of a delegation. Returns `undefined` for
+   * unknown ids so callers can distinguish missing from terminal.
+   * `includeTrace` attaches the journaled loop-trace span tree — off by
+   * default so status polls stay light.
+   */
+  status(taskId, opts) {
+    const record = this.records.get(taskId);
+    if (!record) return void 0;
+    return toStatusResult(record, opts);
+  }
+  /**
+   * Abort an in-flight delegation. Returns `false` if the task is unknown
+   * or already terminal. The underlying `run` function MUST honor the
+   * abort signal for the cancel to take effect; the queue marks the
+   * record `cancelled` regardless so a misbehaving runner cannot pin the
+   * UI on `running` forever.
+   */
+  cancel(taskId) {
+    const record = this.records.get(taskId);
+    if (!record) return false;
+    if (isTerminal(record.status)) return false;
+    const controller = this.controllers.get(taskId);
+    controller?.abort();
+    record.status = "cancelled";
+    record.completedAt = this.now();
+    record.error = { message: "cancelled by caller", kind: "CancelledError" };
+    this.persist(record);
+    this.enforceRetention();
+    return true;
+  }
+  /**
+   * Append a feedback event to the matching delegation. Returns `false`
+   * when `ref` does not name a known taskId — the caller should still
+   * record the feedback through a different surface (artifact/outcome
+   * kinds are not queue-bound).
+   */
+  attachFeedback(taskId, snapshot) {
+    const record = this.records.get(taskId);
+    if (!record) return false;
+    record.feedback.push(snapshot);
+    this.persist(record);
+    return true;
+  }
+  /**
+   * Query the recorded delegations. Returns entries newest-first (by
+   * `startedAt`), truncated to `limit`.
+   */
+  history(args = {}) {
+    const limit = clampLimit(args.limit);
+    const since = args.since ? Date.parse(args.since) : Number.NEGATIVE_INFINITY;
+    const out = [];
+    for (const record of this.records.values()) {
+      if (args.namespace && record.namespace !== args.namespace) continue;
+      if (args.profile && record.profile !== args.profile) continue;
+      if (Number.isFinite(since) && Date.parse(record.startedAt) < since) continue;
+      out.push(toHistoryEntry(record));
+    }
+    out.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    return out.slice(0, limit);
+  }
+  /**
+   * Await every journal write issued so far. Rejects with the recorded
+   * `DelegationPersistenceError` when any of them failed. Call before
+   * handing the store's backing file to another process.
+   */
+  async flush() {
+    await this.persistTail;
+    if (this.persistFailure) throw this.persistFailure;
+  }
+  /** Test-only — number of in-flight (non-terminal) records. */
+  inflightCount() {
+    let n = 0;
+    for (const record of this.records.values()) {
+      if (!isTerminal(record.status)) n += 1;
+    }
+    return n;
+  }
+  async execute(taskId, input, controller) {
+    const record = this.records.get(taskId);
+    if (!record) return;
+    record.status = "running";
+    this.persist(record);
+    const traceCollector = createDelegationTraceCollector((spans) => {
+      if (isTerminal(currentStatus(record))) return;
+      this.appendTrace(record, spans);
+      this.persist(record);
+    });
+    try {
+      const output = await input.run({
+        signal: controller.signal,
+        report: (progress) => {
+          if (record.status === "running") {
+            record.progress = progress;
+            this.persist(record);
+          }
+        },
+        traceEmitter: traceCollector.emitter,
+        ...record.detachedSessionRef !== void 0 ? { detachedSessionRef: record.detachedSessionRef } : {},
+        updateDetachedSessionRef: (ref) => {
+          if (typeof ref !== "string" || ref.length === 0) {
+            throw new ValidationError(
+              "DelegationTaskQueue: updateDetachedSessionRef requires a non-empty ref"
+            );
+          }
+          if (isTerminal(currentStatus(record))) return;
+          record.detachedSessionRef = ref;
+          this.persist(record);
+        }
+      });
+      traceCollector.settle();
+      if (currentStatus(record) === "cancelled") return;
+      record.status = "completed";
+      record.completedAt = this.now();
+      record.result = { profile: input.profile, output };
+      this.persist(record);
+      this.enforceRetention();
+    } catch (err) {
+      traceCollector.settle();
+      if (currentStatus(record) === "cancelled") return;
+      record.status = "failed";
+      record.completedAt = this.now();
+      record.error = errorToShape(err);
+      this.persist(record);
+      this.enforceRetention();
+    } finally {
+      this.controllers.delete(taskId);
+    }
+  }
+  appendTrace(record, spans) {
+    if (spans.length === 0) return;
+    const { trace, truncated } = capDelegationTrace([...record.trace ?? [], ...spans]);
+    record.trace = trace;
+    if (truncated) record.traceTruncated = true;
+  }
+  rehydrate(loaded) {
+    const records = [...loaded].sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+    for (const record of records) {
+      this.records.set(record.taskId, record);
+      if (record.idempotencyKey) this.byIdempotencyKey.set(record.idempotencyKey, record.taskId);
+    }
+    for (const record of this.records.values()) {
+      if (isTerminal(record.status)) continue;
+      if (record.detachedSessionRef && this.resumeDelegate) {
+        record.status = "running";
+        this.persist(record);
+        this.startResume(record, record.detachedSessionRef, this.resumeDelegate);
+        continue;
+      }
+      record.status = "failed";
+      record.completedAt = this.now();
+      record.error = {
+        message: record.detachedSessionRef ? `delegation driver restarted while the task was in flight; detached session "${record.detachedSessionRef}" needs a resumeDelegate to be resumed` : "delegation driver restarted while the task was in flight; the run was not detached and cannot be resumed",
+        kind: "DriverRestartError"
+      };
+      this.persist(record);
+    }
+    this.enforceRetention();
+  }
+  startResume(record, detachedSessionRef, driver) {
+    const controller = new AbortController();
+    this.controllers.set(record.taskId, controller);
+    void this.driveResume(record, detachedSessionRef, driver, controller);
+  }
+  async driveResume(record, detachedSessionRef, driver, controller) {
+    const intervalMs = driver.intervalMs ?? 5e3;
+    const resumeStartMs = Date.parse(this.now());
+    const ctx = {
+      signal: controller.signal,
+      report: (progress) => {
+        if (currentStatus(record) !== "running") return;
+        record.progress = progress;
+        this.persist(record);
+      }
+    };
+    try {
+      while (!controller.signal.aborted && currentStatus(record) === "running") {
+        const tick = await driver.tick({ record: structuredClone(record), detachedSessionRef }, ctx);
+        if (currentStatus(record) === "cancelled") return;
+        if (tick.state === "completed") {
+          this.appendResumeSpan(record, detachedSessionRef, resumeStartMs);
+          record.status = "completed";
+          record.completedAt = this.now();
+          record.result = {
+            profile: record.profile,
+            output: tick.output
+          };
+          if (tick.costUsd !== void 0) record.costUsd = tick.costUsd;
+          this.persist(record);
+          this.enforceRetention();
+          return;
+        }
+        if (tick.state === "failed") {
+          this.appendResumeSpan(record, detachedSessionRef, resumeStartMs, tick.error.message);
+          record.status = "failed";
+          record.completedAt = this.now();
+          record.error = tick.error;
+          this.persist(record);
+          this.enforceRetention();
+          return;
+        }
+        await abortableDelay(intervalMs, controller.signal);
+      }
+    } catch (err) {
+      if (currentStatus(record) === "cancelled") return;
+      this.appendResumeSpan(record, detachedSessionRef, resumeStartMs, errorToShape(err).message);
+      record.status = "failed";
+      record.completedAt = this.now();
+      record.error = errorToShape(err);
+      this.persist(record);
+      this.enforceRetention();
+    } finally {
+      this.controllers.delete(record.taskId);
+    }
+  }
+  /**
+   * Journal the resumed segment of a detached run as one compact span. The
+   * resume driver re-attaches after a process restart, so the original
+   * process's loop events are gone — this span records the post-restart
+   * observation window (re-attach → terminal tick) under the
+   * `'detached-resume'` driver tag, keeping restored delegations observable
+   * in the journal alongside trace-carrying live runs.
+   */
+  appendResumeSpan(record, detachedSessionRef, startMs, error) {
+    this.appendTrace(record, [
+      {
+        spanId: generateDelegationSpanId(),
+        name: "loop",
+        kind: "loop",
+        startMs,
+        endMs: Date.parse(this.now()),
+        meta: {
+          "tangle.loop.driver": "detached-resume",
+          "tangle.loop.detached_session_ref": detachedSessionRef,
+          ...error !== void 0 ? { "tangle.loop.error": error } : {}
+        }
+      }
+    ]);
+  }
+  persist(record) {
+    if (this.persistFailure) return;
+    const snapshot = structuredClone(record);
+    this.persistTail = this.persistTail.then(async () => {
+      if (this.persistFailure) return;
+      try {
+        await this.store.upsert(snapshot);
+      } catch (err) {
+        this.failPersistence(err);
+      }
+    });
+  }
+  persistRemoval(taskIds) {
+    if (this.persistFailure || taskIds.length === 0) return;
+    this.persistTail = this.persistTail.then(async () => {
+      if (this.persistFailure) return;
+      try {
+        await this.store.remove(taskIds);
+      } catch (err) {
+        this.failPersistence(err);
+      }
+    });
+  }
+  failPersistence(cause) {
+    if (this.persistFailure) return;
+    const error = cause instanceof DelegationPersistenceError ? cause : new DelegationPersistenceError(
+      `DelegationTaskQueue: store write failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+      { cause }
+    );
+    this.persistFailure = error;
+    this.onPersistError(error);
+  }
+  enforceRetention() {
+    if (!Number.isFinite(this.maxTerminalRecords)) return;
+    const terminal = [];
+    for (const record of this.records.values()) {
+      if (isTerminal(record.status)) terminal.push(record);
+    }
+    const excess = terminal.length - this.maxTerminalRecords;
+    if (excess <= 0) return;
+    terminal.sort(
+      (a, b) => (a.completedAt ?? a.startedAt).localeCompare(b.completedAt ?? b.startedAt)
+    );
+    const evicted = terminal.slice(0, excess);
+    for (const record of evicted) {
+      this.records.delete(record.taskId);
+      if (record.idempotencyKey && this.byIdempotencyKey.get(record.idempotencyKey) === record.taskId) {
+        this.byIdempotencyKey.delete(record.idempotencyKey);
+      }
+    }
+    this.persistRemoval(evicted.map((record) => record.taskId));
+  }
+};
+function isTerminal(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+function currentStatus(record) {
+  return record.status;
+}
+function clampLimit(raw) {
+  if (!Number.isFinite(raw)) return 50;
+  const n = Math.trunc(raw);
+  if (n <= 0) return 50;
+  return Math.min(n, 500);
+}
+function abortableDelay(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function toStatusResult(record, opts) {
+  const out = {
+    taskId: record.taskId,
+    profile: record.profile,
+    status: record.status,
+    startedAt: record.startedAt
+  };
+  if (record.progress) out.progress = record.progress;
+  if (record.result) out.result = record.result;
+  if (record.error) out.error = record.error;
+  if (record.costUsd !== void 0) out.costUsd = record.costUsd;
+  if (record.completedAt) out.completedAt = record.completedAt;
+  if (record.traceId !== void 0) out.traceId = record.traceId;
+  if (record.parentSpanId !== void 0) out.parentSpanId = record.parentSpanId;
+  if (opts?.includeTrace === true && record.trace && record.trace.length > 0) {
+    out.trace = record.trace.map((span) => ({ ...span }));
+    if (record.traceTruncated) out.traceTruncated = true;
+  }
+  return out;
+}
+function toHistoryEntry(record) {
+  const entry = {
+    taskId: record.taskId,
+    profile: record.profile,
+    args: record.args,
+    status: record.status,
+    startedAt: record.startedAt,
+    hasTrace: record.trace !== void 0 && record.trace.length > 0
+  };
+  if (record.namespace) entry.namespace = record.namespace;
+  if (record.completedAt) entry.completedAt = record.completedAt;
+  if (record.costUsd !== void 0) entry.costUsd = record.costUsd;
+  if (record.feedback.length > 0) entry.feedback = [...record.feedback];
+  if (record.traceId !== void 0) entry.traceId = record.traceId;
+  return entry;
+}
+function errorToShape(err) {
+  if (err instanceof Error) {
+    return { message: err.message, kind: err.name || "Error" };
+  }
+  return { message: String(err), kind: "NonError" };
+}
+function randomTaskId() {
+  const t = Date.now().toString(36);
+  const r = Math.random().toString(36).slice(2, 10);
+  return `dlg-${t}-${r}`;
+}
+function hashIdempotencyInput(value) {
+  let str;
+  try {
+    str = JSON.stringify(canonicalize(value));
+  } catch {
+    str = String(value);
+  }
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i += 1) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function canonicalize(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(canonicalize);
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a.localeCompare(b));
+  const out = {};
+  for (const [k, v] of entries) out[k] = canonicalize(v);
+  return out;
+}
+
+// src/mcp/detached-turn.ts
+var DEFAULT_TICK_INTERVAL_MS = 5e3;
+function formatDetachedSessionRef(parts) {
+  assertRefComponent("sessionId", parts.sessionId);
+  if (parts.sandboxId === void 0) return `session=${parts.sessionId}`;
+  assertRefComponent("sandboxId", parts.sandboxId);
+  return `sandbox=${parts.sandboxId};session=${parts.sessionId}`;
+}
+function parseDetachedSessionRef(raw) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const pair of raw.split(";")) {
+    const eq = pair.indexOf("=");
+    const key = eq === -1 ? "" : pair.slice(0, eq);
+    const value = eq === -1 ? "" : pair.slice(eq + 1);
+    if (key !== "session" && key !== "sandbox" || value.length === 0 || fields.has(key)) {
+      throw new ValidationError(
+        `parseDetachedSessionRef: malformed detachedSessionRef ${JSON.stringify(raw)} \u2014 expected "session=<id>" or "sandbox=<id>;session=<id>"`
+      );
+    }
+    fields.set(key, value);
+  }
+  const sessionId = fields.get("session");
+  if (!sessionId) {
+    throw new ValidationError(
+      `parseDetachedSessionRef: detachedSessionRef ${JSON.stringify(raw)} carries no session id`
+    );
+  }
+  const sandboxId = fields.get("sandbox");
+  return { sessionId, ...sandboxId !== void 0 ? { sandboxId } : {} };
+}
+function assertRefComponent(name, value) {
+  if (value.length === 0 || value.includes(";") || value.includes("=")) {
+    throw new ValidationError(
+      `formatDetachedSessionRef: ${name} ${JSON.stringify(value)} must be non-empty and free of ";" / "="`
+    );
+  }
+}
+function detachedTurnEvents(sessionId, turn) {
+  return [
+    {
+      type: "result",
+      id: sessionId,
+      data: {
+        text: turn.text,
+        finalText: turn.text,
+        success: true,
+        result: turn.result
+      }
+    }
+  ];
+}
+async function runDetachedTurn(options) {
+  const intervalMs = options.tickIntervalMs ?? DEFAULT_TICK_INTERVAL_MS;
+  const trace = createDetachedTurnTrace(options);
+  trace.started();
+  const box = await createSandboxForSpec(options.client, options.spec, options.signal).catch(
+    (err) => {
+      trace.ended(err instanceof Error ? err.message : String(err));
+      throw err;
+    }
+  );
+  const drive = box;
+  const onAbort = () => {
+    void drive._sessionCancel?.(options.sessionId).catch(() => {
+    });
+  };
+  try {
+    if (typeof drive.driveTurn !== "function") {
+      throw new ValidationError(
+        "runDetachedTurn: the acquired sandbox exposes no driveTurn(message, { sessionId }) \u2014 detached dispatch requires @tangle-network/sandbox >= 0.6 and a session-backed placement (sibling/fleet); disable detached dispatch for this executor."
+      );
+    }
+    const sandboxId = box.id;
+    if (typeof sandboxId !== "string" || sandboxId.length === 0) {
+      throw new ValidationError(
+        "runDetachedTurn: the acquired sandbox carries no id \u2014 without it the detached run cannot be resumed after a restart, so refusing to dispatch detached."
+      );
+    }
+    options.bindSandbox(sandboxId);
+    trace.dispatched(sandboxId);
+    options.signal.addEventListener("abort", onAbort, { once: true });
+    for (; ; ) {
+      throwIfAborted(options.signal);
+      const tick = await drive.driveTurn(options.prompt, {
+        sessionId: options.sessionId,
+        turnId: options.sessionId,
+        ...options.wallCapMs !== void 0 ? { wallCapMs: options.wallCapMs } : {}
+      });
+      throwIfAborted(options.signal);
+      if (tick.state === "completed") {
+        trace.ended();
+        return { text: tick.text, result: tick.result };
+      }
+      if (tick.state === "failed") {
+        throw new Error(`detached turn ${options.sessionId} failed: ${tick.error}`);
+      }
+      options.report({ iteration: 0, phase: detachedRunningPhase(tick.elapsedMs) });
+      await sleep(intervalMs, options.signal);
+    }
+  } catch (err) {
+    trace.ended(err instanceof Error ? err.message : String(err));
+    throw err;
+  } finally {
+    options.signal.removeEventListener("abort", onAbort);
+    if (options.signal.aborted) onAbort();
+    await deleteBoxSafe(box);
+  }
+}
+function createDetachedTurnTrace(options) {
+  const emitter = options.traceEmitter;
+  if (!emitter) {
+    return { started() {
+    }, dispatched() {
+    }, ended() {
+    } };
+  }
+  const runId = options.sessionId;
+  const agentRunName = options.spec.name ?? options.spec.profile.name ?? "detached-turn";
+  const startMs = Date.now();
+  let done = false;
+  const emit = (event) => {
+    void emitter.emit(event);
+  };
+  return {
+    started() {
+      emit({
+        kind: "loop.started",
+        runId,
+        timestamp: startMs,
+        payload: {
+          driver: "detached-turn",
+          agentRunNames: [agentRunName],
+          maxIterations: 1,
+          maxConcurrency: 1
+        }
+      });
+      emit({
+        kind: "loop.iteration.started",
+        runId,
+        timestamp: startMs,
+        payload: { iterationIndex: 0, agentRunName, taskHash: options.sessionId }
+      });
+    },
+    dispatched(sandboxId) {
+      emit({
+        kind: "loop.iteration.dispatch",
+        runId,
+        timestamp: Date.now(),
+        payload: {
+          iterationIndex: 0,
+          agentRunName,
+          placement: options.placement ?? "sibling",
+          sandboxId
+        }
+      });
+    },
+    ended(error) {
+      if (done) return;
+      done = true;
+      const endMs = Date.now();
+      emit({
+        kind: "loop.iteration.ended",
+        runId,
+        timestamp: endMs,
+        payload: {
+          iterationIndex: 0,
+          agentRunName,
+          costUsd: 0,
+          durationMs: endMs - startMs,
+          ...error !== void 0 ? { error } : {}
+        }
+      });
+      emit({
+        kind: "loop.ended",
+        runId,
+        timestamp: endMs,
+        payload: {
+          ...error === void 0 ? { winnerIterationIndex: 0 } : {},
+          totalCostUsd: 0,
+          durationMs: endMs - startMs,
+          iterations: 1
+        }
+      });
+    }
+  };
+}
+function detachedRunningPhase(elapsedMs) {
+  return elapsedMs === void 0 ? "detached-running" : `detached-running ${Math.round(elapsedMs / 1e3)}s`;
+}
+function createDriveTurnResumeDriver(options) {
+  const cancelHooked = /* @__PURE__ */ new Set();
+  return {
+    intervalMs: options.intervalMs ?? DEFAULT_TICK_INTERVAL_MS,
+    async tick({ record, detachedSessionRef }, ctx) {
+      const ref = parseDetachedSessionRef(detachedSessionRef);
+      if (ref.sandboxId === void 0) {
+        return {
+          state: "failed",
+          error: {
+            message: `detached session "${ref.sessionId}" was never bound to a sandbox \u2014 the previous process died before the box was acquired, so the turn was never dispatched and cannot be resumed`,
+            kind: "DetachedSessionUnboundError"
+          }
+        };
+      }
+      const box = await options.resolveSandbox(ref.sandboxId);
+      if (!cancelHooked.has(record.taskId)) {
+        cancelHooked.add(record.taskId);
+        ctx.signal.addEventListener(
+          "abort",
+          () => {
+            void box._sessionCancel?.(ref.sessionId).catch(() => {
+            });
+          },
+          { once: true }
+        );
+      }
+      if (ctx.signal.aborted) throwAbort();
+      const tick = await box.driveTurn(options.buildMessage(record), {
+        sessionId: ref.sessionId,
+        turnId: ref.sessionId,
+        ...options.wallCapMs !== void 0 ? { wallCapMs: options.wallCapMs } : {}
+      });
+      if (tick.state === "completed") {
+        const output = await options.settleOutput(
+          { text: tick.text, result: tick.result },
+          record,
+          {
+            signal: ctx.signal
+          }
+        );
+        return { state: "completed", output };
+      }
+      if (tick.state === "failed") {
+        return {
+          state: "failed",
+          error: {
+            message: `detached turn ${ref.sessionId} failed: ${tick.error}`,
+            kind: "DetachedTurnFailedError"
+          }
+        };
+      }
+      ctx.report({ iteration: 0, phase: detachedRunningPhase(tick.elapsedMs) });
+      return { state: "running" };
+    }
+  };
+}
+
+// src/mcp/tools/delegate-code.ts
+var DELEGATE_CODE_TOOL_NAME = "delegate_code";
+var DELEGATE_CODE_DESCRIPTION = [
+  "Delegate a coding task to specialist coder agents that produce a validated patch.",
+  "",
+  "Use when: you need code written, fixed, refactored, or extended to satisfy a",
+  "user goal that touches a real repository. The coder runs in an isolated",
+  "sandbox, opens a fresh branch, keeps the diff minimal, runs the supplied",
+  "test + typecheck commands, and emits a unified-diff patch.",
+  "",
+  "Returns immediately with a taskId. Poll delegation_status to retrieve the",
+  "patch + validator verdict (typically minutes-to-hours, longer for large",
+  "changes). Identical inputs return the same taskId \u2014 safe to retry.",
+  "",
+  "When variants > 1, multiple coder harnesses (claude-code, codex, opencode)",
+  "attempt the task in parallel and the highest-scoring patch wins (smallest",
+  "passing diff). Use variants for high-stakes changes; single variant for",
+  "routine ones.",
+  "",
+  "Capability scope: the coder cannot modify paths outside repoRoot and cannot",
+  "touch paths in config.forbiddenPaths. The validator hard-fails on a",
+  "forbidden-path violation, diff above config.maxDiffLines, test failure, or",
+  "typecheck failure \u2014 none of those make it past the gate."
+].join("\n");
+var DELEGATE_CODE_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    goal: {
+      type: "string",
+      description: "Natural-language description of what the coder must accomplish."
+    },
+    repoRoot: {
+      type: "string",
+      description: "Absolute path inside the sandbox where the repo lives."
+    },
+    contextHint: {
+      type: "string",
+      description: "Optional free-form context the coder sees in the prompt prelude."
+    },
+    variants: {
+      type: "integer",
+      minimum: 1,
+      maximum: 8,
+      description: "Number of parallel coder harnesses. Default 1."
+    },
+    config: {
+      type: "object",
+      properties: {
+        testCmd: { type: "string" },
+        typecheckCmd: { type: "string" },
+        forbiddenPaths: { type: "array", items: { type: "string" } },
+        maxDiffLines: { type: "integer", minimum: 1 }
+      },
+      additionalProperties: false
+    },
+    namespace: {
+      type: "string",
+      description: "Multi-tenant scope (customer-id, workspace-id)."
+    }
+  },
+  required: ["goal", "repoRoot"],
+  additionalProperties: false
+};
+var SINGLE_VARIANT_ESTIMATE_MS = 6 * 60 * 1e3;
+var FANOUT_PER_VARIANT_ESTIMATE_MS = 8 * 60 * 1e3;
+function validateDelegateCodeArgs(raw) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError("delegate_code: arguments must be an object");
+  }
+  const value = raw;
+  const goal = value.goal;
+  if (typeof goal !== "string" || goal.trim().length === 0) {
+    throw new TypeError("delegate_code: `goal` must be a non-empty string");
+  }
+  const repoRoot = value.repoRoot;
+  if (typeof repoRoot !== "string" || repoRoot.trim().length === 0) {
+    throw new TypeError("delegate_code: `repoRoot` must be a non-empty string");
+  }
+  const args = { goal: goal.trim(), repoRoot: repoRoot.trim() };
+  if (typeof value.contextHint === "string") args.contextHint = value.contextHint;
+  if (value.variants !== void 0) {
+    const variants = Number(value.variants);
+    if (!Number.isFinite(variants) || variants < 1 || variants > 8) {
+      throw new RangeError("delegate_code: `variants` must be an integer in [1, 8]");
+    }
+    args.variants = Math.trunc(variants);
+  }
+  if (value.config !== void 0) {
+    args.config = validateConfig(value.config);
+  }
+  if (typeof value.namespace === "string") args.namespace = value.namespace;
+  return args;
+}
+function validateConfig(raw) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError("delegate_code: `config` must be an object");
+  }
+  const value = raw;
+  const out = {};
+  if (value.testCmd !== void 0) {
+    if (typeof value.testCmd !== "string") {
+      throw new TypeError("delegate_code: `config.testCmd` must be a string");
+    }
+    out.testCmd = value.testCmd;
+  }
+  if (value.typecheckCmd !== void 0) {
+    if (typeof value.typecheckCmd !== "string") {
+      throw new TypeError("delegate_code: `config.typecheckCmd` must be a string");
+    }
+    out.typecheckCmd = value.typecheckCmd;
+  }
+  if (value.forbiddenPaths !== void 0) {
+    if (!Array.isArray(value.forbiddenPaths)) {
+      throw new TypeError("delegate_code: `config.forbiddenPaths` must be a string array");
+    }
+    out.forbiddenPaths = value.forbiddenPaths.map((entry, i) => {
+      if (typeof entry !== "string") {
+        throw new TypeError(`delegate_code: forbiddenPaths[${i}] must be a string`);
+      }
+      return entry;
+    });
+  }
+  if (value.maxDiffLines !== void 0) {
+    const n = Number(value.maxDiffLines);
+    if (!Number.isFinite(n) || n < 1) {
+      throw new RangeError("delegate_code: `config.maxDiffLines` must be a positive integer");
+    }
+    out.maxDiffLines = Math.trunc(n);
+  }
+  return out;
+}
+function createDelegateCodeHandler(options) {
+  const estimateDurationMs = options.estimateDurationMs ?? defaultEstimate;
+  return async (raw) => {
+    const args = validateDelegateCodeArgs(raw);
+    const idempotencyKey = hashIdempotencyInput({
+      profile: "coder",
+      goal: args.goal,
+      repoRoot: args.repoRoot,
+      contextHint: args.contextHint,
+      variants: args.variants ?? 1,
+      config: args.config,
+      namespace: args.namespace
+    });
+    const detached = options.detachedDispatch === true && (args.variants ?? 1) <= 1;
+    const submitted = options.queue.submit({
+      profile: "coder",
+      args,
+      namespace: args.namespace,
+      idempotencyKey,
+      ...detached ? {
+        detachedSessionRef: formatDetachedSessionRef({
+          sessionId: `dlg-turn-coder-${idempotencyKey}`
+        })
+      } : {},
+      run: async (ctx) => options.delegate(args, ctx)
+    });
+    return {
+      taskId: submitted.taskId,
+      estimatedDurationMs: estimateDurationMs(args)
+    };
+  };
+}
+function defaultEstimate(args) {
+  const variants = Math.max(1, args.variants ?? 1);
+  if (variants === 1) return SINGLE_VARIANT_ESTIMATE_MS;
+  return FANOUT_PER_VARIANT_ESTIMATE_MS;
+}
+
+// src/mcp/tools/delegate-feedback.ts
+var DELEGATE_FEEDBACK_TOOL_NAME = "delegate_feedback";
+var DELEGATE_FEEDBACK_DESCRIPTION = [
+  "Record feedback on a delegation, artifact, or outcome. Synchronous \u2014 the",
+  "event is durably stored when this call returns.",
+  "",
+  "Use when: you (the agent), the user, or a downstream judge has formed an",
+  "opinion about a piece of work and want it persisted for calibration,",
+  "pricing, or future routing. Every call is a new event \u2014 multiple ratings",
+  "on the same target are expected and never deduped.",
+  "",
+  "`refersTo.kind`:",
+  '  - "delegation": ref is a taskId returned by delegate_code/delegate_research',
+  '  - "artifact":   ref is a URI/path/git-sha \u2014 anything you can dereference',
+  '  - "outcome":    ref is a free-form description of a downstream result',
+  "",
+  "`by`:",
+  '  - "agent":            the agent itself rated the work',
+  '  - "user":             the human user rated it',
+  '  - "downstream-judge": an automated evaluator emitted the rating',
+  "",
+  "When ref names a known taskId, the rating is also attached to the",
+  "delegation record so delegation_history surfaces it inline."
+].join("\n");
+var DELEGATE_FEEDBACK_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    refersTo: {
+      type: "object",
+      properties: {
+        kind: { type: "string", enum: ["delegation", "artifact", "outcome"] },
+        ref: { type: "string" }
+      },
+      required: ["kind", "ref"],
+      additionalProperties: false
+    },
+    rating: {
+      type: "object",
+      properties: {
+        score: { type: "number", minimum: 0, maximum: 1 },
+        label: { type: "string", enum: ["good", "bad", "neutral", "mixed"] },
+        notes: { type: "string" }
+      },
+      required: ["score", "notes"],
+      additionalProperties: false
+    },
+    by: { type: "string", enum: ["agent", "user", "downstream-judge"] },
+    capturedAt: { type: "string" },
+    namespace: { type: "string" }
+  },
+  required: ["refersTo", "rating", "by"],
+  additionalProperties: false
+};
+function validateDelegateFeedbackArgs(raw) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError("delegate_feedback: arguments must be an object");
+  }
+  const value = raw;
+  const refersTo = validateRefersTo(value.refersTo);
+  const rating = validateRating(value.rating);
+  const by = value.by;
+  if (by !== "agent" && by !== "user" && by !== "downstream-judge") {
+    throw new TypeError(
+      'delegate_feedback: `by` must be one of "agent" | "user" | "downstream-judge"'
+    );
+  }
+  const args = { refersTo, rating, by };
+  if (value.capturedAt !== void 0) {
+    if (typeof value.capturedAt !== "string" || Number.isNaN(Date.parse(value.capturedAt))) {
+      throw new TypeError("delegate_feedback: `capturedAt` must be an ISO datetime");
+    }
+    args.capturedAt = value.capturedAt;
+  }
+  if (typeof value.namespace === "string") args.namespace = value.namespace;
+  return args;
+}
+function validateRefersTo(raw) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError("delegate_feedback: `refersTo` must be an object");
+  }
+  const value = raw;
+  const kind = value.kind;
+  if (kind !== "delegation" && kind !== "artifact" && kind !== "outcome") {
+    throw new TypeError(
+      'delegate_feedback: `refersTo.kind` must be one of "delegation" | "artifact" | "outcome"'
+    );
+  }
+  const ref = value.ref;
+  if (typeof ref !== "string" || ref.trim().length === 0) {
+    throw new TypeError("delegate_feedback: `refersTo.ref` must be a non-empty string");
+  }
+  return { kind, ref: ref.trim() };
+}
+function validateRating(raw) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError("delegate_feedback: `rating` must be an object");
+  }
+  const value = raw;
+  const score = Number(value.score);
+  if (!Number.isFinite(score) || score < 0 || score > 1) {
+    throw new RangeError("delegate_feedback: `rating.score` must be a number in [0, 1]");
+  }
+  const notes = value.notes;
+  if (typeof notes !== "string") {
+    throw new TypeError("delegate_feedback: `rating.notes` must be a string");
+  }
+  const rating = { score, notes };
+  const label = value.label;
+  if (label !== void 0) {
+    if (label !== "good" && label !== "bad" && label !== "neutral" && label !== "mixed") {
+      throw new TypeError(
+        'delegate_feedback: `rating.label` must be one of "good" | "bad" | "neutral" | "mixed"'
+      );
+    }
+    rating.label = label;
+  }
+  return rating;
+}
+function createDelegateFeedbackHandler(options) {
+  const generateId = options.generateId ?? randomFeedbackId;
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  return async (raw) => {
+    const args = validateDelegateFeedbackArgs(raw);
+    const id = generateId();
+    const event = {
+      id,
+      refersTo: args.refersTo,
+      rating: args.rating,
+      by: args.by,
+      capturedAt: args.capturedAt ?? now(),
+      namespace: args.namespace
+    };
+    await options.store.put(event);
+    if (args.refersTo.kind === "delegation") {
+      options.queue.attachFeedback(args.refersTo.ref, eventToSnapshot(event));
+    }
+    return { recorded: true, id };
+  };
+}
+function randomFeedbackId() {
+  const t = Date.now().toString(36);
+  const r = Math.random().toString(36).slice(2, 10);
+  return `fbk-${t}-${r}`;
+}
+
+// src/mcp/tools/delegate-research.ts
+var DELEGATE_RESEARCH_TOOL_NAME = "delegate_research";
+var DELEGATE_RESEARCH_DESCRIPTION = [
+  "Delegate a research question to specialist researcher agents that produce",
+  "source-grounded, evidence-bearing knowledge items.",
+  "",
+  "Use when: you need to answer a factual question with external evidence \u2014",
+  "audience research, competitive intelligence, recency-bound web searches,",
+  "corpus / docs lookups. The researcher emits items[] with provenance, a",
+  "citations[] index, and proposedWrites[] you decide whether to persist.",
+  "",
+  "Returns immediately with a taskId. Poll delegation_status to retrieve the",
+  "items + verdict. Identical inputs return the same taskId \u2014 safe to retry.",
+  "",
+  "When variants > 1, multiple researcher harnesses run in parallel and the",
+  "highest-scoring valid output wins (citation density \xD7 source diversity \xD7",
+  "recency match \xD7 gap coverage). Use variants when answers might disagree.",
+  "",
+  "Multi-tenant isolation: every item carries `namespace`. The validator",
+  "hard-fails when any item is scoped outside `namespace`. Never pass another",
+  "tenant's namespace."
+].join("\n");
+var VALID_SOURCES = ["web", "corpus", "twitter", "github", "docs"];
+var DELEGATE_RESEARCH_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    question: {
+      type: "string",
+      description: "The research question to answer."
+    },
+    namespace: {
+      type: "string",
+      description: "Multi-tenant scope (customer-id, workspace-id). REQUIRED."
+    },
+    scope: { type: "string", description: 'Bound, e.g. "audience for cpg-founder ICP".' },
+    sources: {
+      type: "array",
+      items: { type: "string", enum: [...VALID_SOURCES] }
+    },
+    variants: { type: "integer", minimum: 1, maximum: 8 },
+    config: {
+      type: "object",
+      properties: {
+        recencyWindow: {
+          type: "object",
+          properties: {
+            since: { type: "string", description: "ISO datetime" },
+            until: { type: "string", description: "ISO datetime" }
+          },
+          additionalProperties: false
+        },
+        maxItems: { type: "integer", minimum: 1 },
+        minConfidence: { type: "number", minimum: 0, maximum: 1 }
+      },
+      additionalProperties: false
+    }
+  },
+  required: ["question", "namespace"],
+  additionalProperties: false
+};
+var SINGLE_VARIANT_ESTIMATE_MS2 = 4 * 60 * 1e3;
+var FANOUT_PER_VARIANT_ESTIMATE_MS2 = 6 * 60 * 1e3;
+function validateDelegateResearchArgs(raw) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError("delegate_research: arguments must be an object");
+  }
+  const value = raw;
+  const question = value.question;
+  if (typeof question !== "string" || question.trim().length === 0) {
+    throw new TypeError("delegate_research: `question` must be a non-empty string");
+  }
+  const namespace = value.namespace;
+  if (typeof namespace !== "string" || namespace.trim().length === 0) {
+    throw new TypeError("delegate_research: `namespace` is required");
+  }
+  const args = { question: question.trim(), namespace: namespace.trim() };
+  if (typeof value.scope === "string") args.scope = value.scope;
+  if (value.sources !== void 0) {
+    if (!Array.isArray(value.sources)) {
+      throw new TypeError("delegate_research: `sources` must be a string array");
+    }
+    const sources = value.sources.map((src, i) => {
+      if (typeof src !== "string" || !VALID_SOURCES.includes(src)) {
+        throw new TypeError(
+          `delegate_research: sources[${i}] must be one of ${VALID_SOURCES.join("|")}`
+        );
+      }
+      return src;
+    });
+    args.sources = sources;
+  }
+  if (value.variants !== void 0) {
+    const variants = Number(value.variants);
+    if (!Number.isFinite(variants) || variants < 1 || variants > 8) {
+      throw new RangeError("delegate_research: `variants` must be an integer in [1, 8]");
+    }
+    args.variants = Math.trunc(variants);
+  }
+  if (value.config !== void 0) {
+    args.config = validateConfig2(value.config);
+  }
+  return args;
+}
+function validateConfig2(raw) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError("delegate_research: `config` must be an object");
+  }
+  const value = raw;
+  const out = {};
+  if (value.recencyWindow !== void 0) {
+    if (value.recencyWindow === null || typeof value.recencyWindow !== "object") {
+      throw new TypeError("delegate_research: `config.recencyWindow` must be an object");
+    }
+    const window = value.recencyWindow;
+    const windowOut = {};
+    if (window.since !== void 0) {
+      if (typeof window.since !== "string" || Number.isNaN(Date.parse(window.since))) {
+        throw new TypeError("delegate_research: `recencyWindow.since` must be an ISO datetime");
+      }
+      windowOut.since = window.since;
+    }
+    if (window.until !== void 0) {
+      if (typeof window.until !== "string" || Number.isNaN(Date.parse(window.until))) {
+        throw new TypeError("delegate_research: `recencyWindow.until` must be an ISO datetime");
+      }
+      windowOut.until = window.until;
+    }
+    out.recencyWindow = windowOut;
+  }
+  if (value.maxItems !== void 0) {
+    const n = Number(value.maxItems);
+    if (!Number.isFinite(n) || n < 1) {
+      throw new RangeError("delegate_research: `config.maxItems` must be a positive integer");
+    }
+    out.maxItems = Math.trunc(n);
+  }
+  if (value.minConfidence !== void 0) {
+    const n = Number(value.minConfidence);
+    if (!Number.isFinite(n) || n < 0 || n > 1) {
+      throw new RangeError("delegate_research: `config.minConfidence` must be in [0, 1]");
+    }
+    out.minConfidence = n;
+  }
+  return out;
+}
+function createDelegateResearchHandler(options) {
+  const estimateDurationMs = options.estimateDurationMs ?? defaultEstimate2;
+  return async (raw) => {
+    const args = validateDelegateResearchArgs(raw);
+    const idempotencyKey = hashIdempotencyInput({
+      profile: "researcher",
+      question: args.question,
+      namespace: args.namespace,
+      scope: args.scope,
+      sources: args.sources,
+      variants: args.variants ?? 1,
+      config: args.config
+    });
+    const detached = options.detachedDispatch === true && (args.variants ?? 1) <= 1;
+    const submitted = options.queue.submit({
+      profile: "researcher",
+      args,
+      namespace: args.namespace,
+      idempotencyKey,
+      ...detached ? {
+        detachedSessionRef: formatDetachedSessionRef({
+          sessionId: `dlg-turn-research-${idempotencyKey}`
+        })
+      } : {},
+      run: async (ctx) => options.delegate(args, ctx)
+    });
+    return {
+      taskId: submitted.taskId,
+      estimatedDurationMs: estimateDurationMs(args)
+    };
+  };
+}
+function defaultEstimate2(args) {
+  const variants = Math.max(1, args.variants ?? 1);
+  if (variants === 1) return SINGLE_VARIANT_ESTIMATE_MS2;
+  return FANOUT_PER_VARIANT_ESTIMATE_MS2;
+}
+
+// src/mcp/tools/delegate-ui-audit.ts
+import path from "path";
+var DELEGATE_UI_AUDIT_TOOL_NAME = "delegate_ui_audit";
+var DELEGATE_UI_AUDIT_DESCRIPTION = [
+  "Delegate a UI/UX audit to a vision-driven auditor that produces self-contained",
+  "GitHub-issue-ready Markdown findings \u2014 one file per finding, with embedded",
+  "screenshot evidence and a suggested fix.",
+  "",
+  "Use when: you want a thorough pass over a running web app for consistency,",
+  "hierarchy, layout, ux-flow, duplication, accessibility, responsive, states,",
+  "content, interaction, or perceived-performance issues. The auditor iterates",
+  "lens-by-lens so each pass finds new classes of issues; the workspace registry",
+  "deduplicates across iterations.",
+  "",
+  "Returns immediately with a taskId. Poll delegation_status to retrieve the",
+  "workspace path + indexed findings (typically minutes per audited route).",
+  "Identical inputs return the same taskId \u2014 safe to retry.",
+  "",
+  "Output layout under workspaceDir:",
+  "  registry.json                       \u2014 finding index + capture sidecar",
+  "  index.md                            \u2014 human-readable rollup",
+  "  issues/NNN--<lens>--<slug>.md       \u2014 one self-contained GitHub-issue",
+  "  screenshots/<route>--<viewport>.png \u2014 capture archive",
+  "",
+  "Multi-tenant isolation: every finding is scoped to `namespace` when set.",
+  "Never pass another tenant's namespace."
+].join("\n");
+var VIEWPORT_SCHEMA = {
+  type: "object",
+  properties: {
+    width: { type: "integer", minimum: 1 },
+    height: { type: "integer", minimum: 1 }
+  },
+  required: ["width", "height"],
+  additionalProperties: false
+};
+var ROUTE_SCHEMA = {
+  type: "object",
+  properties: {
+    name: { type: "string", description: "Stable route name (used in screenshot filenames)." },
+    url: { type: "string", description: "Fully-qualified URL." },
+    viewports: {
+      type: "array",
+      items: VIEWPORT_SCHEMA,
+      description: "Viewports to capture at. Default [{1280, 800}]."
+    },
+    fullPage: { type: "boolean" },
+    waitFor: { type: "string", description: "CSS selector to wait for before capturing." }
+  },
+  required: ["name", "url"],
+  additionalProperties: false
+};
+var DELEGATE_UI_AUDIT_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    workspaceDir: { type: "string", description: "Absolute path for the audit workspace." },
+    routes: { type: "array", items: ROUTE_SCHEMA, minItems: 1 },
+    namespace: { type: "string", description: "Multi-tenant scope." },
+    config: {
+      type: "object",
+      properties: {
+        lenses: {
+          type: "array",
+          items: { type: "string", enum: [...UI_LENSES] },
+          description: 'Lenses to iterate. Default: every lens except "other".'
+        },
+        maxIterations: { type: "integer", minimum: 1 },
+        maxConcurrency: { type: "integer", minimum: 1 },
+        productContext: { type: "string" }
+      },
+      additionalProperties: false
+    }
+  },
+  required: ["workspaceDir", "routes"],
+  additionalProperties: false
+};
+var PER_LENS_PER_ROUTE_ESTIMATE_MS = 45e3;
+function validateDelegateUiAuditArgs(raw) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError("delegate_ui_audit: arguments must be an object");
+  }
+  const value = raw;
+  const workspaceDir = value.workspaceDir;
+  if (typeof workspaceDir !== "string" || workspaceDir.trim().length === 0) {
+    throw new TypeError("delegate_ui_audit: `workspaceDir` must be a non-empty string");
+  }
+  const trimmedWs = workspaceDir.trim();
+  if (!path.isAbsolute(trimmedWs)) {
+    throw new TypeError(
+      `delegate_ui_audit: \`workspaceDir\` must be an absolute path (got ${JSON.stringify(workspaceDir)})`
+    );
+  }
+  if (trimmedWs.split(path.sep).includes("..")) {
+    throw new TypeError(
+      `delegate_ui_audit: \`workspaceDir\` must not contain '..' segments (got ${JSON.stringify(workspaceDir)})`
+    );
+  }
+  const routesRaw = value.routes;
+  if (!Array.isArray(routesRaw) || routesRaw.length === 0) {
+    throw new TypeError("delegate_ui_audit: `routes` must be a non-empty array");
+  }
+  const routes = routesRaw.map((r, i) => validateRoute(r, i));
+  const args = { workspaceDir: workspaceDir.trim(), routes };
+  if (value.namespace !== void 0) {
+    if (typeof value.namespace !== "string" || value.namespace.trim().length === 0) {
+      throw new TypeError("delegate_ui_audit: `namespace` must be a non-empty string when set");
+    }
+    args.namespace = value.namespace.trim();
+  }
+  if (value.config !== void 0) {
+    args.config = validateConfig3(value.config);
+  }
+  return args;
+}
+function validateRoute(raw, index) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError(`delegate_ui_audit: routes[${index}] must be an object`);
+  }
+  const v = raw;
+  if (typeof v.name !== "string" || v.name.trim().length === 0) {
+    throw new TypeError(`delegate_ui_audit: routes[${index}].name must be a non-empty string`);
+  }
+  const trimmedName = v.name.trim();
+  if (/[./\\]/.test(trimmedName) || trimmedName.includes("\0")) {
+    throw new TypeError(
+      `delegate_ui_audit: routes[${index}].name must not contain path separators, dots, or NUL (got ${JSON.stringify(v.name)})`
+    );
+  }
+  if (typeof v.url !== "string" || v.url.trim().length === 0) {
+    throw new TypeError(`delegate_ui_audit: routes[${index}].url must be a non-empty string`);
+  }
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(v.url);
+  } catch {
+    throw new TypeError(
+      `delegate_ui_audit: routes[${index}].url is not a parseable URL (got ${JSON.stringify(v.url)})`
+    );
+  }
+  if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+    throw new TypeError(
+      `delegate_ui_audit: routes[${index}].url must use http or https (got ${parsedUrl.protocol})`
+    );
+  }
+  const out = { name: v.name.trim(), url: v.url.trim() };
+  if (v.viewports !== void 0) {
+    if (!Array.isArray(v.viewports) || v.viewports.length === 0) {
+      throw new TypeError(
+        `delegate_ui_audit: routes[${index}].viewports must be a non-empty array when set`
+      );
+    }
+    out.viewports = v.viewports.map((vp, j) => validateViewport(vp, index, j));
+  }
+  if (v.fullPage !== void 0) {
+    if (typeof v.fullPage !== "boolean") {
+      throw new TypeError(`delegate_ui_audit: routes[${index}].fullPage must be a boolean`);
+    }
+    out.fullPage = v.fullPage;
+  }
+  if (v.waitFor !== void 0) {
+    if (typeof v.waitFor !== "string" || v.waitFor.trim().length === 0) {
+      throw new TypeError(
+        `delegate_ui_audit: routes[${index}].waitFor must be a non-empty string when set`
+      );
+    }
+    out.waitFor = v.waitFor.trim();
+  }
+  return out;
+}
+function validateViewport(raw, routeIndex, viewportIndex) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError(
+      `delegate_ui_audit: routes[${routeIndex}].viewports[${viewportIndex}] must be an object`
+    );
+  }
+  const v = raw;
+  const w = Number(v.width);
+  const h = Number(v.height);
+  if (!Number.isInteger(w) || w <= 0 || !Number.isInteger(h) || h <= 0) {
+    throw new RangeError(
+      `delegate_ui_audit: routes[${routeIndex}].viewports[${viewportIndex}] must have positive integer width/height`
+    );
+  }
+  return { width: w, height: h };
+}
+function validateConfig3(raw) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError("delegate_ui_audit: `config` must be an object");
+  }
+  const v = raw;
+  const out = {};
+  if (v.lenses !== void 0) {
+    if (!Array.isArray(v.lenses) || v.lenses.length === 0) {
+      throw new TypeError("delegate_ui_audit: `config.lenses` must be a non-empty array when set");
+    }
+    const knownSet = new Set(UI_LENSES);
+    const lenses = [];
+    for (let i = 0; i < v.lenses.length; i += 1) {
+      const lens = v.lenses[i];
+      if (typeof lens !== "string" || !knownSet.has(lens)) {
+        throw new TypeError(
+          `delegate_ui_audit: config.lenses[${i}] must be one of ${UI_LENSES.join("|")}`
+        );
+      }
+      lenses.push(lens);
+    }
+    out.lenses = lenses;
+  }
+  if (v.maxIterations !== void 0) {
+    const n = Number(v.maxIterations);
+    if (!Number.isInteger(n) || n < 1) {
+      throw new RangeError("delegate_ui_audit: `config.maxIterations` must be a positive integer");
+    }
+    out.maxIterations = n;
+  }
+  if (v.maxConcurrency !== void 0) {
+    const n = Number(v.maxConcurrency);
+    if (!Number.isInteger(n) || n < 1) {
+      throw new RangeError("delegate_ui_audit: `config.maxConcurrency` must be a positive integer");
+    }
+    out.maxConcurrency = n;
+  }
+  if (v.productContext !== void 0) {
+    if (typeof v.productContext !== "string") {
+      throw new TypeError("delegate_ui_audit: `config.productContext` must be a string");
+    }
+    out.productContext = v.productContext;
+  }
+  return out;
+}
+function createDelegateUiAuditHandler(options) {
+  const estimateDurationMs = options.estimateDurationMs ?? defaultEstimate3;
+  return async (raw) => {
+    const args = validateDelegateUiAuditArgs(raw);
+    const idempotencyKey = hashIdempotencyInput({
+      profile: "ui-auditor",
+      workspaceDir: args.workspaceDir,
+      routes: args.routes,
+      namespace: args.namespace,
+      config: args.config
+    });
+    const submitted = options.queue.submit({
+      profile: "ui-auditor",
+      args,
+      namespace: args.namespace,
+      idempotencyKey,
+      run: async (ctx) => options.delegate(args, ctx)
+    });
+    return {
+      taskId: submitted.taskId,
+      estimatedDurationMs: estimateDurationMs(args)
+    };
+  };
+}
+function defaultEstimate3(args) {
+  const lenses = args.config?.lenses?.length ?? UI_LENSES.length - 1;
+  const routes = args.routes.length;
+  return PER_LENS_PER_ROUTE_ESTIMATE_MS * lenses * routes;
+}
+
+// src/mcp/tools/delegation-history.ts
+var DELEGATION_HISTORY_TOOL_NAME = "delegation_history";
+var DELEGATION_HISTORY_DESCRIPTION = [
+  "Read past delegations newest-first. Each entry carries the original",
+  "arguments, current status, cost, and any feedback attached via",
+  "delegate_feedback.",
+  "",
+  'Use when: you want to introspect prior decisions \u2014 "have I asked this',
+  "question before?",
+  "did the last patch land?",
+  "what's the historical",
+  'success rate of coder delegations on this repo?". Feed the results back',
+  "into your own routing and calibration.",
+  "",
+  "Each entry carries `hasTrace` \u2014 when true, the full loop-trace span tree",
+  "is retrievable via delegation_status { taskId, includeTrace: true }.",
+  "",
+  'Filters: `namespace` (multi-tenant scope), `profile` ("coder" | "researcher"),',
+  "`since` (ISO date \u2014 only delegations started at-or-after). `limit` defaults",
+  "to 50, capped at 500."
+].join("\n");
+var DELEGATION_HISTORY_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    namespace: { type: "string" },
+    profile: { type: "string", enum: ["coder", "researcher"] },
+    since: { type: "string", description: "ISO datetime \u2014 earliest startedAt to include." },
+    limit: { type: "integer", minimum: 1, maximum: 500 }
+  },
+  additionalProperties: false
+};
+function validateDelegationHistoryArgs(raw) {
+  if (raw === void 0 || raw === null) return {};
+  if (typeof raw !== "object") {
+    throw new TypeError("delegation_history: arguments must be an object");
+  }
+  const value = raw;
+  const out = {};
+  if (value.namespace !== void 0) {
+    if (typeof value.namespace !== "string") {
+      throw new TypeError("delegation_history: `namespace` must be a string");
+    }
+    out.namespace = value.namespace;
+  }
+  if (value.profile !== void 0) {
+    if (value.profile !== "coder" && value.profile !== "researcher") {
+      throw new TypeError('delegation_history: `profile` must be "coder" or "researcher"');
+    }
+    out.profile = value.profile;
+  }
+  if (value.since !== void 0) {
+    if (typeof value.since !== "string" || Number.isNaN(Date.parse(value.since))) {
+      throw new TypeError("delegation_history: `since` must be an ISO datetime");
+    }
+    out.since = value.since;
+  }
+  if (value.limit !== void 0) {
+    const n = Number(value.limit);
+    if (!Number.isFinite(n) || n < 1 || n > 500) {
+      throw new RangeError("delegation_history: `limit` must be an integer in [1, 500]");
+    }
+    out.limit = Math.trunc(n);
+  }
+  return out;
+}
+function createDelegationHistoryHandler(options) {
+  return async (raw) => {
+    const args = validateDelegationHistoryArgs(raw);
+    return { delegations: options.queue.history(args) };
+  };
+}
+
+// src/mcp/tools/delegation-status.ts
+var DELEGATION_STATUS_TOOL_NAME = "delegation_status";
+var DELEGATION_STATUS_DESCRIPTION = [
+  "Poll the status of an async delegation. Returns the current state",
+  "(pending | running | completed | failed | cancelled), optional progress,",
+  'and the final result when status === "completed".',
+  "",
+  "Use when: you previously called delegate_code or delegate_research and",
+  "need to know whether the work is done. The agent's right rhythm is to",
+  "call this every minute or two while waiting; do not busy-poll.",
+  "",
+  "For a completed coder task, `result.output` is a CoderOutput with branch,",
+  "patch, test/typecheck results, and diff stats. For a completed research",
+  "task, `result.output` is the items + citations + proposedWrites bundle.",
+  "",
+  "Pass includeTrace: true to also receive the journaled loop-trace span",
+  "tree (loop \u2192 round \u2192 iteration, with placement/cost/verdict metadata).",
+  "Default false \u2014 keep routine polls light.",
+  "",
+  "Throws NotFoundError when taskId is unknown \u2014 never silently returns",
+  "`pending` for a typo."
+].join("\n");
+var DELEGATION_STATUS_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    taskId: { type: "string", description: "Returned by delegate_code / delegate_research." },
+    includeTrace: {
+      type: "boolean",
+      description: "Also return the journaled loop-trace span tree for this delegation. Default false."
+    }
+  },
+  required: ["taskId"],
+  additionalProperties: false
+};
+function validateDelegationStatusArgs(raw) {
+  if (raw === null || typeof raw !== "object") {
+    throw new TypeError("delegation_status: arguments must be an object");
+  }
+  const value = raw;
+  const taskId = value.taskId;
+  if (typeof taskId !== "string" || taskId.trim().length === 0) {
+    throw new TypeError("delegation_status: `taskId` must be a non-empty string");
+  }
+  const out = { taskId: taskId.trim() };
+  if (value.includeTrace !== void 0) {
+    if (typeof value.includeTrace !== "boolean") {
+      throw new TypeError("delegation_status: `includeTrace` must be a boolean");
+    }
+    out.includeTrace = value.includeTrace;
+  }
+  return out;
+}
+function createDelegationStatusHandler(options) {
+  return async (raw) => {
+    const args = validateDelegationStatusArgs(raw);
+    const status = options.queue.status(
+      args.taskId,
+      args.includeTrace !== void 0 ? { includeTrace: args.includeTrace } : void 0
+    );
+    if (!status) {
+      throw new NotFoundError(`delegation_status: unknown taskId "${args.taskId}"`);
+    }
+    return status;
+  };
+}
+
+// src/mcp/server.ts
+var PROTOCOL_VERSION = "2024-11-05";
+var DEFAULT_SERVER_NAME = "agent-runtime-mcp";
+var DEFAULT_SERVER_VERSION = "0.22.0";
+function createMcpServer(options = {}) {
+  const queue = options.queue ?? new DelegationTaskQueue(
+    options.traceContext !== void 0 ? { traceContext: options.traceContext } : {}
+  );
+  const feedbackStore = options.feedbackStore ?? new InMemoryFeedbackStore();
+  const serverName = options.serverName ?? DEFAULT_SERVER_NAME;
+  const serverVersion = options.serverVersion ?? DEFAULT_SERVER_VERSION;
+  const tools = /* @__PURE__ */ new Map();
+  if (options.coderDelegate) {
+    tools.set(DELEGATE_CODE_TOOL_NAME, {
+      name: DELEGATE_CODE_TOOL_NAME,
+      description: DELEGATE_CODE_DESCRIPTION,
+      inputSchema: DELEGATE_CODE_INPUT_SCHEMA,
+      handler: createDelegateCodeHandler({
+        queue,
+        delegate: options.coderDelegate,
+        ...options.detachedDispatch !== void 0 ? { detachedDispatch: options.detachedDispatch } : {}
+      })
+    });
+  }
+  if (options.researcherDelegate) {
+    tools.set(DELEGATE_RESEARCH_TOOL_NAME, {
+      name: DELEGATE_RESEARCH_TOOL_NAME,
+      description: DELEGATE_RESEARCH_DESCRIPTION,
+      inputSchema: DELEGATE_RESEARCH_INPUT_SCHEMA,
+      handler: createDelegateResearchHandler({
+        queue,
+        delegate: options.researcherDelegate,
+        ...options.detachedDispatch !== void 0 ? { detachedDispatch: options.detachedDispatch } : {}
+      })
+    });
+  }
+  if (options.uiAuditorDelegate) {
+    tools.set(DELEGATE_UI_AUDIT_TOOL_NAME, {
+      name: DELEGATE_UI_AUDIT_TOOL_NAME,
+      description: DELEGATE_UI_AUDIT_DESCRIPTION,
+      inputSchema: DELEGATE_UI_AUDIT_INPUT_SCHEMA,
+      handler: createDelegateUiAuditHandler({ queue, delegate: options.uiAuditorDelegate })
+    });
+  }
+  tools.set(DELEGATE_FEEDBACK_TOOL_NAME, {
+    name: DELEGATE_FEEDBACK_TOOL_NAME,
+    description: DELEGATE_FEEDBACK_DESCRIPTION,
+    inputSchema: DELEGATE_FEEDBACK_INPUT_SCHEMA,
+    handler: createDelegateFeedbackHandler({ queue, store: feedbackStore })
+  });
+  tools.set(DELEGATION_STATUS_TOOL_NAME, {
+    name: DELEGATION_STATUS_TOOL_NAME,
+    description: DELEGATION_STATUS_DESCRIPTION,
+    inputSchema: DELEGATION_STATUS_INPUT_SCHEMA,
+    handler: createDelegationStatusHandler({ queue })
+  });
+  tools.set(DELEGATION_HISTORY_TOOL_NAME, {
+    name: DELEGATION_HISTORY_TOOL_NAME,
+    description: DELEGATION_HISTORY_DESCRIPTION,
+    inputSchema: DELEGATION_HISTORY_INPUT_SCHEMA,
+    handler: createDelegationHistoryHandler({ queue })
+  });
+  for (const tool of options.extraTools ?? []) {
+    if (tools.has(tool.name)) {
+      throw new ValidationError(
+        `createMcpServer: extra tool "${tool.name}" shadows a built-in tool`
+      );
+    }
+    tools.set(tool.name, tool);
+  }
+  let stopped = false;
+  let activeReadline;
+  async function handle(message) {
+    if (stopped) {
+      return rpcError(message.id ?? null, -32099, "server stopped");
+    }
+    if (message.method === "initialize") {
+      return rpcResult(message.id ?? null, {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: { name: serverName, version: serverVersion }
+      });
+    }
+    if (message.method === "notifications/initialized") {
+      return null;
+    }
+    if (message.method === "tools/list") {
+      return rpcResult(message.id ?? null, {
+        tools: [...tools.values()].map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema
+        }))
+      });
+    }
+    if (message.method === "tools/call") {
+      const params = message.params ?? {};
+      const name = typeof params.name === "string" ? params.name : "";
+      const tool = tools.get(name);
+      if (!tool) {
+        return rpcError(message.id ?? null, -32601, `unknown tool: ${name}`);
+      }
+      try {
+        const output = await tool.handler(params.arguments ?? {});
+        return rpcResult(message.id ?? null, {
+          content: [{ type: "text", text: JSON.stringify(output) }],
+          structuredContent: output,
+          isError: false
+        });
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        const code = err instanceof TypeError || err instanceof RangeError ? -32602 : -32e3;
+        return rpcError(message.id ?? null, code, reason);
+      }
+    }
+    if (message.id === void 0 || message.id === null) return null;
+    return rpcError(message.id, -32601, `unknown method: ${message.method}`);
+  }
+  async function serve(transport) {
+    const input = transport?.input ?? process.stdin;
+    const output = transport?.output ?? process.stdout;
+    const rl = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
+    activeReadline = rl;
+    return new Promise((resolve, reject) => {
+      rl.on("line", (line) => {
+        const trimmed = line.trim();
+        if (!trimmed) return;
+        let parsed;
+        try {
+          parsed = JSON.parse(trimmed);
+        } catch (err) {
+          writeResponse(output, rpcError(null, -32700, `parse error: ${err.message}`));
+          return;
+        }
+        if (!parsed || parsed.jsonrpc !== "2.0" || typeof parsed.method !== "string") {
+          writeResponse(output, rpcError(parsed?.id ?? null, -32600, "invalid request"));
+          return;
+        }
+        void handle(parsed).then((response) => {
+          if (response) writeResponse(output, response);
+        });
+      });
+      rl.on("close", () => resolve());
+      rl.on("error", (err) => reject(err));
+      if (stopped) {
+        rl.close();
+        resolve();
+      }
+    });
+  }
+  function stop() {
+    stopped = true;
+    activeReadline?.close();
+    activeReadline = void 0;
+  }
+  return {
+    tools,
+    queue,
+    feedbackStore,
+    handle,
+    serve,
+    stop
+  };
+}
+function rpcResult(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function rpcError(id, code, message, data) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: data === void 0 ? { code, message } : { code, message, data }
+  };
+}
+function writeResponse(output, response) {
+  output.write(`${JSON.stringify(response)}
+`);
+}
+function createInProcessTransport() {
+  const responses = [];
+  const input = new Readable({ read() {
+  } });
+  const output = new Writable({
+    write(chunk, _enc, cb) {
+      const text = chunk.toString("utf8");
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          responses.push(JSON.parse(trimmed));
+        } catch {
+        }
+      }
+      cb();
+    }
+  });
+  return {
+    transport: { input, output },
+    clientWrite(line) {
+      input.push(`${line}
+`);
+    },
+    clientClose() {
+      input.push(null);
+    },
+    async readServer() {
+      for (let i = 0; i < 5; i += 1) await new Promise((r) => setImmediate(r));
+      return [...responses];
+    }
+  };
+}
+
+// src/runtime/supervise/coordination-mcp.ts
+async function serveCoordinationMcp(opts) {
+  const coord = createCoordinationTools({
+    scope: opts.scope,
+    blobs: opts.blobs,
+    makeWorkerAgent: opts.makeWorkerAgent,
+    perWorker: opts.perWorker
+  });
+  const mcp = createMcpServer({ extraTools: coord.tools, serverName: "coordination" });
+  const host = opts.host ?? "127.0.0.1";
+  const server = createServer((req, res) => {
+    if (req.method !== "POST") {
+      res.writeHead(405, { allow: "POST" });
+      res.end();
+      return;
+    }
+    let body = "";
+    req.on("data", (c) => {
+      body += c;
+    });
+    req.on("end", () => {
+      void (async () => {
+        try {
+          const message = JSON.parse(body);
+          const response = await mcp.handle(message);
+          if (response === null) {
+            res.writeHead(202).end();
+            return;
+          }
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(JSON.stringify(response));
+        } catch (e) {
+          res.writeHead(200, { "content-type": "application/json" });
+          res.end(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: null,
+              error: { code: -32700, message: e instanceof Error ? e.message : "parse error" }
+            })
+          );
+        }
+      })();
+    });
+  });
+  const port = await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(opts.port ?? 0, host, () => {
+      const addr = server.address();
+      resolve(typeof addr === "object" && addr ? addr.port : opts.port ?? 0);
+    });
+  });
+  return {
+    url: `http://${host}:${port}/mcp`,
+    port,
+    settled: () => coord.settled(),
+    isStopped: () => coord.isStopped(),
+    close: () => new Promise((resolve) => {
+      server.close(() => resolve());
+    })
+  };
+}
+
+// src/runtime/verifier-environment.ts
+var submitTool = {
+  type: "function",
+  function: {
+    name: "submit_answer",
+    description: "Submit your answer for evaluation. You may submit more than once \u2014 the best-scoring submission counts. Submit the COMPLETE final answer, not a fragment.",
+    parameters: {
+      type: "object",
+      properties: { answer: { type: "string", description: "The complete final answer." } },
+      required: ["answer"]
+    }
+  }
+};
+function createVerifierEnvironment(opts) {
+  if (opts.extraTools?.length && !opts.callExtra) {
+    throw new Error(`${opts.name}: extraTools requires callExtra`);
+  }
+  const states = /* @__PURE__ */ new Map();
+  let seq = 0;
+  return {
+    name: opts.name,
+    async open(task) {
+      seq += 1;
+      const handle = { id: `${opts.name}-${seq}`, surface: opts.name };
+      states.set(handle.id, { task, submissions: [] });
+      return handle;
+    },
+    async tools() {
+      return [submitTool, ...opts.extraTools ?? []];
+    },
+    async call(handle, name, args) {
+      const state = states.get(handle.id);
+      if (!state) return "ERROR: workspace closed";
+      if (name === "submit_answer") {
+        const answer = String(args.answer ?? "").trim();
+        if (!answer) return "ERROR: empty answer";
+        state.submissions.push(answer);
+        return `submission ${state.submissions.length} recorded`;
+      }
+      if (opts.callExtra && opts.extraTools?.some((t) => t.function.name === name)) {
+        try {
+          return await opts.callExtra(state.task, name, args);
+        } catch (e) {
+          return `ERROR: ${e instanceof Error ? e.message : String(e)}`;
+        }
+      }
+      return `ERROR: unknown tool ${name}`;
+    },
+    // Keep-best across submissions — the measured law (workers reach correct answers,
+    // then revise past them; final-state scoring undersells every strategy).
+    async score(task, handle) {
+      const state = states.get(handle.id);
+      if (!state || state.submissions.length === 0) return { passes: 0, total: 1, errored: 0 };
+      let best = { passes: 0, total: 1, errored: 0 };
+      const ratio = (s) => s.total > 0 ? s.passes / s.total : 0;
+      for (const answer of state.submissions) {
+        const s = await opts.check(task, answer);
+        if (ratio(s) > ratio(best)) best = s;
+      }
+      return best;
+    },
+    async close(handle) {
+      states.delete(handle.id);
+    }
+  };
+}
+
+// src/runtime/waterfall.ts
+function createWaterfallCollector() {
+  let spans = /* @__PURE__ */ new Map();
+  const onEvent = (event) => {
+    if (event.target === "agent.spawn") {
+      const p = event.payload ?? {};
+      const id = p.childId ?? event.id;
+      spans.set(id, {
+        id,
+        label: p.label ?? id,
+        runId: event.runId,
+        ...event.parentId !== void 0 ? { parentId: event.parentId } : {},
+        startMs: event.timestamp,
+        status: "running",
+        usd: 0,
+        tokens: { input: 0, output: 0 }
+      });
+      return;
+    }
+    if (event.target === "agent.child") {
+      const p = event.payload ?? {};
+      const id = p.childId;
+      if (!id) return;
+      const span = spans.get(id);
+      if (!span) return;
+      span.endMs = event.timestamp;
+      span.status = p.status === "down" ? "down" : "done";
+      span.usd = p.spent?.usd ?? 0;
+      span.tokens = {
+        input: p.spent?.tokens?.input ?? 0,
+        output: p.spent?.tokens?.output ?? 0
+      };
+      if (typeof p.score === "number") span.score = p.score;
+    }
+  };
+  const report = () => {
+    const all = [...spans.values()].sort((a, b) => a.startMs - b.startMs);
+    const start = all[0]?.startMs ?? 0;
+    const end = Math.max(start, ...all.map((s) => s.endMs ?? s.startMs));
+    const byKind = {};
+    let totalUsd = 0;
+    const totalTokens2 = { input: 0, output: 0 };
+    for (const s of all) {
+      totalUsd += s.usd;
+      totalTokens2.input += s.tokens.input;
+      totalTokens2.output += s.tokens.output;
+      const kind = s.label.includes(":") ? s.label.split(":")[0] : s.label;
+      let k = byKind[kind];
+      if (!k) {
+        k = { count: 0, ms: 0, usd: 0, tokens: { input: 0, output: 0 } };
+        byKind[kind] = k;
+      }
+      k.count += 1;
+      k.ms += (s.endMs ?? s.startMs) - s.startMs;
+      k.usd += s.usd;
+      k.tokens.input += s.tokens.input;
+      k.tokens.output += s.tokens.output;
+    }
+    return { spans: all, totalMs: end - start, totalUsd, totalTokens: totalTokens2, byKind };
+  };
+  const render = (opts) => {
+    const { spans: all, totalMs, totalUsd, byKind } = report();
+    if (all.length === 0) return "(no spans observed)";
+    const width = opts?.width ?? 48;
+    const maxRows = opts?.maxRows ?? 60;
+    const start = all[0]?.startMs ?? 0;
     const scale = totalMs > 0 ? width / totalMs : 0;
     const lines = [];
     const labelWidth = Math.min(24, Math.max(...all.map((s) => s.label.length)) + 1);
@@ -6447,15 +9162,29 @@ function jjWorkspace(opts) {
     }
   };
 }
+async function runInWorkspace(ws, body, opts = {}) {
+  const { mkdtempSync, rmSync } = await import("fs");
+  const { tmpdir } = await import("os");
+  const { join: join2 } = await import("path");
+  const dir = mkdtempSync(join2(tmpdir(), opts.tmpPrefix ?? "ws-run-"));
+  try {
+    await ws.materialize(dir);
+    const r = await body(dir);
+    if (r.valid || opts.commitOnInvalid) {
+      const message = r.message ?? (r.valid ? "worker: delivered" : "worker: wip");
+      const commit = await ws.commit(dir, message);
+      return { valid: r.valid, value: r.value, commit };
+    }
+    return { valid: r.valid, value: r.value };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
 function tail(s) {
   return s.slice(-400);
 }
 
 export {
-  deleteBoxSafe,
-  throwAbort,
-  throwIfAborted,
-  sleep,
   contentAddress,
   InMemoryResultBlobStore,
   FileResultBlobStore,
@@ -6471,12 +9200,6 @@ export {
   stopSentinel,
   sentinelCompletion,
   deterministicCompletion,
-  assertTraceDerivedFindings,
-  createScopeAnalyst,
-  registryScopeAnalyst,
-  buildSteerContext,
-  createDriver,
-  renderAnalyses,
   defaultAnalystInstruction,
   observe,
   renderReport,
@@ -6496,6 +9219,11 @@ export {
   defaultSelectWinner,
   loopDispatch,
   createMcpEnvironment,
+  assertTraceDerivedFindings,
+  createScopeAnalyst,
+  registryScopeAnalyst,
+  buildSteerContext,
+  nestedScopeSeamKey,
   createScope,
   settledToIteration,
   pipeline,
@@ -6508,6 +9236,11 @@ export {
   InMemoryCorpus,
   FileCorpus,
   renderCorpusToInstructions,
+  driverRuntime,
+  driverChild,
+  isDriverSpec,
+  driverExecutorFactory,
+  withDriverExecutor,
   routerChatWithUsage,
   routerChatWithTools,
   routerToolLoop,
@@ -6543,10 +9276,69 @@ export {
   pickChampion,
   selectChampion,
   runStrategyEvolution,
+  gateOnDeliverable,
+  asAuthoredProfile,
+  supervisorSkill,
+  authoredWorker,
+  createCoordinationTools,
+  coordinationDriverAgent,
+  InMemoryFeedbackStore,
+  eventToSnapshot,
+  DelegationStateCorruptError,
+  DelegationPersistenceError,
+  InMemoryDelegationStore,
+  FileDelegationStore,
+  DELEGATION_TRACE_MAX_SPANS,
+  DELEGATION_TRACE_MAX_BYTES,
+  buildDelegationTraceSpans,
+  capDelegationTrace,
+  createDelegationTraceCollector,
+  composeLoopTraceEmitters,
+  DelegationTaskQueue,
+  hashIdempotencyInput,
+  formatDetachedSessionRef,
+  parseDetachedSessionRef,
+  detachedTurnEvents,
+  runDetachedTurn,
+  createDriveTurnResumeDriver,
+  DELEGATE_CODE_TOOL_NAME,
+  DELEGATE_CODE_DESCRIPTION,
+  DELEGATE_CODE_INPUT_SCHEMA,
+  validateDelegateCodeArgs,
+  createDelegateCodeHandler,
+  DELEGATE_FEEDBACK_TOOL_NAME,
+  DELEGATE_FEEDBACK_DESCRIPTION,
+  DELEGATE_FEEDBACK_INPUT_SCHEMA,
+  validateDelegateFeedbackArgs,
+  createDelegateFeedbackHandler,
+  DELEGATE_RESEARCH_TOOL_NAME,
+  DELEGATE_RESEARCH_DESCRIPTION,
+  DELEGATE_RESEARCH_INPUT_SCHEMA,
+  validateDelegateResearchArgs,
+  createDelegateResearchHandler,
+  DELEGATE_UI_AUDIT_TOOL_NAME,
+  DELEGATE_UI_AUDIT_DESCRIPTION,
+  DELEGATE_UI_AUDIT_INPUT_SCHEMA,
+  validateDelegateUiAuditArgs,
+  createDelegateUiAuditHandler,
+  DELEGATION_HISTORY_TOOL_NAME,
+  DELEGATION_HISTORY_DESCRIPTION,
+  DELEGATION_HISTORY_INPUT_SCHEMA,
+  validateDelegationHistoryArgs,
+  createDelegationHistoryHandler,
+  DELEGATION_STATUS_TOOL_NAME,
+  DELEGATION_STATUS_DESCRIPTION,
+  DELEGATION_STATUS_INPUT_SCHEMA,
+  validateDelegationStatusArgs,
+  createDelegationStatusHandler,
+  createMcpServer,
+  createInProcessTransport,
+  serveCoordinationMcp,
   createVerifierEnvironment,
   createWaterfallCollector,
   localShell,
   gitWorkspace,
-  jjWorkspace
+  jjWorkspace,
+  runInWorkspace
 };
-//# sourceMappingURL=chunk-2OU7ZQPD.js.map
+//# sourceMappingURL=chunk-JTH2FPCK.js.map