@tangle-network/agent-runtime 0.56.0 → 0.57.0

package/dist/{chunk-ZADWPBOE.js → chunk-RLDUT4JL.js}

@@ -1,6 +1,6 @@
 import {
   runCoderChecks
-} from "./chunk-3BI6PSP3.js";
+} from "./chunk-7QYOXFCD.js";
 import {
   UI_LENSES
 } from "./chunk-WIR4HOOJ.js";
@@ -305,8 +305,8 @@ var FileSpawnJournal = class {
   }
 };
 function assertSeqUnique(root, events, ev) {
-  if (ev.kind === "spawned") return;
-  if (events.some((e) => e.kind !== "spawned" && e.seq === ev.seq)) {
+  if (ev.kind === "spawned" || ev.kind === "metered") return;
+  if (events.some((e) => e.kind !== "spawned" && e.kind !== "metered" && e.seq === ev.seq)) {
     throw new Error(
       `spawn journal corrupted: duplicate cursor seq ${ev.seq} in tree '${root}'; the cursor order replay relies on is not unique`
     );
@@ -325,6 +325,7 @@ async function replaySpawnTree(journal, blobs, root) {
   const settled = [];
   for (const ev of ordered) {
     if (ev.kind === "spawned") continue;
+    if (ev.kind === "metered") continue;
     if (ev.kind === "cancelled") {
       settled.push({
         kind: "down",
@@ -384,7 +385,7 @@ function materializeTreeView(events) {
   const nodes = /* @__PURE__ */ new Map();
   let root;
   const spawns = events.filter((ev) => ev.kind === "spawned").sort((a, b) => a.seq - b.seq);
-  const settlements = events.filter((ev) => ev.kind !== "spawned").sort((a, b) => a.seq - b.seq);
+  const settlements = events.filter((ev) => ev.kind !== "spawned" && ev.kind !== "metered").sort((a, b) => a.seq - b.seq);
   for (const ev of spawns) {
     if (ev.parent === void 0 && root === void 0) root = ev.id;
     nodes.set(ev.id, {
@@ -408,6 +409,11 @@ function materializeTreeView(events) {
       node.status = "cancelled";
     }
   }
+  for (const ev of events) {
+    if (ev.kind !== "metered") continue;
+    const node = requireNode(nodes, ev.id);
+    node.spent = addJournalSpend(node.spent, ev.spend);
+  }
   const snapshots = [...nodes.values()].map(freezeSnapshot);
   return {
     root: root ?? snapshots[0]?.id ?? "",
@@ -418,6 +424,14 @@ function materializeTreeView(events) {
 function zeroSpend() {
   return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
 }
+function addJournalSpend(a, b) {
+  return {
+    iterations: a.iterations + b.iterations,
+    tokens: { input: a.tokens.input + b.tokens.input, output: a.tokens.output + b.tokens.output },
+    usd: a.usd + b.usd,
+    ms: a.ms + b.ms
+  };
+}
 function requireNode(nodes, id) {
   const node = nodes.get(id);
   if (!node) {
@@ -2130,6 +2144,7 @@ function createScope(args) {
   const children = /* @__PURE__ */ new Map();
   let spawnOrdinal = 0;
   let cursorSeq = 0;
+  let meterSeq = 0;
   const now = args.now ?? Date.now;
   function spawn4(agent, task, opts) {
     if (args.maxDepth !== void 0 && args.depth >= args.maxDepth) {
@@ -2257,10 +2272,36 @@ function createScope(args) {
     child.deliver(msg);
     return true;
   }
+  async function meter(spend, detail) {
+    const seq = meterSeq++;
+    args.pool.observe(spend);
+    await args.journal.appendEvent(args.root, {
+      kind: "metered",
+      id: args.parentId,
+      spend,
+      seq,
+      at: new Date(now()).toISOString()
+    });
+    notifyRuntimeHookEvent(
+      args.hooks,
+      {
+        id: `${args.parentId}:meter:${seq}`,
+        runId: args.root,
+        target: "agent.turn",
+        phase: "after",
+        timestamp: now(),
+        parentId: args.parentId,
+        payload: { spend, ...detail ?? {} }
+      },
+      { signal: args.signal }
+    );
+  }
   return {
     spawn: spawn4,
     next,
     send,
+    signal: args.signal,
+    meter,
     get view() {
       return makeTreeView(args.parentId, children);
     },
@@ -2285,6 +2326,15 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
       seq,
       at: new Date(now()).toISOString()
     });
+    if (settlement.metered) {
+      await args.journal.appendEvent(args.root, {
+        kind: "metered",
+        id: child.id,
+        spend: settlement.metered,
+        seq,
+        at: new Date(now()).toISOString()
+      });
+    }
     notifyRuntimeHookEvent(
       args.hooks,
       {
@@ -2327,6 +2377,15 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
     seq,
     at: new Date(now()).toISOString()
   });
+  if (settlement.metered) {
+    await args.journal.appendEvent(args.root, {
+      kind: "metered",
+      id: child.id,
+      spend: settlement.metered,
+      seq,
+      at: new Date(now()).toISOString()
+    });
+  }
   notifyRuntimeHookEvent(
     args.hooks,
     {
@@ -2380,9 +2439,10 @@ async function runChild(live, executor, childAbort, task, opts, pool2, ticket, b
       artifact = terminal;
       reconcileOnce(terminal.spent);
     }
+    const ownMetered = executor.metered?.();
     if (childAbort.signal.aborted) {
       await teardownSafe(executor, opts.shutdown ?? "brutalKill");
-      return downRecord("aborted before settle", true);
+      return downRecord("aborted before settle", true, ownMetered);
     }
     const outRef = contentAddress(artifact.out);
     await blobs.put(outRef, artifact.out);
@@ -2392,13 +2452,14 @@ async function runChild(live, executor, childAbort, task, opts, pool2, ticket, b
       out: artifact.out,
       outRef,
       ...artifact.verdict ? { verdict: artifact.verdict } : {},
-      spent: live.spent
+      spent: live.spent,
+      ...ownMetered ? { metered: ownMetered } : {}
     };
   } catch (err) {
     reconcileOnce(live.spent);
     await teardownSafe(executor, "brutalKill");
     const aborted = childAbort.signal.aborted || isAbortError2(err);
-    return downRecord(errMessage(err), aborted || isInfraError(err));
+    return downRecord(errMessage(err), aborted || isInfraError(err), executor.metered?.());
   }
 }
 function settledToIteration(settled) {
@@ -2485,8 +2546,8 @@ async function teardownSafe(executor, grace) {
   } catch {
   }
 }
-function downRecord(reason, infra) {
-  return { kind: "down", reason, infra, restartCount: 0 };
+function downRecord(reason, infra, metered) {
+  return { kind: "down", reason, infra, restartCount: 0, ...metered ? { metered } : {} };
 }
 function zeroSpend2() {
   return { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
@@ -3078,23 +3139,33 @@ var driverExecutorFactory = (spec, ctx) => {
   const journal = spec.journal;
   const seam = readNestedScopeSeam(ctx);
   let artifact;
+  let meteredSpend;
   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;
+      try {
+        const out = await driver.act(task, nestedScope);
+        const events = await loadTreeEvents(journal, nestedRoot);
+        const settled = events.filter(isSettled);
+        meteredSpend = nonZeroOrUndef(sumMetered(events));
+        const verdict = deriveDeliveryVerdict(settled);
+        artifact = {
+          outRef: `${driverRuntime}:${nestedRoot}`,
+          out,
+          spent: sumSpend(settled),
+          ...verdict ? { verdict } : {}
+        };
+        return artifact;
+      } catch (err) {
+        meteredSpend = await safeSumMetered(journal, nestedRoot);
+        throw err;
+      }
+    },
+    metered() {
+      return meteredSpend;
     },
     teardown() {
       return Promise.resolve({ destroyed: true });
@@ -3131,16 +3202,17 @@ function nextNestOrdinal(journal) {
   }
   return c.n++;
 }
-async function loadSettled(journal, nestedRoot) {
+async function loadTreeEvents(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"
-  );
+  return events;
+}
+function isSettled(ev) {
+  return ev.kind === "settled";
 }
 function sumSpend(settled) {
   const total = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
@@ -3153,6 +3225,31 @@ function sumSpend(settled) {
   }
   return total;
 }
+function sumMetered(events) {
+  const total = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
+  for (const ev of events) {
+    if (ev.kind !== "metered") continue;
+    total.iterations += ev.spend.iterations;
+    total.tokens.input += ev.spend.tokens.input;
+    total.tokens.output += ev.spend.tokens.output;
+    total.usd += ev.spend.usd;
+    total.ms += ev.spend.ms;
+  }
+  return total;
+}
+function isNonZeroSpend(s) {
+  return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0;
+}
+function nonZeroOrUndef(s) {
+  return isNonZeroSpend(s) ? s : void 0;
+}
+async function safeSumMetered(journal, nestedRoot) {
+  try {
+    return nonZeroOrUndef(sumMetered(await loadTreeEvents(journal, nestedRoot)));
+  } catch {
+    return void 0;
+  }
+}
 function deriveDeliveryVerdict(settled) {
   let sawChild = false;
   let anyValid = false;
@@ -3326,10 +3423,57 @@ async function routerToolLoop(cfg, system, user, tools, execute, opts) {
   return { final: lastText, turns: maxTurns, toolCalls, toolTrace, usage, messages };
 }
 
+// src/runtime/supervise/inbox.ts
+function parseDown(msg) {
+  if (!msg || typeof msg !== "object") return void 0;
+  const m = msg;
+  const interrupt = m.interrupt === true;
+  if (typeof m.steer === "string") return { kind: "steer", text: m.steer, interrupt };
+  if (typeof m.answer === "string")
+    return {
+      kind: "answer",
+      text: m.answer,
+      interrupt,
+      ...typeof m.questionId === "string" ? { questionId: m.questionId } : {}
+    };
+  return void 0;
+}
+function createInbox() {
+  const pending = [];
+  let live = null;
+  return {
+    deliver(msg) {
+      const m = parseDown(msg);
+      if (!m) return;
+      pending.push(m);
+      if (m.interrupt && live && !live.signal.aborted) live.abort();
+    },
+    drain() {
+      return pending.splice(0, pending.length);
+    },
+    pending: () => pending.length,
+    freshInterrupt() {
+      live = new AbortController();
+      return live.signal;
+    },
+    fold(messages) {
+      const lines = messages.map((m) => {
+        if (m.kind === "answer")
+          return `- Answer to your question${m.questionId ? ` (${m.questionId})` : ""}: ${m.text}`;
+        return `- New instruction from your supervisor: ${m.text}`;
+      });
+      return `[SUPERVISOR] Out-of-band message(s) \u2014 address these before continuing:
+${lines.join("\n")}`;
+    }
+  };
+}
+
 // src/runtime/supervise/worktree-cli-executor.ts
-import { spawn as spawn2 } from "child_process";
 import { randomUUID } from "crypto";
 
+// src/mcp/worktree-harness.ts
+import { spawn as spawn2 } from "child_process";
+
 // src/mcp/worktree.ts
 import { spawn } from "child_process";
 async function runGitAsync(args, cwd, runner) {
@@ -3411,8 +3555,115 @@ async function removeWorktree(options) {
   ).catch(() => void 0);
 }
 
+// src/mcp/worktree-harness.ts
+var defaultCheckOutputCap = 16e3;
+async function runWorktreeHarness(opts) {
+  const runHarness = opts.runHarness ?? runLocalHarness;
+  const runCommand = opts.runCommand ?? defaultRunCommand;
+  const checkTimeoutMs = opts.checkTimeoutMs ?? opts.harnessTimeoutMs ?? 5 * 60 * 1e3;
+  const cap = opts.checkOutputCap ?? defaultCheckOutputCap;
+  const worktree = await createWorktree({
+    repoRoot: opts.repoRoot,
+    runId: opts.runId,
+    ...opts.baseRef ? { baseRef: opts.baseRef } : {},
+    ...opts.runGit ? { runGit: opts.runGit } : {}
+  });
+  const cleanup = () => removeWorktree({
+    worktree,
+    repoRoot: opts.repoRoot,
+    ...opts.runGit ? { runGit: opts.runGit } : {}
+  }).catch(() => void 0);
+  try {
+    const { command, args } = harnessInvocation(opts.harness, opts.profile, opts.taskPrompt);
+    const harnessResult = await runHarness({
+      harness: opts.harness,
+      cwd: worktree.path,
+      taskPrompt: opts.taskPrompt,
+      invocation: { command, args },
+      ...opts.harnessTimeoutMs !== void 0 ? { timeoutMs: opts.harnessTimeoutMs } : {},
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+    const diff = await captureWorktreeDiff({
+      worktree,
+      ...opts.runGit ? { runGit: opts.runGit } : {}
+    });
+    const checks = await runChecks({
+      worktreePath: worktree.path,
+      ...opts.testCmd !== void 0 ? { testCmd: opts.testCmd } : {},
+      ...opts.typecheckCmd !== void 0 ? { typecheckCmd: opts.typecheckCmd } : {},
+      timeoutMs: checkTimeoutMs,
+      cap,
+      runCommand,
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+    const result = {
+      branch: worktree.branch,
+      patch: diff.patch,
+      stats: diff.stats,
+      harness: {
+        name: opts.harness,
+        exitCode: harnessResult.exitCode,
+        timedOut: harnessResult.timedOut,
+        killedBySignal: harnessResult.killedBySignal,
+        durationMs: harnessResult.durationMs,
+        stdout: harnessResult.stdout,
+        stderr: harnessResult.stderr
+      },
+      ...checks ? { checks } : {}
+    };
+    return { worktree, result, cleanup };
+  } catch (err) {
+    await cleanup();
+    throw err;
+  }
+}
+async function runChecks(opts) {
+  if (opts.testCmd === void 0 && opts.typecheckCmd === void 0) return void 0;
+  const run = async (command) => {
+    const res = await opts.runCommand({
+      command,
+      cwd: opts.worktreePath,
+      timeoutMs: opts.timeoutMs,
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+    return {
+      command,
+      passed: res.exitCode === 0,
+      exitCode: res.exitCode,
+      output: res.output.length > opts.cap ? res.output.slice(-opts.cap) : res.output
+    };
+  };
+  const checks = {};
+  if (opts.testCmd !== void 0) checks.tests = await run(opts.testCmd);
+  if (opts.typecheckCmd !== void 0) checks.typecheck = await run(opts.typecheckCmd);
+  return checks;
+}
+function defaultRunCommand(opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2("/bin/sh", ["-c", opts.command], {
+      cwd: opts.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const chunks = [];
+    let settled = false;
+    const timer = setTimeout(() => child.kill("SIGTERM"), opts.timeoutMs);
+    const onAbort = () => child.kill("SIGTERM");
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout?.on("data", (d) => chunks.push(String(d)));
+    child.stderr?.on("data", (d) => chunks.push(String(d)));
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
+      fn();
+    };
+    child.on("error", (err) => finish(() => reject(err)));
+    child.on("close", (code) => finish(() => resolve({ exitCode: code, output: chunks.join("") })));
+  });
+}
+
 // src/runtime/supervise/worktree-cli-executor.ts
-var checkOutputCap = 16e3;
 function createWorktreeCliExecutor(options) {
   if (!options.repoRoot) {
     throw new ValidationError("createWorktreeCliExecutor: repoRoot required");
@@ -3424,22 +3675,9 @@ function createWorktreeCliExecutor(options) {
     throw new ValidationError("createWorktreeCliExecutor: taskPrompt required");
   }
   const runId = options.runId ?? randomUUID();
-  const runHarness = options.runHarness ?? runLocalHarness;
-  const runCommand = options.runCommand ?? defaultRunCommand;
-  const checkTimeoutMs = options.checkTimeoutMs ?? options.harnessTimeoutMs ?? 5 * 60 * 1e3;
   const controller = new AbortController();
-  let worktree;
+  let run;
   let artifact;
-  const removeIfPresent = async () => {
-    if (!worktree) return;
-    const wt = worktree;
-    worktree = void 0;
-    await removeWorktree({
-      worktree: wt,
-      repoRoot: options.repoRoot,
-      ...options.runGit ? { runGit: options.runGit } : {}
-    }).catch(() => void 0);
-  };
   return {
     runtime: "cli",
     // A harness CLI cannot account tokens — exclude it from the conserved pool + equal-k.
@@ -3447,52 +3685,22 @@ function createWorktreeCliExecutor(options) {
     async execute(_task, signal) {
       const linked = linkSignals(signal, controller.signal);
       const started = Date.now();
-      worktree = await createWorktree({
+      run = await runWorktreeHarness({
         repoRoot: options.repoRoot,
-        runId,
-        ...options.baseRef ? { baseRef: options.baseRef } : {},
-        ...options.runGit ? { runGit: options.runGit } : {}
-      });
-      const { command, args } = harnessInvocation(
-        options.harness,
-        options.profile,
-        options.taskPrompt
-      );
-      const harnessResult = await runHarness({
+        profile: options.profile,
         harness: options.harness,
-        cwd: worktree.path,
         taskPrompt: options.taskPrompt,
-        invocation: { command, args },
-        ...options.harnessTimeoutMs !== void 0 ? { timeoutMs: options.harnessTimeoutMs } : {},
-        ...linked ? { signal: linked } : {}
-      });
-      const checks = await runWorktreeChecks({
-        worktreePath: worktree.path,
+        runId,
+        ...options.baseRef ? { baseRef: options.baseRef } : {},
         ...options.testCmd !== void 0 ? { testCmd: options.testCmd } : {},
         ...options.typecheckCmd !== void 0 ? { typecheckCmd: options.typecheckCmd } : {},
-        timeoutMs: checkTimeoutMs,
-        runCommand,
-        ...linked ? { signal: linked } : {}
-      });
-      const diff = await captureWorktreeDiff({
-        worktree,
-        ...options.runGit ? { runGit: options.runGit } : {}
+        ...options.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: options.harnessTimeoutMs } : {},
+        ...options.checkTimeoutMs !== void 0 ? { checkTimeoutMs: options.checkTimeoutMs } : {},
+        ...linked ? { signal: linked } : {},
+        ...options.runGit ? { runGit: options.runGit } : {},
+        ...options.runHarness ? { runHarness: options.runHarness } : {},
+        ...options.runCommand ? { runCommand: options.runCommand } : {}
       });
-      const out = {
-        branch: worktree.branch,
-        patch: diff.patch,
-        stats: diff.stats,
-        harness: {
-          name: options.harness,
-          exitCode: harnessResult.exitCode,
-          timedOut: harnessResult.timedOut,
-          killedBySignal: harnessResult.killedBySignal,
-          durationMs: harnessResult.durationMs,
-          stdout: harnessResult.stdout,
-          stderr: harnessResult.stderr
-        },
-        ...checks ? { checks } : {}
-      };
       const spent = {
         iterations: 1,
         // budgetExempt: spend is recorded zero (not metered), never a fabricated cost.
@@ -3500,12 +3708,16 @@ function createWorktreeCliExecutor(options) {
         usd: 0,
         ms: Date.now() - started
       };
-      artifact = { outRef: contentAddress(out), out, spent };
+      artifact = { outRef: contentAddress(run.result), out: run.result, spent };
       return artifact;
     },
     async teardown(_grace) {
       controller.abort();
-      await removeIfPresent();
+      if (run) {
+        const r = run;
+        run = void 0;
+        await r.cleanup();
+      }
       return { destroyed: true };
     },
     resultArtifact() {
@@ -3518,51 +3730,6 @@ function createWorktreeCliExecutor(options) {
     }
   };
 }
-async function runWorktreeChecks(opts) {
-  if (opts.testCmd === void 0 && opts.typecheckCmd === void 0) return void 0;
-  const run = async (command) => {
-    const res = await opts.runCommand({
-      command,
-      cwd: opts.worktreePath,
-      timeoutMs: opts.timeoutMs,
-      ...opts.signal ? { signal: opts.signal } : {}
-    });
-    return {
-      command,
-      passed: res.exitCode === 0,
-      exitCode: res.exitCode,
-      output: res.output.length > checkOutputCap ? res.output.slice(-checkOutputCap) : res.output
-    };
-  };
-  const checks = {};
-  if (opts.testCmd !== void 0) checks.tests = await run(opts.testCmd);
-  if (opts.typecheckCmd !== void 0) checks.typecheck = await run(opts.typecheckCmd);
-  return checks;
-}
-function defaultRunCommand(opts) {
-  return new Promise((resolve, reject) => {
-    const child = spawn2("/bin/sh", ["-c", opts.command], {
-      cwd: opts.cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const chunks = [];
-    let settled = false;
-    const timer = setTimeout(() => child.kill("SIGTERM"), opts.timeoutMs);
-    const onAbort = () => child.kill("SIGTERM");
-    opts.signal?.addEventListener("abort", onAbort, { once: true });
-    child.stdout?.on("data", (d) => chunks.push(String(d)));
-    child.stderr?.on("data", (d) => chunks.push(String(d)));
-    const finish = (fn) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      opts.signal?.removeEventListener("abort", onAbort);
-      fn();
-    };
-    child.on("error", (err) => finish(() => reject(err)));
-    child.on("close", (code) => finish(() => resolve({ exitCode: code, output: chunks.join("") })));
-  });
-}
 function linkSignals(a, b) {
   if (a.aborted || b.aborted) {
     const c2 = new AbortController();
@@ -3671,35 +3838,59 @@ var routerToolsInlineExecutor = (spec, ctx) => {
   };
   abortIfSignalled();
   if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+  const inbox = createInbox();
   let artifact;
   return {
     runtime: "router",
+    deliver: (m) => inbox.deliver(m),
     async execute(task, signal) {
       const started = Date.now();
-      const linked = linkSignals2(signal, controller.signal);
       const messages = [
         ...taskToMessages(task, spec)
       ];
       const tokens = zeroTokenUsage();
       let turns = 0;
       let lastText = "";
+      const flush = () => {
+        const pending = inbox.drain();
+        if (pending.length) messages.push({ role: "user", content: inbox.fold(pending) });
+        return pending.length > 0;
+      };
+      const external = mergeAbortSignals(signal, controller.signal);
       for (let t = 0; t < maxTurns; t += 1) {
+        flush();
+        const interruptSig = inbox.freshInterrupt();
+        const turnController = new AbortController();
+        const abortTurn = () => turnController.abort();
+        if (external.aborted) turnController.abort();
+        else external.addEventListener("abort", abortTurn);
+        interruptSig.addEventListener("abort", abortTurn, { once: true });
+        const cleanup = () => external.removeEventListener("abort", abortTurn);
+        let res;
+        try {
+          res = await fetch(`${seam.routerBaseUrl.replace(/\/$/, "")}/chat/completions`, {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              authorization: `Bearer ${seam.routerKey}`
+            },
+            body: JSON.stringify({
+              model,
+              messages,
+              tools: seam.tools,
+              tool_choice: "auto",
+              temperature: 0.2
+            }),
+            signal: turnController.signal
+          });
+        } catch (e) {
+          cleanup();
+          const interruptAbort = e instanceof DOMException && e.name === "AbortError" && interruptSig.aborted && !signal.aborted && !controller.signal.aborted;
+          if (interruptAbort) continue;
+          throw e;
+        }
+        cleanup();
         turns += 1;
-        const res = await fetch(`${seam.routerBaseUrl.replace(/\/$/, "")}/chat/completions`, {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-            authorization: `Bearer ${seam.routerKey}`
-          },
-          body: JSON.stringify({
-            model,
-            messages,
-            tools: seam.tools,
-            tool_choice: "auto",
-            temperature: 0.2
-          }),
-          ...linked ? { signal: linked } : {}
-        });
         if (!res.ok) {
           throw new ValidationError(
             `routerToolsInlineExecutor: router ${res.status}: ${(await res.text()).slice(0, 200)}`
@@ -3714,7 +3905,10 @@ var routerToolsInlineExecutor = (spec, ctx) => {
         const msg = data.choices?.[0]?.message;
         if (msg?.content) lastText = msg.content;
         const toolCalls = msg?.tool_calls ?? [];
-        if (toolCalls.length === 0) break;
+        if (toolCalls.length === 0) {
+          if (flush()) continue;
+          break;
+        }
         messages.push({
           role: "assistant",
           content: msg?.content ?? "",
@@ -3738,8 +3932,20 @@ var routerToolsInlineExecutor = (spec, ctx) => {
             });
             continue;
           }
-          const result = await seam.executeToolCall(tc?.function?.name ?? "", args, task);
+          const toolName = tc?.function?.name ?? "";
+          let result;
+          let status = "ok";
+          try {
+            result = await seam.executeToolCall(toolName, args, task);
+          } catch (e) {
+            status = "error";
+            result = `error: ${e instanceof Error ? e.message : String(e)}`;
+          }
           messages.push({ role: "tool", tool_call_id: id, content: result });
+          try {
+            seam.onToolStep?.({ toolName, args, status });
+          } catch {
+          }
         }
       }
       const usd = isModelPriced2(model) ? estimateCost2(tokens.input, tokens.output, model) : 0;
@@ -4171,6 +4377,18 @@ function linkSignals2(a, b) {
   b.addEventListener("abort", onAbort, { once: true });
   return c.signal;
 }
+function mergeAbortSignals(...signals) {
+  const c = new AbortController();
+  const onAbort = () => c.abort();
+  for (const s of signals) {
+    if (s.aborted) {
+      c.abort();
+      break;
+    }
+    s.addEventListener("abort", onAbort, { once: true });
+  }
+  return c.signal;
+}
 
 // src/runtime/supervise/budget.ts
 function spendFromUsageEvents(events) {
@@ -4279,10 +4497,20 @@ function createBudgetPool(root, now = Date.now) {
       committedUsd += spent.usd;
     }
   }
+  function observe2(spend) {
+    const tokens = totalTokens(spend.tokens);
+    freeTokens -= tokens;
+    committedTokens += tokens;
+    freeIterations -= spend.iterations;
+    committedIterations += spend.iterations;
+    committedUsd += spend.usd;
+    if (usdCapped) freeUsd -= spend.usd;
+  }
   function readout() {
     return {
       tokensLeft: freeTokens,
       usdLeft: usdCapped ? freeUsd : 0,
+      usdCapped,
       deadlineMs: absoluteDeadlineMs,
       reservedTokens
     };
@@ -4299,6 +4527,7 @@ function createBudgetPool(root, now = Date.now) {
     reconcile,
     spendFrom: foldUsage,
     readout,
+    observe: observe2,
     assertNoOpenTickets
   };
 }
@@ -4368,12 +4597,14 @@ function createSupervisor() {
       if (out !== void 0) {
         const outRef = contentAddress(out);
         await opts.blobs.put(outRef, out);
+        const { childWork, driverInference } = await spentFromJournal(journal, opts.runId);
         return {
           kind: "winner",
           out,
           outRef,
           tree,
-          spentTotal: await spentTotalFromJournal(journal, opts.runId)
+          spentTotal: addSpend(childWork, driverInference),
+          ...isNonEmptySpend(driverInference) ? { spentBreakdown: { driverInference, childWork } } : {}
         };
       }
       return {
@@ -4505,23 +4736,38 @@ function poolExhausted(pool2, opts) {
   }
   return false;
 }
-async function spentTotalFromJournal(journal, root) {
+async function spentFromJournal(journal, root) {
   const events = await journal.loadTree(root);
   if (events === void 0) {
     throw new RuntimeRunStateError(
       `supervisor: spawn tree '${root}' is missing from the journal after run (corrupted log)`
     );
   }
-  const total = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
+  const childWork = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
+  const driverInference = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
   for (const ev of events) {
-    if (ev.kind !== "settled") continue;
-    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;
+    if (ev.kind === "settled") accumulate(childWork, ev.spent);
+    else if (ev.kind === "metered") accumulate(driverInference, ev.spend);
   }
-  return total;
+  return { childWork, driverInference };
+}
+function accumulate(a, b) {
+  a.iterations += b.iterations;
+  a.tokens.input += b.tokens.input;
+  a.tokens.output += b.tokens.output;
+  a.usd += b.usd;
+  a.ms += b.ms;
+}
+function addSpend(a, b) {
+  return {
+    iterations: a.iterations + b.iterations,
+    tokens: { input: a.tokens.input + b.tokens.input, output: a.tokens.output + b.tokens.output },
+    usd: a.usd + b.usd,
+    ms: a.ms + b.ms
+  };
+}
+function isNonEmptySpend(s) {
+  return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0;
 }
 
 // src/runtime/personify/registry.ts
@@ -4680,7 +4926,7 @@ async function trajectoryReport(journal, blobs, root, options = {}) {
     throw new Error(`trajectoryReport: no journaled tree for root '${root}'`);
   }
   const spawns = events.filter(isSpawned).sort(bySeq);
-  const closes = events.filter((ev) => ev.kind !== "spawned").sort(bySeq);
+  const closes = events.filter((ev) => ev.kind !== "spawned" && ev.kind !== "metered").sort(bySeq);
   const nodes = /* @__PURE__ */ new Map();
   for (const ev of spawns) {
     nodes.set(ev.id, {
@@ -4704,6 +4950,11 @@ async function trajectoryReport(journal, blobs, root, options = {}) {
     node.verdict = ev.verdict;
     node.outRef = ev.outRef;
   }
+  for (const ev of events) {
+    if (ev.kind !== "metered") continue;
+    const node = requireNode2(nodes, ev.id, root);
+    node.ownSpend = addNodeSpend(node.ownSpend, ev.spend);
+  }
   if (!nodes.has(root)) {
     throw new Error(
       `trajectoryReport: root '${root}' has no spawned event in its journaled tree (corrupted log)`
@@ -4766,7 +5017,7 @@ function rollUpSpend(nodes, root) {
       continue;
     }
     const sum = cloneSpend(node.ownSpend);
-    for (const child of node.children) addSpend(sum, requireSpend(rolled, child, root));
+    for (const child of node.children) addSpend2(sum, requireSpend(rolled, child, root));
     rolled.set(frame.id, sum);
   }
   return rolled;
@@ -4811,6 +5062,14 @@ function countStatuses(reported) {
 function zeroSpend4() {
   return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
 }
+function addNodeSpend(a, b) {
+  return {
+    iterations: a.iterations + b.iterations,
+    tokens: { input: a.tokens.input + b.tokens.input, output: a.tokens.output + b.tokens.output },
+    usd: a.usd + b.usd,
+    ms: a.ms + b.ms
+  };
+}
 function cloneSpend(spend) {
   return {
     iterations: spend.iterations,
@@ -4819,7 +5078,7 @@ function cloneSpend(spend) {
     ms: spend.ms
   };
 }
-function addSpend(acc, delta) {
+function addSpend2(acc, delta) {
   acc.iterations += delta.iterations;
   addTokenUsage(acc.tokens, delta.tokens);
   acc.usd += delta.usd;
@@ -6569,7 +6828,7 @@ function supervisorSkill(opts) {
     '   \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.",
+    "3. await_event (kinds:['settled']) 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}`] : []
@@ -6708,6 +6967,62 @@ function isArtifact(value) {
   return value !== null && typeof value === "object" && typeof value.patch === "string" && typeof value.stats === "object";
 }
 
+// src/runtime/supervise/event-bus.ts
+function createEventBus(now = Date.now) {
+  const queue = [];
+  const log = [];
+  const subscribers = [];
+  const byKind = {};
+  let seq = 0;
+  let pulled = 0;
+  const matches = (r, kinds) => !kinds || kinds.includes(r.event.type);
+  const bestIndex = (kinds) => {
+    let best = -1;
+    let bestPriority = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < queue.length; i++) {
+      const r = queue[i];
+      if (!r || !matches(r, kinds)) continue;
+      if (r.priority > bestPriority) {
+        best = i;
+        bestPriority = r.priority;
+      }
+    }
+    return best;
+  };
+  return {
+    async publish(event, opts) {
+      const record = { seq: seq++, at: now(), priority: opts?.priority ?? 0, event };
+      if (opts?.queue !== false) queue.push(record);
+      log.push(record);
+      byKind[event.type] = (byKind[event.type] ?? 0) + 1;
+      for (const handler of subscribers) await handler(record);
+      return record;
+    },
+    pull(kinds) {
+      const i = bestIndex(kinds);
+      if (i < 0) return void 0;
+      pulled++;
+      return queue.splice(i, 1)[0]?.event;
+    },
+    subscribe(handler) {
+      subscribers.push(handler);
+      return () => {
+        const i = subscribers.indexOf(handler);
+        if (i >= 0) subscribers.splice(i, 1);
+      };
+    },
+    pending(kinds) {
+      return kinds ? queue.filter((r) => matches(r, kinds)).length : queue.length;
+    },
+    history() {
+      return log;
+    },
+    stats() {
+      return { published: seq, pulled, byKind: { ...byKind } };
+    }
+  };
+}
+
 // src/mcp/tools/coordination.ts
 var idArg = { type: "string", description: "The workerId returned by spawn_worker." };
 function createCoordinationTools(opts) {
@@ -6717,6 +7032,12 @@ function createCoordinationTools(opts) {
   const ledger = [];
   const questions = [];
   const questionPolicy = opts.questionPolicy ?? "auto";
+  const bus = createEventBus();
+  if (opts.onEvent) {
+    const cb = opts.onEvent;
+    bus.subscribe((rec) => cb(rec.event));
+  }
+  const urgencyPriority = (u) => u === "blocks-run" ? 20 : u === "blocks-step" ? 10 : 0;
   const str = (v, field) => {
     if (typeof v !== "string" || v.length === 0)
       throw new Error(`coordination tools: "${field}" must be a non-empty string`);
@@ -6748,6 +7069,43 @@ function createCoordinationTools(opts) {
     ledger.push(w);
     return w;
   };
+  const drainSettlement = async () => {
+    const s = await opts.scope.next();
+    if (!s) return false;
+    const w = recordSettled(s);
+    await bus.publish({ type: "settled", worker: w });
+    if (w.status === "done" && w.outRef && opts.analysts && opts.analyzeOnSettle?.length) {
+      const trace = await opts.blobs.get(w.outRef);
+      for (const analyst of opts.analyzeOnSettle) {
+        const findings = await opts.analysts.run(analyst, trace);
+        await bus.publish({ type: "finding", finding: { fromWorker: w.id, analyst, findings } });
+      }
+    }
+    return true;
+  };
+  async function sendDown(type, down, questionId) {
+    await bus.publish(
+      type === "answer" ? { type, down, questionId: str(questionId, "questionId") } : { type, down },
+      { queue: false }
+    );
+  }
+  const projectEvent = (ev) => {
+    if (ev.type === "settled") {
+      const w = ev.worker;
+      return w.status === "done" ? {
+        type: "settled",
+        settled: w.id,
+        status: "done",
+        score: w.score,
+        valid: w.valid,
+        outRef: w.outRef
+      } : { type: "settled", settled: w.id, status: "down", reason: w.reason };
+    }
+    if (ev.type === "question") return { type: "question", question: ev.question };
+    if (ev.type === "finding") return { type: "finding", ...ev.finding };
+    if (ev.type === "answer") return { type: "answer", ...ev.down, questionId: ev.questionId };
+    return { type: ev.type, ...ev.down };
+  };
   const nextQuestionId = (from) => `${from}:q${questionSeq++}`;
   const normalizeQuestion = (q, fallbackFrom) => {
     const from = str(q.from ?? fallbackFrom, "from");
@@ -6781,7 +7139,11 @@ function createCoordinationTools(opts) {
     return { question: record, added: true };
   };
   const emitNewQuestion = async (record) => {
-    if (record.added) await opts.onEvent?.({ type: "question", question: record.question });
+    if (record.added)
+      await bus.publish(
+        { type: "question", question: record.question },
+        { priority: urgencyPriority(record.question.urgency) }
+      );
     return record.question;
   };
   const decideQuestion = (questionId, decision) => {
@@ -6844,38 +7206,52 @@ function createCoordinationTools(opts) {
     },
     {
       name: "steer_worker",
-      description: "Deliver an out-of-band instruction to a running worker inbox.",
+      description: "Send a message DOWN to a still-LIVE worker (parent\u2192child): a new instruction, a course correction, or a continuation. The worker drains it at its next step boundary \u2014 and before it may settle, so it cannot finish while a message it never read is pending. A worker that already settled is gone (returns delivered:false) \u2014 spawn a fresh one instead.",
       inputSchema: {
         type: "object",
         properties: {
           workerId: idArg,
-          instruction: { type: "string", description: "What the worker should do next." }
+          instruction: { type: "string", description: "What the worker should do next." },
+          interrupt: {
+            type: "boolean",
+            description: "true = forceful: abort the worker\u2019s in-flight inference so it re-plans on the NEXT turn (a tool already mid-execution finishes first; only the owned tool-loop honors this). false/omitted = queued: it flushes at the next step boundary (and before it may settle)."
+          }
         },
         required: ["workerId", "instruction"]
       },
-      handler: (raw) => {
+      handler: async (raw) => {
         const a = obj(raw);
-        const delivered = opts.scope.send(str(a.workerId, "workerId"), {
-          steer: str(a.instruction, "instruction")
-        });
-        return Promise.resolve({ delivered });
+        const workerId = str(a.workerId, "workerId");
+        const instruction = str(a.instruction, "instruction");
+        const interrupt = a.interrupt === true;
+        const delivered = opts.scope.send(workerId, { steer: instruction, interrupt });
+        await sendDown("steer", { toWorker: workerId, instruction, delivered });
+        return { 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: "await_event",
+      description: "Wait for and pull the next message a worker, sub-driver, or analyst sent up \u2014 the unified inbox. An event is one of: a settled worker output ('settled'), a question needing your answer ('question', from ask_parent / the worker's ask-user), or a trace-analyst finding ('finding', from analyze-on-settle). Pass kinds:['settled'] for just the next finished worker; omit `kinds` to also receive questions and findings. Returns { idle: true } when nothing is queued and no workers are live.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          kinds: {
+            type: "array",
+            items: { type: "string", enum: ["settled", "question", "finding"] },
+            description: "Restrict to these event kinds (any if omitted)."
+          }
+        }
+      },
+      handler: async (raw) => {
+        const k = obj(raw).kinds;
+        const kinds = Array.isArray(k) ? k.filter((x) => x === "settled" || x === "question" || x === "finding") : void 0;
+        let ev = bus.pull(kinds);
+        if (!ev) {
+          const drained = await drainSettlement();
+          ev = bus.pull(kinds);
+          if (!ev) return { idle: !drained };
+        }
+        return projectEvent(ev);
       }
     },
     {
@@ -6899,17 +7275,24 @@ function createCoordinationTools(opts) {
         },
         required: ["questionId"]
       },
-      handler: (raw) => {
+      handler: async (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"
-            })
+          const answer = a.answer;
+          const question = decideQuestion(questionId, {
+            kind: "answer",
+            answer,
+            by: typeof a.by === "string" && a.by.length > 0 ? a.by : "user"
           });
+          const interrupt = question.urgency === "blocks-run" || question.urgency === "blocks-step";
+          const delivered = opts.scope.send(question.from, { answer, questionId, interrupt });
+          await sendDown(
+            "answer",
+            { toWorker: question.from, instruction: answer, delivered },
+            questionId
+          );
+          return { question, delivered };
         }
         if (typeof a.deferReason === "string" && a.deferReason.length > 0) {
           return Promise.resolve({
@@ -7020,6 +7403,9 @@ function createCoordinationTools(opts) {
   }
   return {
     tools,
+    history: () => bus.history(),
+    raiseFinding: (finding) => bus.publish({ type: "finding", finding }).then(() => void 0),
+    stats: () => bus.stats(),
     isStopped: () => stopped,
     stopReason: () => reason,
     settled: () => ledger,
@@ -7028,11 +7414,29 @@ function createCoordinationTools(opts) {
 }
 
 // src/runtime/supervise/coordination-driver.ts
+var runawayTripwireTurns = 2e3;
+function poolStarved(scope, perWorker) {
+  const b = scope.budget;
+  if (b.reservedTokens > 0) return false;
+  const tokenStarved = b.tokensLeft < perWorker.maxTokens;
+  const usdStarved = b.usdCapped && b.usdLeft <= 0;
+  return tokenStarved || usdStarved;
+}
+function deadlinePassed(scope, now) {
+  const b = scope.budget;
+  return b.deadlineMs > 0 && now() >= b.deadlineMs;
+}
 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;
+  if (opts.maxTurns !== void 0 && opts.maxTurns < 0) {
+    throw new ValidationError(
+      "coordinationDriverAgent: maxTurns must be >= 0 (0 lifts the turn cap; bounds become the conserved pool + deadline + abort)"
+    );
+  }
+  const maxTurns = opts.maxTurns === 0 ? runawayTripwireTurns : opts.maxTurns ?? 16;
+  const now = opts.now ?? Date.now;
   return {
     name: opts.name,
     async act(task, scope) {
@@ -7051,9 +7455,28 @@ function coordinationDriverAgent(opts) {
       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;
+        if (coord.isStopped() || scope.signal.aborted) break;
+        if (poolStarved(scope, opts.perWorker) || deadlinePassed(scope, now)) break;
         const res = await opts.chat.next({ system, messages, tools: toolSpecs });
         const calls = res.toolCalls ?? [];
+        if (res.usage || res.costUsd !== void 0) {
+          const turnSpend = {
+            // iterations:0 — the conserved iteration channel (`maxIterations`) budgets CHILD rounds,
+            // not driver turns; counting turns there would conflate the two AND make a driver arm's
+            // iteration count diverge from a blind arm's. The driver is bounded by maxTurns + the
+            // token/usd pool; its turn COUNT stays observable via the per-turn `agent.turn` events.
+            iterations: 0,
+            tokens: { input: res.usage?.input ?? 0, output: res.usage?.output ?? 0 },
+            usd: res.costUsd ?? 0,
+            ms: 0
+          };
+          await scope.meter(turnSpend, {
+            kind: "driver-inference",
+            driver: opts.name,
+            turn,
+            toolCalls: calls.map((c) => c.name)
+          });
+        }
         if (calls.length === 0) {
           return finalize2(coord, opts.blobs);
         }
@@ -9215,7 +9638,11 @@ async function serveCoordinationMcp(opts) {
     scope: opts.scope,
     blobs: opts.blobs,
     makeWorkerAgent: opts.makeWorkerAgent,
-    perWorker: opts.perWorker
+    perWorker: opts.perWorker,
+    ...opts.analysts ? { analysts: opts.analysts } : {},
+    ...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
+    ...opts.onEvent ? { onEvent: opts.onEvent } : {},
+    ...opts.questionPolicy ? { questionPolicy: opts.questionPolicy } : {}
   });
   const mcp = createMcpServer({ extraTools: coord.tools, serverName: "coordination" });
   const host = opts.host ?? "127.0.0.1";
@@ -9265,12 +9692,145 @@ async function serveCoordinationMcp(opts) {
     port,
     settled: () => coord.settled(),
     isStopped: () => coord.isStopped(),
+    history: () => coord.history(),
+    stats: () => coord.stats(),
+    raiseFinding: (finding) => coord.raiseFinding(finding),
     close: () => new Promise((resolve) => {
       server.close(() => resolve());
     })
   };
 }
 
+// src/runtime/supervise/detector-monitor.ts
+import {
+  argHash,
+  errorStreakDetector,
+  observeAll,
+  repeatedActionDetector
+} from "@tangle-network/agent-eval";
+function defaultToolDetectors() {
+  return [repeatedActionDetector({ maxRepeated: 3 }), errorStreakDetector({ maxErrors: 3 })];
+}
+function createDetectorMonitor(opts = {}) {
+  const detectors = opts.detectors ?? defaultToolDetectors();
+  return {
+    observeToolStep(step) {
+      let fingerprint;
+      try {
+        fingerprint = `${step.toolName}|${argHash(step.args)}`;
+      } catch {
+        fingerprint = `${step.toolName}|<unhashable>`;
+      }
+      const signals = observeAll(detectors, {
+        // Same fingerprint scheme as agent-eval's batch stuck-loop view: tool name + hashed args.
+        actionFingerprint: fingerprint,
+        ...step.status ? { status: step.status } : {},
+        label: step.toolName
+      });
+      for (const s of signals) void opts.onSignal?.(s);
+      return signals;
+    },
+    reset() {
+      for (const d of detectors) d.reset();
+    }
+  };
+}
+
+// src/runtime/supervise/router-driver-chat.ts
+function routerDriverChat(c, opts = {}) {
+  const temperature = opts.temperature ?? 0.4;
+  return {
+    next: async ({ system, messages, tools }) => {
+      const oa = [
+        { role: "system", content: system },
+        ...messages.map(toOpenAI)
+      ];
+      const oaTools = tools.map((t) => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters }
+      }));
+      const r = await routerChatWithTools(c, oa, oaTools, { temperature, toolChoice: "auto" });
+      return {
+        ...r.content ? { content: r.content } : {},
+        // Forward the router's REAL usage + cost so the driver meters its own inference against the
+        // conserved pool (the integrity hole: these were dropped on the floor before).
+        ...r.usage ? { usage: r.usage } : {},
+        ...typeof r.costUsd === "number" ? { costUsd: r.costUsd } : {},
+        toolCalls: r.toolCalls.map((tc) => ({
+          id: tc.id,
+          name: tc.name,
+          arguments: safeParse(tc.arguments)
+        }))
+      };
+    }
+  };
+}
+function toOpenAI(m) {
+  if (m.role === "assistant" && m.toolCalls?.length) {
+    return {
+      role: "assistant",
+      content: m.content ?? "",
+      tool_calls: m.toolCalls.map((tc) => ({
+        id: tc.id ?? tc.name,
+        type: "function",
+        function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+      }))
+    };
+  }
+  if (m.role === "tool") {
+    return { role: "tool", tool_call_id: m.toolCallId ?? m.name ?? "call", content: m.content };
+  }
+  return { role: m.role, content: m.content };
+}
+function safeParse(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return {};
+  }
+}
+
+// src/runtime/supervise/trajectory-recorder.ts
+import { buildTrajectory, InMemoryTraceStore } from "@tangle-network/agent-eval";
+import { stuckLoopView, toolWasteView } from "@tangle-network/agent-eval/pipelines";
+function createTrajectoryRecorder(runId, now = Date.now) {
+  let steps = [];
+  return {
+    observeToolStep(step) {
+      steps.push({ ...step, at: now() });
+    },
+    async analyze() {
+      const store = new InMemoryTraceStore();
+      for (let i = 0; i < steps.length; i += 1) {
+        const s = steps[i];
+        if (!s) continue;
+        const span = {
+          spanId: `${runId}-t${i}`,
+          runId,
+          kind: "tool",
+          name: s.toolName,
+          toolName: s.toolName,
+          args: s.args,
+          status: s.status ?? "ok",
+          startedAt: s.at,
+          endedAt: s.at,
+          ...s.result !== void 0 ? { result: s.result } : {}
+        };
+        await store.appendSpan(span);
+      }
+      const [trajectory, stuckLoop, toolWaste] = await Promise.all([
+        buildTrajectory(store, runId),
+        stuckLoopView(store, { runId }),
+        toolWasteView(store, { runId })
+      ]);
+      return { trajectory, stuckLoop, toolWaste };
+    },
+    reset() {
+      steps = [];
+    }
+  };
+}
+
 // src/runtime/verifier-environment.ts
 var submitTool = {
   type: "function",
@@ -9618,9 +10178,11 @@ export {
   routerChatWithUsage,
   routerChatWithTools,
   routerToolLoop,
+  createInbox,
   createWorktree,
   captureWorktreeDiff,
   removeWorktree,
+  runWorktreeHarness,
   createWorktreeCliExecutor,
   cliWorktreeExecutor,
   createExecutor,
@@ -9661,6 +10223,7 @@ export {
   authoredWorker,
   coderDeliverable,
   worktreeCoderFanout,
+  createEventBus,
   createCoordinationTools,
   coordinationDriverAgent,
   InMemoryFeedbackStore,
@@ -9715,6 +10278,10 @@ export {
   createMcpServer,
   createInProcessTransport,
   serveCoordinationMcp,
+  defaultToolDetectors,
+  createDetectorMonitor,
+  routerDriverChat,
+  createTrajectoryRecorder,
   createVerifierEnvironment,
   createWaterfallCollector,
   localShell,
@@ -9722,4 +10289,4 @@ export {
   jjWorkspace,
   runInWorkspace
 };
-//# sourceMappingURL=chunk-ZADWPBOE.js.map
+//# sourceMappingURL=chunk-RLDUT4JL.js.map