@tangle-network/agent-runtime 0.68.0 → 0.70.0

package/dist/{chunk-VKUHUFX7.js → chunk-QXWGSDAQ.js}

@@ -1,22 +1,12 @@
-import {
-  UI_LENSES
-} from "./chunk-WIR4HOOJ.js";
-import {
-  AgentEvalError,
-  AnalystError,
-  NotFoundError,
-  PlannerError,
-  RuntimeRunStateError,
-  ValidationError,
-  extractLlmCallEvent
-} from "./chunk-VLF5RHEQ.js";
-import {
-  harnessInvocation,
-  runLocalHarness
-} from "./chunk-O2UPHN7X.js";
 import {
   buildLoopSpanNodes
 } from "./chunk-G3RGMA7C.js";
+import {
+  UI_LENSES
+} from "./chunk-WIR4HOOJ.js";
+
+// src/runtime/index.ts
+import { computeFindingId as computeFindingId2, makeFinding as makeFinding3 } from "@tangle-network/agent-eval";
 
 // src/durable/spawn-journal.ts
 import { createHash } from "crypto";
@@ -149,38 +139,6 @@ var InMemoryResultBlobStore = class {
     return this.blobs.has(outRef) ? this.blobs.get(outRef) : void 0;
   }
 };
-var FileResultBlobStore = class {
-  constructor(dir) {
-    this.dir = dir;
-  }
-  dir;
-  async put(outRef, artifact) {
-    assertContentAddress(outRef, artifact);
-    const fs = await import("fs/promises");
-    await fs.mkdir(this.dir, { recursive: true });
-    const fh = await fs.open(this.blobPath(outRef), "w");
-    try {
-      await fh.write(JSON.stringify(artifact));
-      await fh.sync();
-    } finally {
-      await fh.close();
-    }
-  }
-  async get(outRef) {
-    const fs = await import("fs/promises");
-    let text;
-    try {
-      text = await fs.readFile(this.blobPath(outRef), "utf8");
-    } catch (err) {
-      if (isNoEntError(err)) return void 0;
-      throw err;
-    }
-    return JSON.parse(text);
-  }
-  blobPath(outRef) {
-    return `${this.dir}/${outRef.replace(/:/g, "-")}.json`;
-  }
-};
 function assertContentAddress(outRef, artifact) {
   const expected = contentAddress(artifact);
   if (outRef !== expected) {
@@ -217,90 +175,6 @@ var InMemorySpawnJournal = class {
     tree.events.push({ ...ev });
   }
 };
-var FileSpawnJournal = class {
-  constructor(path2) {
-    this.path = path2;
-  }
-  path;
-  async loadTree(root) {
-    const fs = await import("fs/promises");
-    let text;
-    try {
-      text = await fs.readFile(this.path, "utf8");
-    } catch (err) {
-      if (isNoEntError(err)) return void 0;
-      throw err;
-    }
-    const lines = text.split("\n").filter((line) => line.length > 0);
-    let begun = false;
-    const events = [];
-    for (const line of lines) {
-      const record = JSON.parse(line);
-      if (record.root !== root) continue;
-      if (record.kind === "begin") {
-        begun = true;
-      } else {
-        if (!begun) {
-          throw new Error(
-            `spawn journal corrupted: event for tree '${root}' precedes its begin record`
-          );
-        }
-        assertSeqUnique(root, events, record.event);
-        events.push(record.event);
-      }
-    }
-    return begun ? events : void 0;
-  }
-  async beginTree(root, at) {
-    const existing = await this.loadTreeBegin(root);
-    if (existing) {
-      if (existing !== at) {
-        throw new Error(
-          `spawn tree '${root}' already begun in ${this.path} at ${existing}; refusing to overwrite with ${at}`
-        );
-      }
-      return;
-    }
-    await this.appendRecord({ kind: "begin", root, at });
-  }
-  async appendEvent(root, ev) {
-    const events = await this.loadTree(root);
-    if (events === void 0) {
-      throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`);
-    }
-    assertSeqUnique(root, events, ev);
-    await this.appendRecord({ kind: "event", root, event: ev });
-  }
-  async loadTreeBegin(root) {
-    const fs = await import("fs/promises");
-    let text;
-    try {
-      text = await fs.readFile(this.path, "utf8");
-    } catch (err) {
-      if (isNoEntError(err)) return void 0;
-      throw err;
-    }
-    const lines = text.split("\n").filter((line) => line.length > 0);
-    for (const line of lines) {
-      const record = JSON.parse(line);
-      if (record.root === root && record.kind === "begin") return record.at;
-    }
-    return void 0;
-  }
-  async appendRecord(record) {
-    const fs = await import("fs/promises");
-    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)}
-`);
-      await fh.sync();
-    } finally {
-      await fh.close();
-    }
-  }
-};
 function assertSeqUnique(root, events, ev) {
   if (ev.kind === "spawned" || ev.kind === "metered") return;
   if (events.some((e) => e.kind !== "spawned" && e.kind !== "metered" && e.seq === ev.seq)) {
@@ -309,148 +183,6 @@ function assertSeqUnique(root, events, ev) {
     );
   }
 }
-async function replaySpawnTree(journal, blobs, root) {
-  const events = await journal.loadTree(root);
-  if (events === void 0) {
-    throw new Error(`replaySpawnTree: no journaled tree for root '${root}'`);
-  }
-  const ordered = [...events].sort((a, b) => a.seq - b.seq);
-  const labels = /* @__PURE__ */ new Map();
-  for (const ev of ordered) {
-    if (ev.kind === "spawned") labels.set(ev.id, ev.label);
-  }
-  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",
-        handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, "cancelled"),
-        reason: ev.reason,
-        infra: false,
-        restartCount: 0,
-        seq: ev.seq
-      });
-      continue;
-    }
-    if (ev.status === "down") {
-      settled.push({
-        kind: "down",
-        handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, "failed"),
-        reason: ev.verdict?.notes ?? "child down",
-        infra: ev.infra === true,
-        restartCount: 0,
-        seq: ev.seq
-      });
-      continue;
-    }
-    if (ev.outRef === void 0) {
-      throw new Error(
-        `replaySpawnTree: settled-done event for '${ev.id}' (seq ${ev.seq}) has no outRef; cannot rehydrate the result the driver branched on`
-      );
-    }
-    const out = await blobs.get(ev.outRef);
-    if (out === void 0) {
-      throw new Error(
-        `replaySpawnTree: blob store has no artifact for outRef '${ev.outRef}' (node '${ev.id}', seq ${ev.seq})`
-      );
-    }
-    settled.push({
-      kind: "done",
-      handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, "done"),
-      out,
-      outRef: ev.outRef,
-      verdict: ev.verdict,
-      spent: ev.spent,
-      seq: ev.seq
-    });
-  }
-  return settled;
-}
-function replayHandle(id, label, status) {
-  return {
-    id,
-    label,
-    status,
-    abort() {
-      throw new Error(`cannot abort node '${id}': replayed handles are terminal, not live`);
-    }
-  };
-}
-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" && 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, {
-      id: ev.id,
-      parent: ev.parent,
-      label: ev.label,
-      status: "pending",
-      runtime: ev.runtime,
-      budget: ev.budget,
-      spent: zeroSpend()
-    });
-  }
-  for (const ev of settlements) {
-    if (ev.kind === "settled") {
-      const node = requireNode(nodes, ev.id);
-      node.status = ev.status === "done" ? "done" : "failed";
-      node.spent = ev.spent;
-      node.outRef = ev.outRef;
-    } else {
-      const node = requireNode(nodes, ev.id);
-      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 ?? "",
-    nodes: snapshots,
-    inFlight: snapshots.filter((n) => n.status === "running" || n.status === "acquiring").length
-  };
-}
-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) {
-    throw new Error(`spawn journal corrupted: settle/cancel for node '${id}' with no prior spawn`);
-  }
-  return node;
-}
-function freezeSnapshot(node) {
-  return {
-    id: node.id,
-    parent: node.parent,
-    label: node.label,
-    status: node.status,
-    runtime: node.runtime,
-    budget: node.budget,
-    spent: node.spent,
-    outRef: node.outRef
-  };
-}
-function isNoEntError(err) {
-  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
-}
 
 // src/runtime/anytime.ts
 var median = (xs) => {
@@ -947,6 +679,61 @@ function reportLoopUsage(cost, result, source = "loop") {
   cost.observeTokens(result.tokenUsage);
 }
 
+// src/errors.ts
+import { AgentEvalError } from "@tangle-network/agent-eval";
+import {
+  AgentEvalError as AgentEvalError2,
+  ConfigError,
+  JudgeError,
+  NotFoundError,
+  ValidationError
+} from "@tangle-network/agent-eval";
+var SessionMismatchError = class extends AgentEvalError {
+  sessionBackend;
+  requestedBackend;
+  constructor(sessionBackend, requestedBackend, options) {
+    super(
+      "validation",
+      `Cannot resume ${sessionBackend} session with ${requestedBackend} backend`,
+      options
+    );
+    this.sessionBackend = sessionBackend;
+    this.requestedBackend = requestedBackend;
+  }
+};
+var BackendTransportError = class extends AgentEvalError {
+  backend;
+  status;
+  /**
+   * Truncated upstream response body (≤2 KiB) when available. Diagnostic
+   * only — surfaces in `backend_error.error.body` and `final.error.body`
+   * so operators can see "free_tier_limit", "invalid_api_key", etc. without
+   * cracking the log line open.
+   */
+  body;
+  constructor(backend, message, options) {
+    super("config", message, options);
+    this.backend = backend;
+    this.status = options?.status;
+    this.body = options?.body;
+  }
+};
+var RuntimeRunStateError = class extends AgentEvalError {
+  constructor(message, options) {
+    super("validation", message, options);
+  }
+};
+var PlannerError = class extends AgentEvalError {
+  constructor(message, options) {
+    super("validation", message, options);
+  }
+};
+var AnalystError = class extends AgentEvalError {
+  constructor(message, options) {
+    super("validation", message, options);
+  }
+};
+
 // src/runtime-hooks.ts
 function defineRuntimeHooks(hooks) {
   return hooks;
@@ -1175,6 +962,79 @@ async function resolveCapabilities(client) {
   }
 }
 
+// src/runtime/sandbox-events.ts
+function extractLlmCallEvent(event, agentRunName) {
+  if (!event || typeof event !== "object") return void 0;
+  const type = String(event.type ?? "");
+  const data = event.data && typeof event.data === "object" ? event.data : {};
+  if (type === "llm_call" || type === "cost.usage" || type === "usage") {
+    return buildLlmCall(data, agentRunName);
+  }
+  if (type === "message.completed" || type === "result" || type === "final") {
+    const usage = data.usage;
+    if (!usage || typeof usage !== "object") return void 0;
+    return buildLlmCall({ ...usage, model: data.model ?? usage.model }, agentRunName);
+  }
+  if (type === "done") {
+    const usage = data.tokenUsage;
+    if (!usage || typeof usage !== "object") return void 0;
+    const out = pickFiniteNumber(usage, ["outputTokens", "completion_tokens", "tokensOut"]);
+    const reasoning = pickFiniteNumber(usage, ["reasoningTokens"]);
+    const mergedOut = out !== void 0 || reasoning !== void 0 ? (out ?? 0) + (reasoning ?? 0) : void 0;
+    return buildLlmCall(
+      {
+        inputTokens: usage.inputTokens,
+        outputTokens: mergedOut,
+        totalCostUsd: data.totalCostUsd,
+        model: data.model ?? usage.model
+      },
+      agentRunName
+    );
+  }
+  return void 0;
+}
+function buildLlmCall(data, agentRunName) {
+  const tokensIn = pickFiniteNumber(data, ["tokensIn", "inputTokens", "prompt_tokens"]);
+  const tokensOut = pickFiniteNumber(data, ["tokensOut", "outputTokens", "completion_tokens"]);
+  const costUsd = pickFiniteNumber(data, ["costUsd", "totalCostUsd", "cost_usd", "cost"]);
+  if (tokensIn === void 0 && tokensOut === void 0 && costUsd === void 0) {
+    return void 0;
+  }
+  const model = typeof data.model === "string" && data.model.length > 0 ? data.model : agentRunName;
+  const event = {
+    type: "llm_call",
+    model
+  };
+  if (tokensIn !== void 0) event.tokensIn = tokensIn;
+  if (tokensOut !== void 0) event.tokensOut = tokensOut;
+  if (costUsd !== void 0) event.costUsd = costUsd;
+  return event;
+}
+function pickFiniteNumber(data, keys) {
+  for (const key of keys) {
+    const value = data[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function mapSandboxEvent(event, opts = {}) {
+  if (!event || typeof event !== "object") return void 0;
+  const type = String(event.type ?? "");
+  const data = event.data && typeof event.data === "object" ? event.data : {};
+  if (type === "message.part.updated") {
+    const part = data.part && typeof data.part === "object" ? data.part : {};
+    const partType = String(part.type ?? "");
+    const delta = typeof data.delta === "string" ? data.delta : void 0;
+    const text = delta ?? (typeof part.text === "string" ? part.text : void 0);
+    if (text === void 0) return void 0;
+    if (partType === "text") return { type: "text_delta", text };
+    if (partType === "reasoning" || partType === "thinking")
+      return { type: "reasoning_delta", text };
+    return void 0;
+  }
+  return extractLlmCallEvent(event, opts.agentRunName ?? "agent");
+}
+
 // src/runtime/sandbox-lineage.ts
 var TEARDOWN_TIMEOUT_MS = 15e3;
 var DEFAULT_FORK_CONCURRENCY = 4;
@@ -2143,7 +2003,7 @@ function createScope(args) {
   let cursorSeq = 0;
   let meterSeq = 0;
   const now = args.now ?? Date.now;
-  function spawn4(agent, task, opts) {
+  function spawn5(agent, task, opts) {
     if (args.maxDepth !== void 0 && args.depth >= args.maxDepth) {
       return { ok: false, reason: "depth-exceeded" };
     }
@@ -2185,7 +2045,7 @@ function createScope(args) {
         runtime: executor.runtime,
         budget: opts.budget,
         label: opts.label,
-        spent: zeroSpend2(),
+        spent: zeroSpend(),
         settled: void 0,
         delivered: false,
         ...executor.deliver ? { deliver: executor.deliver.bind(executor) } : {}
@@ -2239,7 +2099,7 @@ function createScope(args) {
       live.settled = settled;
       return { ok: true, handle };
     } catch (err) {
-      args.pool.reconcile(reservation.ticket, zeroSpend2());
+      args.pool.reconcile(reservation.ticket, zeroSpend());
       throw err;
     }
   }
@@ -2294,7 +2154,7 @@ function createScope(args) {
     );
   }
   return {
-    spawn: spawn4,
+    spawn: spawn5,
     next,
     send,
     signal: args.signal,
@@ -2546,7 +2406,7 @@ async function teardownSafe(executor, grace) {
 function downRecord(reason, infra, metered) {
   return { kind: "down", reason, infra, restartCount: 0, ...metered ? { metered } : {} };
 }
-function zeroSpend2() {
+function zeroSpend() {
   return { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
 }
 function isAsyncIterable2(value) {
@@ -3042,7 +2902,7 @@ var FileCorpus = class {
     try {
       text = await fs.readFile(this.path, "utf8");
     } catch (err) {
-      if (isNoEntError2(err)) return /* @__PURE__ */ new Map();
+      if (isNoEntError(err)) return /* @__PURE__ */ new Map();
       throw err;
     }
     const lines = text.split("\n").filter((line) => line.length > 0);
@@ -3116,30 +2976,13 @@ function renderLine(record) {
 function freeze(record) {
   return Object.freeze({ ...record });
 }
-function isNoEntError2(err) {
+function isNoEntError(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 
 // 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;
@@ -3311,11 +3154,64 @@ function isAgent(value) {
 }
 
 // src/runtime/supervise/runtime.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
 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";
+
+// src/runtime/tool-loop.ts
+async function runBrainLoop(opts) {
+  const maxTurns = opts.maxTurns ?? 4;
+  const messages = [...opts.initialMessages];
+  let toolCalls = 0;
+  let lastText = "";
+  const usage = { input: 0, output: 0 };
+  const toolTrace = [];
+  for (let turn = 1; turn <= maxTurns; turn += 1) {
+    if (opts.hooks?.stopBefore?.(turn)) break;
+    await opts.hooks?.beforeTurn?.(turn, messages);
+    const r = await opts.chat(messages, opts.tools);
+    if (r.usage) {
+      usage.input += r.usage.input;
+      usage.output += r.usage.output;
+      opts.hooks?.onUsage?.(r.usage);
+    }
+    if (r.content) lastText = r.content;
+    if (r.toolCalls.length === 0)
+      return { final: lastText, turns: turn, toolCalls, toolTrace, usage, messages };
+    messages.push({
+      role: "assistant",
+      content: r.content ?? "",
+      tool_calls: r.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: tc.arguments }
+      }))
+    });
+    for (const tc of r.toolCalls) {
+      toolCalls += 1;
+      let args = {};
+      try {
+        args = JSON.parse(tc.arguments);
+      } catch {
+        messages.push({
+          role: "tool",
+          tool_call_id: tc.id,
+          content: `error: arguments were not valid JSON: ${tc.arguments.slice(0, 200)}`
+        });
+        continue;
+      }
+      const out = await opts.execute(tc.name, args);
+      messages.push({ role: "tool", tool_call_id: tc.id, content: out });
+      toolTrace.push({ name: tc.name, args: tc.arguments, result: out });
+    }
+  }
+  return { final: lastText, turns: maxTurns, toolCalls, toolTrace, usage, messages };
+}
+
+// src/runtime/router-client.ts
 async function routerChatWithUsage(cfg, messages, opts) {
   const url = `${cfg.routerBaseUrl.replace(/\/$/, "")}/chat/completions`;
   const headers = { "content-type": "application/json", authorization: `Bearer ${cfg.routerKey}` };
@@ -3387,62 +3283,31 @@ async function routerChatWithTools(cfg, messages, tools, opts) {
   const costUsd = usage && isModelPriced(cfg.model) ? estimateCost(usage.input, usage.output, cfg.model) : void 0;
   return {
     content: msg?.content ?? null,
-    toolCalls,
-    ...usage ? { usage } : {},
-    ...costUsd !== void 0 ? { costUsd } : {}
-  };
-}
-async function routerToolLoop(cfg, system, user, tools, execute, opts) {
-  const maxTurns = opts?.maxTurns ?? 4;
-  const messages = opts?.initialMessages ? [...opts.initialMessages] : [
-    { role: "system", content: system },
-    { role: "user", content: user }
-  ];
-  let toolCalls = 0;
-  let lastText = "";
-  const usage = { input: 0, output: 0 };
-  const toolTrace = [];
-  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) {
-      usage.input += r.usage.input;
-      usage.output += r.usage.output;
-    }
-    if (r.content) lastText = r.content;
-    if (r.toolCalls.length === 0)
-      return { final: lastText, turns: turn, toolCalls, toolTrace, usage, messages };
-    messages.push({
-      role: "assistant",
-      content: r.content ?? "",
-      tool_calls: r.toolCalls.map((tc) => ({
-        id: tc.id,
-        type: "function",
-        function: { name: tc.name, arguments: tc.arguments }
-      }))
-    });
-    for (const tc of r.toolCalls) {
-      toolCalls += 1;
-      let args = {};
-      try {
-        args = JSON.parse(tc.arguments);
-      } catch {
-        messages.push({
-          role: "tool",
-          tool_call_id: tc.id,
-          content: `error: arguments were not valid JSON: ${tc.arguments.slice(0, 200)}`
-        });
-        continue;
-      }
-      const out = await execute(tc.name, args);
-      messages.push({ role: "tool", tool_call_id: tc.id, content: out });
-      toolTrace.push({ name: tc.name, args: tc.arguments, result: out });
-    }
-  }
-  return { final: lastText, turns: maxTurns, toolCalls, toolTrace, usage, messages };
+    toolCalls,
+    ...usage ? { usage } : {},
+    ...costUsd !== void 0 ? { costUsd } : {}
+  };
+}
+async function routerToolLoop(cfg, system, user, tools, execute, opts) {
+  const initialMessages = opts?.initialMessages ?? [
+    { role: "system", content: system },
+    { role: "user", content: user }
+  ];
+  return runBrainLoop({
+    chat: (messages, toolSpecs) => routerChatWithTools(cfg, messages, toolSpecs, {
+      ...opts?.temperature !== void 0 ? { temperature: opts.temperature } : {},
+      ...opts?.maxTokens ? { maxTokens: opts.maxTokens } : {},
+      ...opts?.signal ? { signal: opts.signal } : {}
+    }),
+    tools,
+    execute,
+    initialMessages,
+    maxTurns: opts?.maxTurns ?? 4
+  });
+}
+function routerBrain(cfg, opts = {}) {
+  const temperature = opts.temperature ?? 0.4;
+  return (messages, tools) => routerChatWithTools(cfg, messages, tools, { temperature, toolChoice: "auto" });
 }
 
 // src/runtime/supervise/inbox.ts
@@ -3494,14 +3359,123 @@ ${lines.join("\n")}`;
 import { randomUUID } from "crypto";
 
 // src/mcp/worktree-harness.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 
-// src/mcp/worktree.ts
+// src/mcp/local-harness.ts
 import { spawn } from "child_process";
+var HARNESS_INVOCATIONS = {
+  claude: {
+    command: "claude",
+    buildArgs: (taskPrompt) => ["--headless", "-p", taskPrompt],
+    modelArgs: (model) => ["-m", model]
+  },
+  codex: {
+    command: "codex",
+    buildArgs: (taskPrompt) => ["run", taskPrompt],
+    modelArgs: (model) => ["-m", model]
+  },
+  opencode: {
+    command: "opencode",
+    buildArgs: (taskPrompt) => ["run", taskPrompt],
+    modelArgs: (model) => ["-m", model]
+  }
+};
+function harnessInvocation(harness, profile, taskPrompt) {
+  const invocation = HARNESS_INVOCATIONS[harness];
+  if (!invocation) {
+    throw new Error(`harnessInvocation: unknown harness ${String(harness)}`);
+  }
+  const systemPrompt = profile.prompt?.systemPrompt;
+  const composedPrompt = typeof systemPrompt === "string" && systemPrompt.trim().length > 0 ? `${systemPrompt}
+
+${taskPrompt}` : taskPrompt;
+  const args = invocation.buildArgs(composedPrompt);
+  const model = profile.model?.default;
+  if (typeof model === "string" && model.length > 0) {
+    args.push(...invocation.modelArgs(model));
+  }
+  return { command: invocation.command, args };
+}
+var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+function runLocalHarness(options) {
+  const { harness, cwd, taskPrompt } = options;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const env = options.env ?? process.env;
+  const spawnImpl = options.spawn ?? spawn;
+  const invocation = HARNESS_INVOCATIONS[harness];
+  if (!invocation) {
+    return Promise.reject(new Error(`runLocalHarness: unknown harness ${String(harness)}`));
+  }
+  const startedAt = Date.now();
+  const command = options.invocation?.command ?? invocation.command;
+  const args = options.invocation ? [...options.invocation.args] : invocation.buildArgs(taskPrompt);
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawnImpl(command, args, { cwd, env, stdio: "pipe" });
+    } catch (err) {
+      reject(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    child.stdin?.end();
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const timer = timeoutMs > 0 ? setTimeout(() => {
+      timedOut = true;
+      if (!child.killed) child.kill("SIGTERM");
+    }, timeoutMs) : null;
+    if (timer && typeof timer.unref === "function") {
+      ;
+      timer.unref();
+    }
+    const onAbort = () => {
+      if (!child.killed) child.kill("SIGTERM");
+    };
+    if (options.signal) {
+      if (options.signal.aborted) onAbort();
+      else options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    const finalize3 = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      resolve(result);
+    };
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+    child.on("close", (code, signal) => {
+      finalize3({
+        exitCode: code,
+        stdout,
+        stderr,
+        killedBySignal: signal,
+        durationMs: Date.now() - startedAt,
+        timedOut
+      });
+    });
+  });
+}
+
+// src/mcp/worktree.ts
+import { spawn as spawn2 } from "child_process";
 async function runGitAsync(args, cwd, runner) {
   if (runner) return runner(args, { cwd });
   return new Promise((resolve, reject) => {
-    const proc = spawn("git", args, { cwd, stdio: "pipe" });
+    const proc = spawn2("git", args, { cwd, stdio: "pipe" });
     let stdout = "";
     let stderr = "";
     proc.stdout?.on("data", (c) => {
@@ -3667,7 +3641,7 @@ async function runChecks(opts) {
 }
 function defaultRunCommand(opts) {
   return new Promise((resolve, reject) => {
-    const child = spawn2("/bin/sh", ["-c", opts.command], {
+    const child = spawn3("/bin/sh", ["-c", opts.command], {
       cwd: opts.cwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -3790,7 +3764,7 @@ function contentRef(prefix, value) {
   }
   return `${prefix}:${(h >>> 0).toString(16).padStart(8, "0")}`;
 }
-function zeroSpend3() {
+function zeroSpend2() {
   return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
 }
 var routerInlineExecutor = (spec, ctx) => {
@@ -3962,15 +3936,24 @@ var routerToolsInlineExecutor = (spec, ctx) => {
           const toolName = tc?.function?.name ?? "";
           let result;
           let status = "ok";
+          const toolStartedAt = Date.now();
           try {
             result = await seam.executeToolCall(toolName, args, task);
           } catch (e) {
             status = "error";
             result = `error: ${e instanceof Error ? e.message : String(e)}`;
           }
+          const toolEndedAt = Date.now();
           messages.push({ role: "tool", tool_call_id: id, content: result });
           try {
-            seam.onToolStep?.({ toolName, args, status });
+            seam.onToolStep?.({
+              toolName,
+              args,
+              status,
+              startedAt: toolStartedAt,
+              endedAt: toolEndedAt,
+              durationMs: toolEndedAt - toolStartedAt
+            });
           } catch {
           }
         }
@@ -4150,7 +4133,7 @@ var cliExecutor = (_spec, ctx) => {
 };
 async function* streamCliLeaf(args) {
   const prompt = taskToPrompt(args.task);
-  const proc = spawn3(args.seam.bin, args.seam.args ?? [], {
+  const proc = spawn4(args.seam.bin, args.seam.args ?? [], {
     ...args.seam.cwd ? { cwd: args.seam.cwd } : {},
     env: { ...process.env, ...args.seam.env ?? {} },
     stdio: ["pipe", "pipe", "pipe"]
@@ -4187,7 +4170,7 @@ async function* streamCliLeaf(args) {
     );
   }
   const out = { content: chunks.join("") };
-  args.onArtifact({ outRef: contentRef("cli", out), out, spent: zeroSpend3() });
+  args.onArtifact({ outRef: contentRef("cli", out), out, spent: zeroSpend2() });
   yield { kind: "iteration" };
 }
 function killWithGrace(proc, grace) {
@@ -4216,58 +4199,33 @@ var bridgeExecutor = (spec, ctx) => {
       "bridgeExecutor: BridgeSeam.bridgeUrl + bridgeBearer + model required"
     );
   }
+  const maxTurns = seam.maxTurns ?? 200;
+  const sessionId = seam.sessionId ?? `bridge-${spec.profile.name ?? "worker"}-${randomUUID2()}`;
   const controller = new AbortController();
   const abortIfSignalled = () => {
     if (ctx.signal.aborted) controller.abort();
   };
   abortIfSignalled();
   if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+  const inbox = createInbox();
   let artifact;
   return {
     runtime: "cli",
-    async execute(task, signal) {
-      const messages = taskToMessages(task, spec);
-      const started = Date.now();
-      const linked = linkSignals2(signal, controller.signal);
-      const timer = seam.timeoutMs ? setTimeout(() => controller.abort(), seam.timeoutMs) : void 0;
-      try {
-        const res = await fetch(`${seam.bridgeUrl.replace(/\/$/, "")}/v1/chat/completions`, {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-            authorization: `Bearer ${seam.bridgeBearer}`
-          },
-          body: JSON.stringify({
-            model: seam.model,
-            stream: false,
-            ...seam.agentProfile ? { agent_profile: seam.agentProfile } : {},
-            messages
-          }),
-          ...linked ? { signal: linked } : {}
-        });
-        if (!res.ok) {
-          throw new ValidationError(
-            `bridgeExecutor: bridge ${res.status}: ${(await res.text()).slice(0, 300)}`
-          );
+    deliver: (m) => inbox.deliver(m),
+    execute(task, signal) {
+      return streamBridgeSession({
+        task,
+        signal,
+        spec,
+        seam,
+        sessionId,
+        maxTurns,
+        inbox,
+        controller,
+        onArtifact: (a) => {
+          artifact = a;
         }
-        const data = await res.json();
-        const u = data.usage;
-        const usage = u && typeof u.prompt_tokens === "number" && typeof u.completion_tokens === "number" ? { input: u.prompt_tokens, output: u.completion_tokens } : void 0;
-        const msg = data.choices?.[0]?.message;
-        const content = msg?.content ?? "";
-        const toolCalls = (msg?.tool_calls ?? []).map((t) => t.function?.name ?? "unknown");
-        const spent = {
-          iterations: 1,
-          tokens: usage ? { input: usage.input, output: usage.output } : zeroTokenUsage(),
-          usd: typeof u?.cost === "number" ? u.cost : 0,
-          ms: Date.now() - started
-        };
-        const out = { content, toolCalls };
-        artifact = { outRef: contentRef("bridge", { model: seam.model, content }), out, spent };
-        return artifact;
-      } finally {
-        if (timer) clearTimeout(timer);
-      }
+      });
     },
     teardown(_grace) {
       controller.abort();
@@ -4275,12 +4233,179 @@ var bridgeExecutor = (spec, ctx) => {
     },
     resultArtifact() {
       if (!artifact) {
-        throw new ValidationError("bridgeExecutor: resultArtifact() read before execute()");
+        throw new ValidationError("bridgeExecutor: resultArtifact() read before stream drained");
       }
       return { ...artifact, spent: artifact.spent };
     }
   };
 };
+async function* streamBridgeSession(args) {
+  const { seam, inbox } = args;
+  const started = Date.now();
+  const url = `${seam.bridgeUrl.replace(/\/$/, "")}/v1/chat/completions`;
+  const external = mergeAbortSignals(args.signal, args.controller.signal);
+  const tokens = zeroTokenUsage();
+  let usd = 0;
+  let turns = 0;
+  let lastText = "";
+  const toolCalls = [];
+  let nextPrompt = taskToPrompt(args.task);
+  const system = args.spec.profile.prompt?.systemPrompt;
+  for (let t = 0; t < args.maxTurns; t += 1) {
+    const pending = inbox.drain();
+    if (pending.length) {
+      const folded = inbox.fold(pending);
+      nextPrompt = t === 0 && nextPrompt ? `${nextPrompt}
+
+${folded}` : folded;
+    }
+    if (nextPrompt === void 0) break;
+    const messages = [];
+    if (t === 0 && typeof system === "string" && system.length > 0) {
+      messages.push({ role: "system", content: system });
+    }
+    messages.push({ role: "user", content: nextPrompt });
+    nextPrompt = void 0;
+    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 timer = seam.timeoutMs ? setTimeout(abortTurn, seam.timeoutMs) : void 0;
+    const cleanup = () => {
+      external.removeEventListener("abort", abortTurn);
+      if (timer) clearTimeout(timer);
+    };
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${seam.bridgeBearer}`,
+          "x-session-id": args.sessionId
+        },
+        body: JSON.stringify({
+          model: seam.model,
+          stream: true,
+          session_id: args.sessionId,
+          ...seam.agentProfile ? { agent_profile: seam.agentProfile } : {},
+          messages
+        }),
+        signal: turnController.signal
+      });
+    } catch (e) {
+      cleanup();
+      const interruptAbort = e instanceof DOMException && e.name === "AbortError" && interruptSig.aborted && !args.signal.aborted && !args.controller.signal.aborted;
+      if (interruptAbort) continue;
+      throw e;
+    }
+    if (!res.ok) {
+      cleanup();
+      throw new ValidationError(
+        `bridgeExecutor: bridge ${res.status}: ${(await res.text()).slice(0, 300)}`
+      );
+    }
+    if (!res.body) {
+      cleanup();
+      throw new ValidationError("bridgeExecutor: bridge response had no body to stream");
+    }
+    let turnText = "";
+    try {
+      for await (const chunk of parseSseChatStream(res.body)) {
+        if (chunk.content) {
+          turnText += chunk.content;
+          yield { kind: "iteration" };
+        }
+        if (chunk.toolCall) toolCalls.push(chunk.toolCall);
+        if (chunk.usage) {
+          tokens.input += chunk.usage.input;
+          tokens.output += chunk.usage.output;
+          yield { kind: "tokens", input: chunk.usage.input, output: chunk.usage.output };
+        }
+        if (typeof chunk.cost === "number" && chunk.cost > 0) {
+          usd += chunk.cost;
+          yield { kind: "cost", usd: chunk.cost };
+        }
+      }
+    } finally {
+      cleanup();
+    }
+    turns += 1;
+    if (turnText) lastText = turnText;
+    if (inbox.pending() === 0) break;
+  }
+  const spent = {
+    iterations: turns,
+    tokens,
+    usd,
+    ms: Date.now() - started
+  };
+  const out = { content: lastText, toolCalls };
+  args.onArtifact({
+    outRef: contentRef("bridge", { model: seam.model, session: args.sessionId, content: lastText }),
+    out,
+    spent
+  });
+}
+async function* parseSseChatStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      let sep = buf.indexOf("\n\n");
+      while (sep !== -1) {
+        const frame = buf.slice(0, sep);
+        buf = buf.slice(sep + 2);
+        const chunk = parseSseFrame(frame);
+        if (chunk === "done") return;
+        if (chunk) yield chunk;
+        sep = buf.indexOf("\n\n");
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseSseFrame(frame) {
+  const dataLines = [];
+  for (const rawLine of frame.split("\n")) {
+    const line = rawLine.replace(/\r$/, "");
+    if (!line || line.startsWith(":")) continue;
+    if (line.startsWith("data:")) dataLines.push(line.slice("data:".length).trimStart());
+  }
+  if (dataLines.length === 0) return void 0;
+  const data = dataLines.join("\n");
+  if (data === "[DONE]") return "done";
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return void 0;
+  }
+  if (parsed.error) {
+    throw new ValidationError(
+      `bridgeExecutor: bridge stream error: ${parsed.error.message ?? "unknown"}`
+    );
+  }
+  const out = {};
+  const choice = parsed.choices?.[0];
+  const content = choice?.delta?.content ?? choice?.message?.content;
+  if (typeof content === "string" && content.length > 0) out.content = content;
+  const toolName = choice?.delta?.tool_calls?.[0]?.function?.name;
+  if (typeof toolName === "string" && toolName.length > 0) out.toolCall = toolName;
+  const u = parsed.usage;
+  if (u && (typeof u.prompt_tokens === "number" || typeof u.completion_tokens === "number")) {
+    out.usage = { input: u.prompt_tokens ?? 0, output: u.completion_tokens ?? 0 };
+  }
+  if (typeof u?.cost === "number") out.cost = u.cost;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 var cliWorktreeExecutor = (spec, ctx) => {
   const seam = readSeam(ctx, cliWorktreeSeamKey, "cli-worktree");
   if (!seam.repoRoot || !seam.harness || !seam.taskPrompt) {
@@ -4660,40 +4785,6 @@ function createSupervisor() {
   return { run, attach };
 }
 var rootControls = /* @__PURE__ */ new WeakMap();
-function createRootHandle() {
-  let binding;
-  const handle = {
-    view() {
-      if (!binding) {
-        throw new RuntimeRunStateError(
-          "RootHandle.view: handle is not bound to a live run (attach it before run, read after run starts)"
-        );
-      }
-      return binding.scope.view;
-    },
-    signal(msg) {
-      if (!binding) {
-        throw new RuntimeRunStateError("RootHandle.signal: handle is not bound to a live run");
-      }
-      binding.signal(msg);
-    },
-    abort(reason) {
-      if (!binding) {
-        throw new RuntimeRunStateError("RootHandle.abort: handle is not bound to a live run");
-      }
-      binding.cascadeAbort(reason ?? "root handle aborted");
-    }
-  };
-  rootControls.set(handle, {
-    bind(b) {
-      binding = b;
-    },
-    unbind() {
-      binding = void 0;
-    }
-  });
-  return handle;
-}
 function pushRootSignal(cascadeAbort) {
   return (msg) => {
     if (msg.kind === "cancel") cascadeAbort(msg.reason ?? "root signal: cancel");
@@ -4962,12 +5053,12 @@ async function trajectoryReport(journal, blobs, root, options = {}) {
       label: ev.label,
       runtime: ev.runtime,
       status: "pending",
-      ownSpend: zeroSpend4(),
+      ownSpend: zeroSpend3(),
       children: []
     });
   }
   for (const ev of closes) {
-    const node = requireNode2(nodes, ev.id, root);
+    const node = requireNode(nodes, ev.id, root);
     if (ev.kind === "cancelled") {
       node.status = "cancelled";
       continue;
@@ -4979,7 +5070,7 @@ async function trajectoryReport(journal, blobs, root, options = {}) {
   }
   for (const ev of events) {
     if (ev.kind !== "metered") continue;
-    const node = requireNode2(nodes, ev.id, root);
+    const node = requireNode(nodes, ev.id, root);
     node.ownSpend = addNodeSpend(node.ownSpend, ev.spend);
   }
   if (!nodes.has(root)) {
@@ -4989,7 +5080,7 @@ async function trajectoryReport(journal, blobs, root, options = {}) {
   }
   for (const ev of spawns) {
     if (ev.parent === void 0) continue;
-    requireNode2(nodes, ev.parent, root).children.push(ev.id);
+    requireNode(nodes, ev.parent, root).children.push(ev.id);
   }
   const rolledUp = rollUpSpend(nodes, root);
   if (options.withOutputs) {
@@ -5037,7 +5128,7 @@ function rollUpSpend(nodes, root) {
   while (stack.length > 0) {
     const frame = stack.pop();
     if (frame === void 0) continue;
-    const node = requireNode2(nodes, frame.id, root);
+    const node = requireNode(nodes, frame.id, root);
     if (!frame.expanded) {
       stack.push({ id: frame.id, expanded: true });
       for (const child of node.children) stack.push({ id: child, expanded: false });
@@ -5086,7 +5177,7 @@ function countStatuses(reported) {
   for (const node of reported) counts[node.status] += 1;
   return counts;
 }
-function zeroSpend4() {
+function zeroSpend3() {
   return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
 }
 function addNodeSpend(a, b) {
@@ -5146,7 +5237,7 @@ function isNode(node) {
 function bySeq(a, b) {
   return a.seq - b.seq;
 }
-function requireNode2(nodes, id, root) {
+function requireNode(nodes, id, root) {
   const node = nodes.get(id);
   if (!node) {
     throw new Error(
@@ -5551,7 +5642,7 @@ var perChild = (innerTurns) => ({
   maxIterations: innerTurns + 1,
   maxTokens: 1e6
 });
-function depthDriver(surface, task, opts, cfg) {
+function depthStrategy(surface, task, opts, cfg) {
   const innerTurns = opts.innerTurns ?? 4;
   let pendingSteer;
   return {
@@ -5614,7 +5705,7 @@ Address each with the tools, verify they took, then continue.`;
     }
   };
 }
-function breadthDriver(_surface, task, opts, cfg) {
+function breadthStrategy(_surface, task, opts, cfg) {
   const innerTurns = opts.innerTurns ?? 4;
   return {
     name: "breadth",
@@ -5657,11 +5748,11 @@ function breadthDriver(_surface, task, opts, cfg) {
 }
 var sample = {
   name: "sample",
-  driver: (surface, task, opts, budget) => breadthDriver(surface, task, opts, { width: budget })
+  driver: (surface, task, opts, budget) => breadthStrategy(surface, task, opts, { width: budget })
 };
 var refine = {
   name: "refine",
-  driver: (surface, task, opts, budget) => depthDriver(surface, task, opts, { maxShots: budget })
+  driver: (surface, task, opts, budget) => depthStrategy(surface, task, opts, { maxShots: budget })
 };
 function defineStrategy(name, run) {
   return {
@@ -6792,6 +6883,9 @@ ${summary}`,
   };
 }
 
+// src/runtime/supervise/authoring.ts
+import { computeFindingId, makeFinding as makeFinding2 } from "@tangle-network/agent-eval";
+
 // src/runtime/supervise/completion-gate.ts
 function gateOnDeliverable(inner, deliverable) {
   let gated;
@@ -6844,13 +6938,13 @@ function asAuthoredProfile(raw) {
     ...typeof p.model === "string" ? { model: p.model } : {}
   };
 }
-function supervisorSkill(opts) {
+function supervisorInstructions(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`:",
+    "2. For EACH sub-task, AUTHOR a worker by calling spawn_agent 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).",
@@ -6901,6 +6995,93 @@ function authoredWorker(profile, opts) {
   };
   return { name: profile.name, act: async () => "", executorSpec: spec };
 }
+var defaultProfileRichnessThresholds = {
+  minSystemPromptChars: 600,
+  minSystemPromptLines: 6
+};
+function resolveSystemPrompt(profile) {
+  const pr = profile.prompt;
+  if (typeof pr === "string") return pr;
+  if (pr && typeof pr === "object") {
+    const o = pr;
+    if (typeof o.systemPrompt === "string") return o.systemPrompt;
+    if (typeof o.system === "string") return o.system;
+  }
+  return "";
+}
+function assessAuthoredProfile(profile, opts) {
+  const th = { ...defaultProfileRichnessThresholds, ...opts?.thresholds ?? {} };
+  const systemPrompt = resolveSystemPrompt(profile);
+  const trimmed = systemPrompt.trim();
+  const systemPromptChars = trimmed.length;
+  const systemPromptLines = trimmed ? trimmed.split("\n").filter((l) => l.trim().length > 0).length : 0;
+  const sentenceCount = trimmed ? (trimmed.match(/[.!?](\s|$)/g) ?? []).length || (trimmed ? 1 : 0) : 0;
+  const hasDescription = typeof profile.description === "string" && profile.description.trim().length > 0;
+  const tools = profile.tools;
+  const hasTools = !!tools && Object.keys(tools).length > 0;
+  const skills = profile.resources?.skills;
+  const hasSkills = Array.isArray(skills) && skills.length > 0;
+  const mcp = profile.mcp;
+  const hasMcp = !!mcp && Object.keys(mcp).length > 0;
+  const subagents = profile.subagents;
+  const hasSubagents = !!subagents && Object.keys(subagents).length > 0;
+  const reasons = [];
+  const promptThin = systemPromptChars < th.minSystemPromptChars || systemPromptLines < th.minSystemPromptLines;
+  if (promptThin)
+    reasons.push(
+      `system prompt is thin (${systemPromptChars} chars, ${systemPromptLines} lines; need \u2265${th.minSystemPromptChars} chars and \u2265${th.minSystemPromptLines} lines)`
+    );
+  if (!hasTools)
+    reasons.push("no tools granted (a worker can only act through the tools you grant it)");
+  if (!hasSkills) reasons.push("no skills attached (no reusable how-to notes injected)");
+  if (opts?.needsMcp && !hasMcp) reasons.push("no MCP server, but the task needs data/tool access");
+  const signals = [!promptThin, hasTools, hasSkills, hasDescription, opts?.needsMcp ? hasMcp : true];
+  const richness = signals.filter(Boolean).length / signals.length;
+  const thin = promptThin || !hasTools && !hasSkills && !hasMcp;
+  return {
+    name: profile.name ?? "worker",
+    systemPrompt,
+    systemPromptChars,
+    systemPromptLines,
+    sentenceCount,
+    hasDescription,
+    hasTools,
+    hasSkills,
+    hasMcp,
+    hasSubagents,
+    richness,
+    thin,
+    reasons
+  };
+}
+function profileRichnessFinding(richness, opts) {
+  const analyst_id = opts?.analystId ?? "profile-richness";
+  const subject = richness.name;
+  const claim = richness.thin ? `Worker "${richness.name}" was authored as a THIN profile: ${richness.reasons.join("; ")}.` : `Worker "${richness.name}" was authored as a rich profile (richness ${(richness.richness * 100).toFixed(0)}%).`;
+  const severity = richness.thin ? richness.richness < 0.25 ? "high" : "medium" : "info";
+  return makeFinding2({
+    analyst_id,
+    severity,
+    area: "profile-quality",
+    claim,
+    subject,
+    confidence: 0.9,
+    evidence_refs: [
+      {
+        kind: "metric",
+        uri: `profile:${subject}`,
+        excerpt: `chars=${richness.systemPromptChars} lines=${richness.systemPromptLines} tools=${richness.hasTools} skills=${richness.hasSkills} mcp=${richness.hasMcp} richness=${richness.richness.toFixed(2)}`
+      }
+    ],
+    ...richness.thin ? { recommended_action: `Re-author "${richness.name}" with: ${richness.reasons.join("; ")}.` } : {},
+    id_basis: computeFindingId({
+      analyst_id,
+      area: "profile-quality",
+      subject,
+      claim: `richness:${richness.thin ? "thin" : "rich"}`
+    })
+  });
+}
 
 // src/runtime/supervise/event-bus.ts
 function createEventBus(now = Date.now) {
@@ -6959,7 +7140,19 @@ function createEventBus(now = Date.now) {
 }
 
 // src/mcp/tools/coordination.ts
-var idArg = { type: "string", description: "The workerId returned by spawn_worker." };
+var coordinationVerbNames = [
+  "spawn_agent",
+  "observe_agent",
+  "steer_agent",
+  "await_event",
+  "list_questions",
+  "answer_question",
+  "ask_parent",
+  "stop",
+  "list_analysts",
+  "run_analyst"
+];
+var idArg = { type: "string", description: "The workerId returned by spawn_agent." };
 function createCoordinationTools(opts) {
   let stopped = false;
   let reason;
@@ -6983,6 +7176,28 @@ function createCoordinationTools(opts) {
       throw new Error("coordination tools: arguments must be an object");
     return raw;
   };
+  const mergeBudget = (base, raw) => {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+      throw new Error('coordination tools: "budget" must be an object');
+    const o = raw;
+    const field = (name) => {
+      const v = o[name];
+      if (v === void 0) return void 0;
+      if (typeof v !== "number" || !Number.isFinite(v))
+        throw new Error(`coordination tools: "budget.${name}" must be a finite number`);
+      return v;
+    };
+    const maxIterations = field("maxIterations");
+    const maxTokens = field("maxTokens");
+    const maxUsd = field("maxUsd");
+    const deadlineMs = field("deadlineMs");
+    return {
+      maxIterations: maxIterations ?? base.maxIterations,
+      maxTokens: maxTokens ?? base.maxTokens,
+      ...(maxUsd ?? base.maxUsd) === void 0 ? {} : { maxUsd: maxUsd ?? base.maxUsd },
+      ...(deadlineMs ?? base.deadlineMs) === void 0 ? {} : { deadlineMs: deadlineMs ?? base.deadlineMs }
+    };
+  };
   const level = (v) => {
     if (v === "worker" || v === "driver" || v === "loop") return v;
     throw new Error('coordination tools: "level" must be worker, driver, or loop');
@@ -7101,29 +7316,40 @@ function createCoordinationTools(opts) {
   };
   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.",
+      name: "spawn_agent",
+      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. Pass an optional `budget` (per-field) to give a hard sub-task more than the default \u2014 it merges over the per-worker default; the conserved pool is still the hard fence.",
       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." }
+          label: { type: "string", description: "Optional trace label." },
+          budget: {
+            type: "object",
+            description: "Optional per-spawn budget that merges over the per-worker default (per field). Only set the ceilings this sub-task needs raised; the conserved pool still fences.",
+            properties: {
+              maxIterations: { type: "number" },
+              maxTokens: { type: "number" },
+              maxUsd: { type: "number" },
+              deadlineMs: { type: "number" }
+            }
+          }
         },
         required: ["profile", "task"]
       },
       handler: (raw) => {
         const a = obj2(raw);
         const agent = opts.makeWorkerAgent(a.profile);
+        const budget = a.budget === void 0 ? opts.perWorker : mergeBudget(opts.perWorker, a.budget);
         const res = opts.scope.spawn(agent, a.task, {
-          budget: opts.perWorker,
+          budget,
           label: typeof a.label === "string" ? a.label : "worker"
         });
         return Promise.resolve(res.ok ? { workerId: res.handle.id } : { error: res.reason });
       }
     },
     {
-      name: "observe_worker",
+      name: "observe_agent",
       description: "Inspect a worker status, spend, and settled output artifact when available.",
       inputSchema: { type: "object", properties: { workerId: idArg }, required: ["workerId"] },
       handler: async (raw) => {
@@ -7140,7 +7366,7 @@ function createCoordinationTools(opts) {
       }
     },
     {
-      name: "steer_worker",
+      name: "steer_agent",
       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",
@@ -7361,13 +7587,26 @@ 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");
+function driverAgent(opts) {
+  if (typeof opts.brain !== "function") {
+    throw new ValidationError("driverAgent: opts.brain must be a function");
+  }
+  if ((opts.extraTools?.length ?? 0) > 0 && typeof opts.executeExtraTool !== "function") {
+    throw new ValidationError(
+      "driverAgent: extraTools requires executeExtraTool (how to run a work-tool call)"
+    );
+  }
+  const reserved = new Set(coordinationVerbNames);
+  for (const t of opts.extraTools ?? []) {
+    if (reserved.has(t.name)) {
+      throw new ValidationError(
+        `driverAgent: extra work tool "${t.name}" collides with a coordination verb`
+      );
+    }
   }
   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)"
+      "driverAgent: 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;
@@ -7382,24 +7621,23 @@ function coordinationDriverAgent(opts) {
         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 toolSpecs = [
+        ...coord.tools.map((t) => ({
+          type: "function",
+          function: { name: t.name, description: t.description, parameters: t.inputSchema }
+        })),
+        // Work tools the driver calls DIRECTLY — so it can ACT, not only delegate.
+        ...(opts.extraTools ?? []).map((t) => ({
+          type: "function",
+          function: { name: t.name, description: t.description, parameters: t.parameters }
+        }))
+      ];
       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() || 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 ?? [];
+      let turn = 0;
+      const chat = async (messages, tools) => {
+        const res = await opts.brain(messages, tools);
         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,
@@ -7409,28 +7647,47 @@ function coordinationDriverAgent(opts) {
             kind: "driver-inference",
             driver: opts.name,
             turn,
-            toolCalls: calls.map((c) => c.name)
+            toolCalls: (res.toolCalls ?? []).map((c) => c.name)
           });
         }
-        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)
-          });
+        turn += 1;
+        return res;
+      };
+      await runBrainLoop({
+        chat,
+        tools: toolSpecs,
+        execute: async (name, args) => {
+          if (opts.executeExtraTool) {
+            const worked = await runExtraTool(opts.executeExtraTool, name, args);
+            if (worked !== null && worked !== void 0) return worked;
+          }
+          const tool = byName.get(name);
+          const result = tool ? await runTool(tool, args) : { error: `unknown tool: ${name}` };
+          return safeJson(result);
+        },
+        initialMessages: [
+          { role: "system", content: system },
+          { role: "user", content: stringifyTask(task) }
+        ],
+        maxTurns,
+        // The conserved-pool + deadline + external-stop bound (what maxTurns=0 relies on): a driver
+        // that can no longer spawn (pool starved) or has run past the deadline stops here instead of
+        // burning turns. Checked before each inference turn.
+        hooks: {
+          stopBefore: () => coord.isStopped() || scope.signal.aborted || poolStarved(scope, opts.perWorker) || deadlinePassed(scope, now)
         }
-      }
+      });
       return finalize2(coord, opts.blobs);
     }
   };
 }
+async function runExtraTool(execute, name, args) {
+  try {
+    return await execute(name, args);
+  } catch (e) {
+    return `error: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
 async function runTool(tool, args) {
   try {
     return await tool.handler(args);
@@ -7438,13 +7695,16 @@ async function runTool(tool, args) {
     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);
+async function finalizeBestDelivered(settled, blobs) {
+  const delivered = 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;
 }
+async function finalize2(coord, blobs) {
+  return finalizeBestDelivered(coord.settled(), blobs);
+}
 function stringifyTask(task) {
   return typeof task === "string" ? task : safeJson(task);
 }
@@ -7495,12 +7755,12 @@ function eventToSnapshot(event) {
 // src/mcp/delegation-store.ts
 import { mkdir, readFile, rename, writeFile } from "fs/promises";
 import { dirname } from "path";
-var DelegationStateCorruptError = class extends AgentEvalError {
+var DelegationStateCorruptError = class extends AgentEvalError2 {
   constructor(message, options) {
     super("validation", message, options);
   }
 };
-var DelegationPersistenceError = class extends AgentEvalError {
+var DelegationPersistenceError = class extends AgentEvalError2 {
   constructor(message, options) {
     super("config", message, options);
   }
@@ -8406,7 +8666,7 @@ function createDetachedTurnTrace(options) {
 function detachedRunningPhase(elapsedMs) {
   return elapsedMs === void 0 ? "detached-running" : `detached-running ${Math.round(elapsedMs / 1e3)}s`;
 }
-function createDriveTurnResumeDriver(options) {
+function createDetachedTurnResumeDriver(options) {
   const cancelHooked = /* @__PURE__ */ new Set();
   return {
     intervalMs: options.intervalMs ?? DEFAULT_TICK_INTERVAL_MS,
@@ -9668,6 +9928,16 @@ function watchTrace(source, opts = {}) {
   });
 }
 
+// src/runtime/supervise/model-policy.ts
+function assertModelAllowed(model, allowed) {
+  if (!allowed || model === void 0) return;
+  if (!allowed.includes(model)) {
+    throw new ConfigError(
+      `model ${JSON.stringify(model)} is not in the allowed set ${JSON.stringify([...allowed])}`
+    );
+  }
+}
+
 // src/runtime/supervise/patch-checks.ts
 var DEFAULT_MAX_DIFF_LINES = 400;
 var secretPathPattern = /(^|\/)(\.env(\.|$)|.*\.(pem|key|p12|pfx|keystore|wallet)|id_rsa|id_ed25519|secrets?\.json|credentials?\.json)$/i;
@@ -9692,12 +9962,6 @@ function countDiffLines(patch) {
   }
   return count;
 }
-function isNonEmptyPatch(patch) {
-  return touchedPathsFromPatch(patch).length > 0 && patch.trim().length > 0;
-}
-function touchesSecretPath(patch) {
-  return touchedPathsFromPatch(patch).filter((p) => secretPathPattern.test(p));
-}
 function runCoderChecks(input, constraints = {}) {
   const maxDiff = constraints.maxDiffLines ?? DEFAULT_MAX_DIFF_LINES;
   const forbidden = constraints.forbiddenPaths ?? [];
@@ -9784,72 +10048,132 @@ function signalPass(value, required) {
   return !required;
 }
 
-// src/runtime/supervise/router-driver-chat.ts
-function routerDriverChat(c, opts = {}) {
-  const temperature = opts.temperature ?? 0.4;
+// src/runtime/supervise/run-context.ts
+function createInMemoryRunContext(opts = {}) {
+  const base = createExecutorRegistry();
   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)
-        }))
-      };
-    }
+    journal: new InMemorySpawnJournal(),
+    blobs: new InMemoryResultBlobStore(),
+    executors: opts.withDriver ? withDriverExecutor(base) : base
   };
 }
-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) }
-      }))
-    };
+
+// src/runtime/supervise/supervisor-agent.ts
+function supervisorAgent(profile, deps) {
+  const name = profile.name ?? "supervisor";
+  const systemPrompt = profile.systemPrompt ?? "";
+  const harness = profile.harness ?? null;
+  if (harness === null) {
+    const brain = deps.brain ?? routerBrainFromProfile(profile, deps);
+    return driverAgent({
+      name,
+      brain,
+      blobs: deps.blobs,
+      makeWorkerAgent: deps.makeWorkerAgent,
+      perWorker: deps.perWorker,
+      systemPrompt,
+      ...deps.extraTools ? { extraTools: deps.extraTools } : {},
+      ...deps.executeExtraTool ? { executeExtraTool: deps.executeExtraTool } : {},
+      ...deps.maxTurns !== void 0 ? { maxTurns: deps.maxTurns } : {}
+    });
   }
-  if (m.role === "tool") {
-    return { role: "tool", tool_call_id: m.toolCallId ?? m.name ?? "call", content: m.content };
+  const driveHarness = deps.driveHarness;
+  if (!driveHarness) {
+    throw new ValidationError(
+      `supervisorAgent: profile.harness="${harness}" needs deps.driveHarness (how to run the harness with the coordination MCP mounted)`
+    );
   }
-  return { role: m.role, content: m.content };
+  return {
+    name,
+    async act(task, scope) {
+      const mcp = await serveCoordinationMcp({
+        scope,
+        blobs: deps.blobs,
+        makeWorkerAgent: deps.makeWorkerAgent,
+        perWorker: deps.perWorker
+      });
+      try {
+        await driveHarness({ profile, task, scope, coordinationMcpUrl: mcp.url });
+        return await finalizeBestDelivered(mcp.settled(), deps.blobs);
+      } finally {
+        await mcp.close();
+      }
+    }
+  };
 }
-function safeParse(s) {
-  try {
-    return JSON.parse(s);
-  } catch {
-    return {};
+function routerBrainFromProfile(profile, deps) {
+  if (!deps.router) {
+    throw new ValidationError(
+      "supervisorAgent: a router-brained supervisor (harness null) needs deps.router (or deps.brain)"
+    );
   }
+  return routerBrain({ ...deps.router, model: profile.model ?? deps.router.model });
 }
 
-// src/runtime/supervise/run-context.ts
-function createInMemoryRunContext(opts = {}) {
-  const base = createExecutorRegistry();
+// src/runtime/supervise/supervise.ts
+function workerFromBackend(backend, deliverable) {
+  return (rawProfile) => {
+    const p = rawProfile ?? {};
+    const name = typeof p.name === "string" && p.name.length > 0 ? p.name : "worker";
+    const spec = { profile: rawProfile, harness: null };
+    const ctx = { signal: new AbortController().signal, seams: {} };
+    const built = createExecutor(backend)(spec, ctx);
+    const executor = deliverable ? gateOnDeliverable(built, deliverable) : built;
+    return { name, act: async () => "", executorSpec: { ...spec, executor } };
+  };
+}
+function defaultPerWorker(budget) {
   return {
-    journal: new InMemorySpawnJournal(),
-    blobs: new InMemoryResultBlobStore(),
-    executors: opts.withDriver ? withDriverExecutor(base) : base
+    maxIterations: budget.maxIterations,
+    maxTokens: Math.max(1, Math.floor(budget.maxTokens / 4))
   };
 }
+function supervise(profile, task, opts) {
+  const backendModel = opts.backend?.model;
+  assertModelAllowed(opts.router?.model, opts.allowedModels);
+  assertModelAllowed(profile.model, opts.allowedModels);
+  assertModelAllowed(
+    typeof backendModel === "string" ? backendModel : void 0,
+    opts.allowedModels
+  );
+  const ctx = createInMemoryRunContext({ withDriver: true });
+  const blobs = opts.blobs ?? ctx.blobs;
+  const perWorker = opts.perWorker ?? defaultPerWorker(opts.budget);
+  let makeWorkerAgent = opts.makeWorkerAgent;
+  if (!makeWorkerAgent) {
+    if (!opts.backend) {
+      throw new ValidationError(
+        "supervise: provide opts.backend (where workers run) or opts.makeWorkerAgent"
+      );
+    }
+    makeWorkerAgent = workerFromBackend(opts.backend, opts.deliverable);
+  }
+  const agent = supervisorAgent(profile, {
+    blobs,
+    makeWorkerAgent,
+    perWorker,
+    ...opts.router ? { router: opts.router } : {},
+    ...opts.brain ? { brain: opts.brain } : {},
+    ...opts.driveHarness ? { driveHarness: opts.driveHarness } : {},
+    ...opts.extraTools ? { extraTools: opts.extraTools } : {},
+    ...opts.executeExtraTool ? { executeExtraTool: opts.executeExtraTool } : {},
+    ...opts.maxTurns !== void 0 ? { maxTurns: opts.maxTurns } : {}
+  });
+  return createSupervisor().run(agent, task, {
+    budget: opts.budget,
+    runId: opts.runId ?? "supervise",
+    journal: ctx.journal,
+    blobs,
+    executors: ctx.executors,
+    maxDepth: opts.maxDepth ?? 8,
+    ...opts.now ? { now: opts.now } : {}
+  });
+}
 
 // src/runtime/supervise/trace-source.ts
 function toToolSpan(input, runId, seq, at) {
+  const startedAt = typeof input.startedAt === "number" ? input.startedAt : at;
+  const endedAt = typeof input.endedAt === "number" ? input.endedAt : startedAt;
   return {
     spanId: `${runId}-t${seq}`,
     runId,
@@ -9858,8 +10182,8 @@ function toToolSpan(input, runId, seq, at) {
     toolName: input.toolName,
     args: input.args,
     status: input.status ?? "ok",
-    startedAt: at,
-    endedAt: at,
+    startedAt,
+    endedAt,
     ...input.result !== void 0 ? { result: input.result } : {}
   };
 }
@@ -9899,7 +10223,7 @@ var decodeOpenAiPart = (p) => {
   const rawArgs = fn?.arguments ?? p.arguments;
   return {
     toolName: name,
-    args: typeof rawArgs === "string" ? safeParse2(rawArgs) : rawArgs ?? {},
+    args: typeof rawArgs === "string" ? safeParse(rawArgs) : rawArgs ?? {},
     ...str(p.id) ? { callId: p.id } : str(fn?.id) ? { callId: fn?.id } : {}
   };
 };
@@ -9923,7 +10247,7 @@ function decodeToolPart(part, harness) {
   }
   return void 0;
 }
-function safeParse2(s) {
+function safeParse(s) {
   try {
     return JSON.parse(s);
   } catch {
@@ -10369,13 +10693,22 @@ function tail(s) {
 }
 
 export {
+  SessionMismatchError,
+  BackendTransportError,
+  RuntimeRunStateError,
+  PlannerError,
+  AgentEvalError2 as AgentEvalError,
+  ConfigError,
+  JudgeError,
+  NotFoundError,
+  ValidationError,
+  runLocalHarness,
+  assertModelAllowed,
+  extractLlmCallEvent,
+  mapSandboxEvent,
   contentAddress,
   InMemoryResultBlobStore,
-  FileResultBlobStore,
   InMemorySpawnJournal,
-  FileSpawnJournal,
-  replaySpawnTree,
-  materializeTreeView,
   anytimeReport,
   renderAnytimeTable,
   defaultAuditorInstruction,
@@ -10398,7 +10731,6 @@ export {
   probeSandboxCapabilities,
   createSandboxLineage,
   runLoop,
-  describeSandboxPlacement,
   createSandboxForSpec,
   defaultSelectWinner,
   loopDispatch,
@@ -10407,7 +10739,6 @@ export {
   createScopeAnalyst,
   registryScopeAnalyst,
   buildSteerContext,
-  nestedScopeSeamKey,
   createScope,
   settledToIteration,
   selectValidWinner,
@@ -10421,14 +10752,10 @@ export {
   InMemoryCorpus,
   FileCorpus,
   renderCorpusToInstructions,
-  driverRuntime,
-  driverChild,
-  isDriverSpec,
-  driverExecutorFactory,
-  withDriverExecutor,
   routerChatWithUsage,
   routerChatWithTools,
   routerToolLoop,
+  routerBrain,
   createInbox,
   createWorktree,
   captureWorktreeDiff,
@@ -10441,7 +10768,6 @@ export {
   spendFromUsageEvents,
   createBudgetPool,
   createSupervisor,
-  createRootHandle,
   createShapeRegistry,
   builtinShapes,
   registerShape,
@@ -10450,8 +10776,8 @@ export {
   trajectoryReport,
   equalKOnCost,
   promotionGate,
-  depthDriver,
-  breadthDriver,
+  depthStrategy,
+  breadthStrategy,
   sample,
   refine,
   defineStrategy,
@@ -10470,11 +10796,15 @@ export {
   runStrategyEvolution,
   gateOnDeliverable,
   asAuthoredProfile,
-  supervisorSkill,
+  supervisorInstructions,
   authoredWorker,
+  defaultProfileRichnessThresholds,
+  assessAuthoredProfile,
+  profileRichnessFinding,
   createEventBus,
   createCoordinationTools,
-  coordinationDriverAgent,
+  driverAgent,
+  finalizeBestDelivered,
   InMemoryFeedbackStore,
   eventToSnapshot,
   DelegationStateCorruptError,
@@ -10493,7 +10823,7 @@ export {
   parseDetachedSessionRef,
   detachedTurnEvents,
   runDetachedTurn,
-  createDriveTurnResumeDriver,
+  createDetachedTurnResumeDriver,
   DELEGATE_CODE_TOOL_NAME,
   DELEGATE_CODE_DESCRIPTION,
   DELEGATE_CODE_INPUT_SCHEMA,
@@ -10529,22 +10859,14 @@ export {
   serveCoordinationMcp,
   defaultToolDetectors,
   watchTrace,
-  touchedPathsFromPatch,
-  countDiffLines,
-  isNonEmptyPatch,
-  touchesSecretPath,
   runCoderChecks,
   patchDelivered,
-  routerDriverChat,
   createInMemoryRunContext,
-  toToolSpan,
-  decodeOpencodePart,
-  decodeAnthropicPart,
-  decodeOpenAiPart,
-  toolPartDecoders,
+  supervisorAgent,
+  workerFromBackend,
+  supervise,
   decodeToolPart,
   createPushTraceSource,
-  createPartsTraceSource,
   sandboxSessionTraceSource,
   analyzeTrace,
   worktreeFanout,
@@ -10553,6 +10875,8 @@ export {
   localShell,
   gitWorkspace,
   jjWorkspace,
-  runInWorkspace
+  runInWorkspace,
+  computeFindingId2 as computeFindingId,
+  makeFinding3 as makeFinding
 };
-//# sourceMappingURL=chunk-VKUHUFX7.js.map
+//# sourceMappingURL=chunk-QXWGSDAQ.js.map