@tangle-network/agent-runtime 0.101.1 → 0.102.1

package/dist/{chunk-KVJQV342.js → chunk-6MR4IJRW.js}

@@ -6,9 +6,18 @@ import {
 } from "./chunk-2VZYRB55.js";
 import {
   assertModelAllowed,
-  harnessInvocation,
-  runLocalHarness
-} from "./chunk-IKGCKPDX.js";
+  captureWorktreeDiff,
+  createSupervisor,
+  createWorktree,
+  notifyRuntimeHookEvent,
+  removeWorktree,
+  routerBrain,
+  routerChatWithUsage,
+  runBrainLoop,
+  runWorktreeChecks,
+  runWorktreeHarness,
+  withDriverExecutor
+} from "./chunk-SQ3ZJH3Y.js";
 import {
   InMemoryResultBlobStore,
   InMemorySpawnJournal,
@@ -38,7 +47,6 @@ import {
   AgentEvalError,
   ConfigError,
   NotFoundError,
-  RuntimeRunStateError,
   ValidationError
 } from "./chunk-YEJR7IXO.js";
 
@@ -84,919 +92,6 @@ function isAsyncIterable(v) {
   return v != null && typeof v[Symbol.asyncIterator] === "function";
 }
 
-// src/runtime-hooks.ts
-function defineRuntimeHooks(hooks) {
-  return hooks;
-}
-function composeRuntimeHooks(...entries) {
-  const hooks = entries.filter((entry) => !!entry);
-  return {
-    onEvent: hooks.some((hook) => hook.onEvent) ? (event, context) => {
-      const pending = [];
-      for (const hook of hooks) {
-        const result = hook.onEvent?.(event, context);
-        if (isThenable(result)) pending.push(Promise.resolve(result));
-      }
-      if (pending.length > 0) return Promise.all(pending).then(() => void 0);
-      return void 0;
-    } : void 0,
-    onDecisionPoint: hooks.some((hook) => hook.onDecisionPoint) ? (point, context) => {
-      const pending = [];
-      for (const hook of hooks) {
-        const result = hook.onDecisionPoint?.(point, context);
-        if (isThenable(result)) pending.push(Promise.resolve(result));
-      }
-      if (pending.length > 0) return Promise.all(pending).then(() => void 0);
-      return void 0;
-    } : void 0,
-    onHookError: hooks.some((hook) => hook.onHookError) ? (error, context) => {
-      const pending = [];
-      for (const hook of hooks) {
-        const result = hook.onHookError?.(error, context);
-        if (isThenable(result)) pending.push(Promise.resolve(result));
-      }
-      if (pending.length > 0) return Promise.all(pending).then(() => void 0);
-      return void 0;
-    } : void 0
-  };
-}
-function notifyRuntimeHookEvent(hooks, event, context = {}) {
-  const onEvent = hooks?.onEvent;
-  if (!onEvent) return;
-  try {
-    const result = onEvent(event, context);
-    if (isThenable(result)) {
-      void result.catch((error) => {
-        notifyRuntimeHookError(hooks, toError(error), {
-          hook: "onEvent",
-          eventId: event.id,
-          target: event.target,
-          phase: event.phase
-        });
-      });
-    }
-  } catch (error) {
-    notifyRuntimeHookError(hooks, toError(error), {
-      hook: "onEvent",
-      eventId: event.id,
-      target: event.target,
-      phase: event.phase
-    });
-  }
-}
-function notifyRuntimeDecisionPoint(hooks, point, context = {}) {
-  const onDecisionPoint = hooks?.onDecisionPoint;
-  if (!onDecisionPoint) return;
-  try {
-    const result = onDecisionPoint(point, context);
-    if (isThenable(result)) {
-      void result.catch((error) => {
-        notifyRuntimeHookError(hooks, toError(error), {
-          hook: "onDecisionPoint",
-          decisionId: point.id,
-          decisionKind: point.kind
-        });
-      });
-    }
-  } catch (error) {
-    notifyRuntimeHookError(hooks, toError(error), {
-      hook: "onDecisionPoint",
-      decisionId: point.id,
-      decisionKind: point.kind
-    });
-  }
-}
-function notifyRuntimeHookError(hooks, error, context) {
-  try {
-    const result = hooks?.onHookError?.(error, context);
-    if (isThenable(result)) void result.catch(() => void 0);
-  } catch {
-  }
-}
-function isThenable(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-
-// src/runtime/supervise/scope.ts
-var nestedScopeSeamKey = "nested-scope";
-function makeNestedScopeSeam(args, childNodeId) {
-  return {
-    depth: args.depth,
-    ...args.maxDepth !== void 0 ? { maxDepth: args.maxDepth } : {},
-    journalRoot: args.root,
-    mount(nestedRoot, signal) {
-      return createScope({
-        parentId: childNodeId,
-        root: nestedRoot,
-        pool: args.pool,
-        journal: args.journal,
-        blobs: args.blobs,
-        executors: args.executors,
-        // Re-seed the parent's NON-recursion seams (sandbox/router for leaf grandchildren);
-        // the nested scope adds its OWN nested-scope seam per child in `spawn`.
-        seams: args.seams,
-        depth: args.depth + 1,
-        ...args.maxDepth !== void 0 ? { maxDepth: args.maxDepth } : {},
-        signal,
-        ...args.now ? { now: args.now } : {},
-        ...args.hooks ? { hooks: args.hooks } : {}
-      });
-    }
-  };
-}
-function createScope(args) {
-  const children = /* @__PURE__ */ new Map();
-  let spawnOrdinal = 0;
-  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) {
-      return { ok: false, reason: "depth-exceeded" };
-    }
-    const spec = agent.executorSpec;
-    if (!isAgentSpec(spec)) {
-      throw new ValidationError(
-        `scope.spawn: agent "${agent.name}" exposes no \`executorSpec\` (AgentSpec) to resolve a Executor`
-      );
-    }
-    const resolved = args.executors.resolve(spec);
-    if (!resolved.succeeded) throw new ValidationError(`scope.spawn: ${resolved.error}`);
-    const reservation = args.pool.reserve(opts.budget);
-    if (!reservation.ok) return { ok: false, reason: reservation.reason };
-    try {
-      const ordinal = spawnOrdinal++;
-      const id = `${args.parentId}:s${ordinal}`;
-      const childAbort = new AbortController();
-      const cascadeAbort = () => childAbort.abort();
-      if (args.signal.aborted) childAbort.abort();
-      else args.signal.addEventListener("abort", cascadeAbort, { once: true });
-      const ctx = {
-        signal: childAbort.signal,
-        seams: { ...args.seams, [nestedScopeSeamKey]: makeNestedScopeSeam(args, id) }
-      };
-      const executor = resolved.value(spec, ctx);
-      const handle = {
-        id,
-        label: opts.label,
-        get status() {
-          return children.get(id)?.status ?? "cancelled";
-        },
-        abort(reason) {
-          childAbort.abort(reason);
-        }
-      };
-      const live = {
-        id,
-        status: "acquiring",
-        runtime: executor.runtime,
-        budget: opts.budget,
-        label: opts.label,
-        spent: zeroSpend(),
-        settled: void 0,
-        delivered: false,
-        executorDone: false,
-        ...executor.deliver ? { deliver: executor.deliver.bind(executor) } : {}
-      };
-      children.set(id, live);
-      void args.journal.appendEvent(args.root, {
-        kind: "spawned",
-        id,
-        parent: args.parentId,
-        label: opts.label,
-        budget: opts.budget,
-        runtime: executor.runtime,
-        seq: ordinal,
-        at: new Date(now()).toISOString()
-      });
-      notifyRuntimeHookEvent(
-        args.hooks,
-        {
-          id: `${id}:spawn`,
-          runId: args.root,
-          target: "agent.spawn",
-          phase: "after",
-          timestamp: now(),
-          stepIndex: ordinal,
-          parentId: args.parentId,
-          payload: {
-            childId: id,
-            label: opts.label,
-            runtime: executor.runtime,
-            budget: opts.budget,
-            depth: args.depth
-          }
-        },
-        { signal: args.signal }
-      );
-      const settled = runChild(
-        live,
-        executor,
-        childAbort,
-        task,
-        opts,
-        args.pool,
-        reservation.ticket,
-        args.blobs
-      ).then((s) => {
-        live.resolved = s;
-        return s;
-      }).finally(() => {
-        args.signal.removeEventListener("abort", cascadeAbort);
-      });
-      live.settled = settled;
-      return { ok: true, handle };
-    } catch (err) {
-      args.pool.reconcile(reservation.ticket, zeroSpend());
-      throw err;
-    }
-  }
-  async function next() {
-    const undelivered = () => [...children.values()].filter((c) => !c.delivered);
-    if (undelivered().length === 0) return null;
-    for (; ; ) {
-      const pending = undelivered();
-      if (pending.length === 0) return null;
-      const ready = pending.find((c) => c.resolved !== void 0);
-      const chosen = ready ?? await raceFirstSettled(pending);
-      if (chosen.delivered) continue;
-      chosen.delivered = true;
-      const seq = cursorSeq++;
-      const settlement = chosen.resolved;
-      if (!settlement) {
-        throw new ValidationError(
-          `scope.next: child '${chosen.id}' won the settle race without a resolved value`
-        );
-      }
-      return finalizeSettlement(chosen, settlement, seq, args, now);
-    }
-  }
-  async function nextResolved() {
-    for (; ; ) {
-      const candidates = [...children.values()].filter((c) => !c.delivered);
-      const pick = candidates.find((c) => c.resolved !== void 0) ?? candidates.find((c) => c.executorDone);
-      if (!pick) return null;
-      const settlement = await pick.settled;
-      if (pick.delivered) continue;
-      pick.delivered = true;
-      const seq = cursorSeq++;
-      return finalizeSettlement(pick, settlement, seq, args, now);
-    }
-  }
-  function send(nodeId, msg) {
-    const child = children.get(nodeId);
-    if (!child || child.delivered || !child.deliver) return false;
-    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,
-    nextResolved,
-    send,
-    signal: args.signal,
-    meter,
-    get view() {
-      return makeTreeView(args.parentId, children);
-    },
-    get budget() {
-      return args.pool.readout();
-    }
-  };
-}
-async function raceFirstSettled(pending) {
-  return Promise.race(pending.map((c) => c.settled.then(() => c)));
-}
-async function finalizeSettlement(child, settlement, seq, args, now) {
-  const handle = frozenHandle(child);
-  if (settlement.kind === "down") {
-    child.status = "failed";
-    await args.journal.appendEvent(args.root, {
-      kind: "settled",
-      id: child.id,
-      status: "down",
-      spent: child.spent,
-      infra: settlement.infra,
-      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,
-      {
-        id: `${child.id}:settled`,
-        runId: args.root,
-        target: "agent.child",
-        phase: "after",
-        timestamp: now(),
-        stepIndex: seq,
-        parentId: args.parentId,
-        payload: {
-          childId: child.id,
-          status: "down",
-          reason: settlement.reason,
-          infra: settlement.infra,
-          spent: child.spent
-        }
-      },
-      { signal: args.signal }
-    );
-    return {
-      kind: "down",
-      handle,
-      reason: settlement.reason,
-      infra: settlement.infra,
-      restartCount: settlement.restartCount,
-      seq
-    };
-  }
-  child.status = "done";
-  child.outRef = settlement.outRef;
-  child.spent = settlement.spent;
-  await args.journal.appendEvent(args.root, {
-    kind: "settled",
-    id: child.id,
-    status: "done",
-    outRef: settlement.outRef,
-    ...settlement.verdict ? { verdict: settlement.verdict } : {},
-    spent: settlement.spent,
-    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,
-    {
-      id: `${child.id}:settled`,
-      runId: args.root,
-      target: "agent.child",
-      phase: "after",
-      timestamp: now(),
-      stepIndex: seq,
-      parentId: args.parentId,
-      payload: {
-        childId: child.id,
-        status: "done",
-        outRef: settlement.outRef,
-        score: settlement.verdict?.score,
-        valid: settlement.verdict?.valid,
-        spent: settlement.spent
-      }
-    },
-    { signal: args.signal }
-  );
-  return {
-    kind: "done",
-    handle,
-    out: settlement.out,
-    outRef: settlement.outRef,
-    ...settlement.verdict ? { verdict: settlement.verdict } : {},
-    spent: settlement.spent,
-    seq
-  };
-}
-async function runChild(live, executor, childAbort, task, opts, pool, ticket, blobs) {
-  let reconciled = false;
-  const reconcileOnce = (spend) => {
-    if (reconciled) return;
-    reconciled = true;
-    pool.reconcile(ticket, clampSpend(spend, opts.budget));
-  };
-  try {
-    live.status = "running";
-    const ran = executor.execute(task, childAbort.signal);
-    let artifact;
-    if (isAsyncIterable2(ran)) {
-      const spend = await foldStream(ran);
-      live.spent = spend;
-      artifact = executor.resultArtifact();
-      reconcileOnce(spend);
-    } else {
-      const terminal = await ran;
-      live.spent = terminal.spent;
-      artifact = terminal;
-      reconcileOnce(terminal.spent);
-    }
-    live.executorDone = true;
-    const ownMetered = executor.metered?.();
-    if (childAbort.signal.aborted) {
-      await teardownSafe(executor, opts.shutdown ?? "brutalKill");
-      return downRecord("aborted before settle", true, ownMetered);
-    }
-    const outRef = contentAddress(artifact.out);
-    await blobs.put(outRef, artifact.out);
-    await teardownSafe(executor, opts.shutdown ?? "infinity");
-    return {
-      kind: "done",
-      out: artifact.out,
-      outRef,
-      ...artifact.verdict ? { verdict: artifact.verdict } : {},
-      spent: live.spent,
-      ...ownMetered ? { metered: ownMetered } : {}
-    };
-  } catch (err) {
-    live.executorDone = true;
-    reconcileOnce(live.spent);
-    await teardownSafe(executor, "brutalKill");
-    const aborted = childAbort.signal.aborted || isAbortError(err);
-    return downRecord(errMessage(err), aborted || isInfraError(err), executor.metered?.());
-  }
-}
-function settledToIteration(settled) {
-  if (settled.kind === "down") {
-    throw new ValidationError(
-      `settledToIteration: cannot adapt a 'down' settlement (node '${settled.handle.id}', seq ${settled.seq}) to an Iteration`
-    );
-  }
-  return {
-    index: settled.seq,
-    task: void 0,
-    agentRunName: settled.handle.label,
-    output: settled.out,
-    ...settled.verdict ? { verdict: settled.verdict } : {},
-    events: [],
-    startedAt: 0,
-    endedAt: settled.spent.ms,
-    costUsd: settled.spent.usd,
-    tokenUsage: { input: settled.spent.tokens.input, output: settled.spent.tokens.output }
-  };
-}
-function makeTreeView(root, children) {
-  const nodes = [...children.values()].map((c) => ({
-    id: c.id,
-    parent: root,
-    label: c.label,
-    status: c.status,
-    runtime: c.runtime,
-    budget: c.budget,
-    spent: c.spent,
-    ...c.outRef ? { outRef: c.outRef } : {}
-  }));
-  return {
-    root,
-    nodes,
-    inFlight: nodes.filter((n) => n.status === "running" || n.status === "acquiring").length
-  };
-}
-function frozenHandle(child) {
-  return {
-    id: child.id,
-    label: child.label,
-    status: child.status,
-    abort() {
-    }
-  };
-}
-async function foldStream(stream) {
-  const tokens = { input: 0, output: 0 };
-  let usd = 0;
-  let iterations = 0;
-  for await (const ev of stream) {
-    if (ev.kind === "tokens") {
-      tokens.input += ev.input;
-      tokens.output += ev.output;
-    } else if (ev.kind === "cost") {
-      usd += ev.usd;
-    } else {
-      iterations += 1;
-    }
-  }
-  return { iterations, tokens, usd, ms: 0 };
-}
-function clampSpend(spend, budget) {
-  const totalTokens2 = spend.tokens.input + spend.tokens.output;
-  const tokensOk = totalTokens2 <= budget.maxTokens;
-  const itersOk = spend.iterations <= budget.maxIterations;
-  const usdOk = budget.maxUsd === void 0 || spend.usd <= budget.maxUsd;
-  if (tokensOk && itersOk && usdOk) return spend;
-  const ratio = !tokensOk && totalTokens2 > 0 ? budget.maxTokens / totalTokens2 : 1;
-  return {
-    iterations: Math.min(spend.iterations, budget.maxIterations),
-    tokens: ratio < 1 ? {
-      input: Math.floor(spend.tokens.input * ratio),
-      output: Math.floor(spend.tokens.output * ratio)
-    } : spend.tokens,
-    usd: budget.maxUsd === void 0 ? spend.usd : Math.min(spend.usd, budget.maxUsd),
-    ...spend.usdKnown === false ? { usdKnown: false } : {},
-    ms: spend.ms
-  };
-}
-async function teardownSafe(executor, grace) {
-  try {
-    await executor.teardown(grace);
-  } catch {
-  }
-}
-function downRecord(reason, infra, metered) {
-  return { kind: "down", reason, infra, restartCount: 0, ...metered ? { metered } : {} };
-}
-function zeroSpend() {
-  return { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
-}
-function isAsyncIterable2(value) {
-  return typeof value === "object" && value !== null && typeof value[Symbol.asyncIterator] === "function";
-}
-function isAgentSpec(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const v = value;
-  return "profile" in v && "harness" in v;
-}
-function isAbortError(err) {
-  return typeof err === "object" && err !== null && "name" in err && err.name === "AbortError";
-}
-function isInfraError(err) {
-  return err instanceof ValidationError;
-}
-function errMessage(err) {
-  if (err instanceof Error) return err.message;
-  return String(err);
-}
-
-// src/mcp/worktree.ts
-import { spawn } from "child_process";
-import { isAbsolute, win32 } from "path";
-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" });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout?.on("data", (c) => {
-      stdout += String(c);
-    });
-    proc.stderr?.on("data", (c) => {
-      stderr += String(c);
-    });
-    proc.on("error", reject);
-    proc.on("close", (code) => resolve({ stdout, stderr, exitCode: code ?? -1 }));
-  });
-}
-function ensureGitOk(step, result) {
-  if (result.exitCode !== 0) {
-    throw gitFailure(step, result);
-  }
-}
-function gitFailure(step, result) {
-  return new Error(
-    `worktree: git ${step} failed (exit ${result.exitCode}): ${result.stderr.slice(0, 400)}`
-  );
-}
-async function createWorktree(options) {
-  const variants = options.variantsDir ?? ".agent-worktrees";
-  const baseRef = options.baseRef ?? "HEAD";
-  const branch = `delegate/${options.runId}`;
-  const path2 = `${options.repoRoot.replace(/\/+$/, "")}/${variants}/${options.runId}`;
-  const headSha = await runGitAsync(["rev-parse", baseRef], options.repoRoot, options.runGit);
-  ensureGitOk(`rev-parse ${baseRef}`, headSha);
-  const add = await runGitAsync(
-    ["worktree", "add", "-b", branch, path2, baseRef],
-    options.repoRoot,
-    options.runGit
-  );
-  ensureGitOk(`worktree add ${path2}`, add);
-  return { path: path2, baseSha: headSha.stdout.trim(), branch };
-}
-async function captureWorktreeDiff(options) {
-  const baseRef = options.baseRef ?? options.worktree.baseSha;
-  const pathspecs = worktreeDiffPathspecs(options.excludePaths ?? []);
-  const staged = await runGitAsync(
-    ["add", "-A", ...pathspecs.length > 0 ? ["--", ".", ...pathspecs] : []],
-    options.worktree.path,
-    options.runGit
-  );
-  ensureGitOk("add -A", staged);
-  const patch = await runGitAsync(
-    ["diff", "--cached", baseRef, ...pathspecs.length > 0 ? ["--", ".", ...pathspecs] : []],
-    options.worktree.path,
-    options.runGit
-  );
-  ensureGitOk(`diff --cached ${baseRef}`, patch);
-  const shortstat = await runGitAsync(
-    [
-      "diff",
-      "--cached",
-      "--shortstat",
-      baseRef,
-      ...pathspecs.length > 0 ? ["--", ".", ...pathspecs] : []
-    ],
-    options.worktree.path,
-    options.runGit
-  );
-  ensureGitOk(`diff --cached --shortstat ${baseRef}`, shortstat);
-  const stats = parseShortstat(shortstat.stdout);
-  return { patch: patch.stdout, stats };
-}
-function worktreeDiffPathspecs(paths) {
-  const normalized = /* @__PURE__ */ new Set();
-  for (const path2 of paths) {
-    if (typeof path2 !== "string" || path2.length === 0 || path2.includes("\\") || hasControlCharacter(path2) || isAbsolute(path2) || win32.isAbsolute(path2)) {
-      throw new Error(
-        `worktree: excluded path must be a canonical repository-relative path: ${path2}`
-      );
-    }
-    const segments = path2.split("/");
-    if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
-      throw new Error(
-        `worktree: excluded path must be a canonical repository-relative path: ${path2}`
-      );
-    }
-    normalized.add(path2);
-  }
-  return [...normalized].sort((left, right) => left.localeCompare(right)).map((path2) => `:(top,exclude,literal)${path2}`);
-}
-function hasControlCharacter(value) {
-  for (let index = 0; index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
-    if (code < 32 || code === 127) return true;
-  }
-  return false;
-}
-function parseShortstat(text) {
-  const out = { filesChanged: 0, insertions: 0, deletions: 0 };
-  const filesMatch = text.match(/(\d+)\s+files?\s+changed/);
-  if (filesMatch?.[1]) out.filesChanged = Number(filesMatch[1]);
-  const insertMatch = text.match(/(\d+)\s+insertions?/);
-  if (insertMatch?.[1]) out.insertions = Number(insertMatch[1]);
-  const deleteMatch = text.match(/(\d+)\s+deletions?/);
-  if (deleteMatch?.[1]) out.deletions = Number(deleteMatch[1]);
-  return out;
-}
-async function removeWorktree(options) {
-  const force = options.force ?? true;
-  const args = ["worktree", "remove"];
-  if (force) args.push("--force");
-  args.push(options.worktree.path);
-  const removal = await runGitAsync(args, options.repoRoot, options.runGit);
-  const removalError = removal.exitCode !== 0 && !/not a working tree/iu.test(removal.stderr) ? gitFailure(`worktree remove ${options.worktree.path}`, removal) : void 0;
-  const branchRemoval = await runGitAsync(
-    ["branch", "-D", options.worktree.branch],
-    options.repoRoot,
-    options.runGit
-  );
-  const branchError = branchRemoval.exitCode !== 0 && !/branch .+ not found/iu.test(branchRemoval.stderr) ? gitFailure(`branch -D ${options.worktree.branch}`, branchRemoval) : void 0;
-  if (removalError && branchError) {
-    throw new AggregateError(
-      [removalError, branchError],
-      "worktree: failed to remove worktree and branch"
-    );
-  }
-  if (removalError) throw removalError;
-  if (branchError) throw branchError;
-}
-
-// src/runtime/router-client.ts
-import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
-
-// src/runtime/tool-loop.ts
-function estimateConversationTokens(messages) {
-  let chars = 0;
-  for (const m of messages) {
-    const content = m.content;
-    chars += typeof content === "string" ? content.length : safeJsonLength(content);
-    const calls = m.tool_calls;
-    if (calls) for (const c of calls) chars += c.function?.arguments?.length ?? 0;
-  }
-  return Math.ceil(chars / 4);
-}
-function safeJsonLength(value) {
-  if (value === void 0 || value === null) return 0;
-  try {
-    return JSON.stringify(value)?.length ?? 0;
-  } catch {
-    return String(value).length;
-  }
-}
-async function maybeCompact(messages, c, turn) {
-  const head = c.preserveHead !== void 0 && c.preserveHead > 0 ? c.preserveHead : 2;
-  if (messages.length <= head + 1) return false;
-  const estimate = c.estimateTokens ?? estimateConversationTokens;
-  const before = estimate(messages);
-  if (before <= c.thresholdTokens) return false;
-  const digest = await c.distill([...messages]);
-  messages.splice(head, messages.length - head, {
-    role: "user",
-    content: `[earlier work compacted to save context \u2014 progress so far]
-${digest}`
-  });
-  c.onCompact?.({ turn, beforeTokens: before, afterTokens: estimate(messages) });
-  return true;
-}
-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);
-    if (opts.compaction) await maybeCompact(messages, opts.compaction, turn);
-    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) {
-      if (r.content) messages.push({ role: "assistant", content: r.content });
-      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}` };
-  let temperature = opts?.temperature ?? 0.2;
-  const body = () => ({
-    model: cfg.model,
-    messages,
-    temperature,
-    max_tokens: opts?.maxTokens ?? 8192,
-    ...opts?.reasoningEffort ? { reasoning_effort: opts.reasoningEffort } : {}
-  });
-  if (cfg.complete) return parseChatResult(await cfg.complete(body()), cfg.model);
-  let lastErr = "";
-  for (let attempt = 0; attempt < 5; attempt += 1) {
-    const res = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body()),
-      ...opts?.signal ? { signal: opts.signal } : {}
-    });
-    if (res.ok) return parseChatResult(await res.json(), cfg.model);
-    const status = res.status;
-    const text = (await res.text()).slice(0, 200);
-    lastErr = `router ${status}: ${text}`;
-    if (status === 400 && /temperature/i.test(text) && temperature !== 1) {
-      temperature = 1;
-      continue;
-    }
-    if (![408, 425, 429, 500, 502, 503, 504, 520, 522, 524].includes(status))
-      throw new Error(lastErr);
-    if (attempt < 4) await new Promise((r) => setTimeout(r, 800 * 2 ** attempt));
-  }
-  throw new Error(`${lastErr} (exhausted retries)`);
-}
-function parseChatResult(json, model) {
-  const data = 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 costUsd = usage && isModelPriced(model) ? estimateCost(usage.input, usage.output, model) : void 0;
-  const msg = data.choices?.[0]?.message;
-  const { content, reasoning } = splitReasoning(
-    msg?.content ?? "",
-    msg?.reasoning ?? msg?.reasoning_content
-  );
-  return {
-    content,
-    ...reasoning ? { reasoning } : {},
-    ...usage ? { usage } : {},
-    ...costUsd !== void 0 ? { costUsd } : {}
-  };
-}
-function splitReasoning(rawContent, fieldReasoning) {
-  const open = rawContent.indexOf("<think>");
-  if (open !== -1) {
-    const close = rawContent.indexOf("</think>", open);
-    const inline = close !== -1 ? rawContent.slice(open + 7, close) : rawContent.slice(open + 7);
-    const rest = close !== -1 ? rawContent.slice(0, open) + rawContent.slice(close + 8) : rawContent.slice(0, open);
-    const reasoning = [fieldReasoning, inline.trim()].filter(Boolean).join("\n");
-    return { content: rest.trim(), ...reasoning ? { reasoning } : {} };
-  }
-  return { content: rawContent, ...fieldReasoning ? { reasoning: fieldReasoning } : {} };
-}
-async function routerChatWithTools(cfg, messages, tools, opts) {
-  const body = {
-    model: cfg.model,
-    messages,
-    tools,
-    tool_choice: opts?.toolChoice ?? "auto",
-    temperature: opts?.temperature ?? 0.3,
-    ...opts?.maxTokens ? { max_tokens: opts.maxTokens } : {}
-  };
-  const raw = cfg.complete ? await cfg.complete(body) : await (async () => {
-    const res = await fetch(`${cfg.routerBaseUrl.replace(/\/$/, "")}/chat/completions`, {
-      method: "POST",
-      headers: { "content-type": "application/json", authorization: `Bearer ${cfg.routerKey}` },
-      body: JSON.stringify(body),
-      ...opts?.signal ? { signal: opts.signal } : {}
-    });
-    if (!res.ok) throw new Error(`router ${res.status}: ${(await res.text()).slice(0, 200)}`);
-    return res.json();
-  })();
-  const data = raw;
-  const msg = data.choices?.[0]?.message;
-  const toolCalls = (msg?.tool_calls ?? []).map((tc, i) => ({
-    id: tc.id ?? `call_${i}`,
-    name: tc.function?.name ?? "",
-    arguments: tc.function?.arguments ?? "{}"
-  }));
-  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 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 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/sandbox-acquire.ts
 var RETRYABLE_HTTP = /* @__PURE__ */ new Set([502, 503, 504, 522, 524, 408, 425, 429]);
 var TERMINAL_STATUS = /* @__PURE__ */ new Set(["failed", "expired", "stopped"]);
@@ -1687,13 +782,13 @@ async function executeIteration(args) {
       await destroySandboxSafe(box, args.ctx.traceEmitter, args.runId, args.now);
     }
   }
-  if (isAbortError2(slot.error) || args.signal.aborted) {
+  if (isAbortError(slot.error) || args.signal.aborted) {
     if (slot.error) throw slot.error;
     throwAbort();
   }
   if (slot.error instanceof ValidationError) throw slot.error;
 }
-function isAbortError2(err) {
+function isAbortError(err) {
   return err instanceof Error && err.name === "AbortError";
 }
 var TEARDOWN_TIMEOUT_MS2 = 15e3;
@@ -2003,302 +1098,6 @@ ${lines.join("\n")}`;
 
 // src/runtime/supervise/worktree-cli-executor.ts
 import { randomUUID } from "crypto";
-
-// src/mcp/worktree-harness.ts
-import { spawn as spawn2 } from "child_process";
-import { createHash } from "crypto";
-import {
-  applyWorkspacePlan,
-  materializeProfile
-} from "@tangle-network/agent-profile-materialize";
-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 } : {}
-  });
-  try {
-    assertSupportedWorktreeProfile(opts.profile, opts.harness);
-    assertSafeProfileResourcePaths(opts.profile);
-    const resourceInstructions = resolveResourceInstructions(opts.profile);
-    const workspaceProfile = materializationOnlyProfile(opts.profile);
-    const plan = materializeProfile(workspaceProfile, opts.harness);
-    if (plan.unsupported.length > 0) {
-      throw new Error(
-        `runWorktreeHarness: profile cannot be materialized for ${opts.harness}: ${plan.unsupported.map(({ dimension, reason }) => `${dimension}: ${reason}`).join("; ")}`
-      );
-    }
-    assertSafeMaterializedPaths(plan);
-    const applied = applyWorkspacePlan(plan, worktree.path, { existingFiles: "reject" });
-    if (applied.unsupported.length > 0) {
-      throw new Error("runWorktreeHarness: applied profile unexpectedly retained unsupported rows");
-    }
-    const invocationProfile = profileWithResourceInstructions(opts.profile, resourceInstructions);
-    const { command, args } = harnessInvocation(opts.harness, invocationProfile, opts.taskPrompt, {
-      // This helper created the candidate worktree above; autonomous Claude
-      // edits are permitted only inside that isolated checkout.
-      dangerouslySkipPermissions: opts.harness === "claude",
-      ...opts.codexReproducible ? { codexReproducible: true } : {}
-    });
-    const harnessResult = await runHarness({
-      harness: opts.harness,
-      cwd: worktree.path,
-      taskPrompt: opts.taskPrompt,
-      invocation: { command, args: [...args, ...applied.flags] },
-      env: { ...process.env, ...applied.env },
-      ...opts.codexReproducible ? { codexReproducible: true } : {},
-      ...opts.codexReadDeniedPaths ? { codexReadDeniedPaths: opts.codexReadDeniedPaths } : {},
-      ...opts.harnessTimeoutMs !== void 0 ? { timeoutMs: opts.harnessTimeoutMs } : {},
-      ...opts.signal ? { signal: opts.signal } : {}
-    });
-    const diff = await captureWorktreeDiff({
-      worktree,
-      excludePaths: applied.written,
-      ...opts.runGit ? { runGit: opts.runGit } : {}
-    });
-    const checks = await runWorktreeChecks({
-      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,
-      profileMaterialization: profileMaterializationReceipt(applied, resourceInstructions),
-      harness: {
-        name: opts.harness,
-        exitCode: harnessResult.exitCode,
-        timedOut: harnessResult.timedOut,
-        killedBySignal: harnessResult.killedBySignal,
-        durationMs: harnessResult.durationMs,
-        stdout: harnessResult.stdout,
-        stderr: harnessResult.stderr,
-        ...harnessResult.usage ? { usage: harnessResult.usage } : {},
-        ...harnessResult.evidence ? {
-          cliVersion: harnessResult.evidence.cliVersion,
-          executableSha256: harnessResult.evidence.executableSha256,
-          requestedPromptSha256: harnessResult.evidence.requestedPromptSha256,
-          effectivePromptSha256: harnessResult.evidence.effectivePromptSha256,
-          nonPromptArgsSha256: harnessResult.evidence.nonPromptArgsSha256,
-          controlledConfigSha256: harnessResult.evidence.controlledConfigSha256,
-          readDeniedPaths: [...harnessResult.evidence.readDeniedPaths],
-          readDeniedPathsSha256: harnessResult.evidence.readDeniedPathsSha256,
-          readDeniedPathCount: harnessResult.evidence.readDeniedPathCount,
-          executionPolicy: harnessResult.evidence.policy
-        } : {}
-      },
-      ...checks ? { checks } : {}
-    };
-    return { worktree, result, cleanup };
-  } catch (err) {
-    try {
-      await cleanup();
-    } catch (cleanupError) {
-      throw new AggregateError(
-        [err, cleanupError],
-        "runWorktreeHarness: run failed and worktree cleanup also failed"
-      );
-    }
-    throw err;
-  }
-}
-function resolveResourceInstructions(profile) {
-  const instructions = profile.resources?.instructions;
-  if (instructions === void 0) return void 0;
-  if (typeof instructions === "string")
-    return instructions.trim().length > 0 ? instructions : void 0;
-  if (instructions.kind === "inline" && typeof instructions.content === "string") {
-    return instructions.content.trim().length > 0 ? instructions.content : void 0;
-  }
-  throw new Error(
-    "runWorktreeHarness: resources.instructions must be a string or inline resource; remote refs require pre-resolution"
-  );
-}
-function profileWithResourceInstructions(profile, resourceInstructions) {
-  let resources;
-  if (profile.resources) {
-    const { instructions: _instructions, ...structuralResources } = profile.resources;
-    resources = structuralResources;
-  }
-  return {
-    ...profile,
-    ...resources ? { resources } : {},
-    ...resourceInstructions === void 0 ? {} : {
-      prompt: {
-        ...profile.prompt,
-        instructions: [...profile.prompt?.instructions ?? [], resourceInstructions]
-      }
-    }
-  };
-}
-function materializationOnlyProfile(profile) {
-  const {
-    prompt: _prompt,
-    model: _model,
-    resources: profileResources,
-    ...structuralProfile
-  } = profile;
-  let resources;
-  if (profileResources) {
-    const { instructions: _instructions, ...fileBackedResources } = profileResources;
-    resources = fileBackedResources;
-  }
-  return {
-    ...structuralProfile,
-    ...resources ? { resources } : {}
-  };
-}
-function assertSupportedWorktreeProfile(profile, harness) {
-  const unsupportedAxes = [
-    hasEntries(profile.tools) ? "tools" : null,
-    hasEntries(profile.permissions) ? "permissions" : null,
-    profile.connections && profile.connections.length > 0 ? "connections" : null,
-    hasEntries(profile.confidential) ? "confidential" : null,
-    hasEntries(profile.modes) ? "modes" : null,
-    hasEntries(profile.extensions) ? "extensions" : null
-  ].filter((axis) => axis !== null);
-  if (profile.model?.reasoningEffort !== void 0 && harness !== "codex") {
-    unsupportedAxes.push("model.reasoningEffort");
-  }
-  for (const [name, server] of Object.entries(profile.mcp ?? {})) {
-    const path2 = `mcp[${JSON.stringify(name)}]`;
-    if (server.enabled === false && harness !== "opencode") {
-      unsupportedAxes.push(`${path2}.enabled`);
-    }
-    if (hasEntries(server.headers) && harness === "codex") {
-      unsupportedAxes.push(`${path2}.headers`);
-    }
-    if (server.cwd !== void 0 && harness === "opencode") {
-      unsupportedAxes.push(`${path2}.cwd`);
-    }
-  }
-  if (harness === "claude") {
-    for (const [event, commands] of Object.entries(profile.hooks ?? {})) {
-      for (const [index, command] of commands.entries()) {
-        const path2 = `hooks[${JSON.stringify(event)}][${index}]`;
-        if (hasEntries(command.env)) unsupportedAxes.push(`${path2}.env`);
-        if (command.blocking !== void 0) unsupportedAxes.push(`${path2}.blocking`);
-      }
-    }
-  }
-  for (const [name, subagent] of Object.entries(profile.subagents ?? {})) {
-    const path2 = `subagents[${JSON.stringify(name)}]`;
-    if (hasEntries(subagent.permissions)) unsupportedAxes.push(`${path2}.permissions`);
-    if (subagent.maxSteps !== void 0) unsupportedAxes.push(`${path2}.maxSteps`);
-    if (hasEntries(subagent.tools) && harness !== "claude") {
-      unsupportedAxes.push(`${path2}.tools`);
-    }
-  }
-  if (unsupportedAxes.length > 0) {
-    throw new Error(
-      `runWorktreeHarness: profile requests unsupported worktree behavior: ${unsupportedAxes.join(", ")}`
-    );
-  }
-}
-function hasEntries(value) {
-  return value !== void 0 && Object.keys(value).length > 0;
-}
-function assertSafeMaterializedPaths(plan) {
-  for (const file of plan.files) {
-    if (file.relPath.split("/").some(isGitMetadataSegment)) {
-      throw new Error(
-        `runWorktreeHarness: profile file cannot target reserved Git metadata: ${file.relPath}`
-      );
-    }
-  }
-}
-function assertSafeProfileResourcePaths(profile) {
-  for (const file of profile.resources?.files ?? []) {
-    if (file.path.split("/").some(isGitMetadataSegment)) {
-      throw new Error(
-        `runWorktreeHarness: profile file cannot target reserved Git metadata: ${file.path}`
-      );
-    }
-  }
-}
-function isGitMetadataSegment(segment) {
-  const windowsCanonical = segment.replace(/[ .]+$/u, "").toLowerCase();
-  return windowsCanonical === ".git" || windowsCanonical.startsWith(".git:");
-}
-function profileMaterializationReceipt(applied, resourceInstructions) {
-  const instructionBytes = resourceInstructions === void 0 ? null : Buffer.from(resourceInstructions, "utf8");
-  return {
-    workspacePlanDigest: applied.workspacePlanDigest,
-    writtenPaths: [...applied.written],
-    unsupported: [...applied.unsupported],
-    environmentNames: Object.keys(applied.env).sort(),
-    flags: [...applied.flags],
-    resourceInstructions: instructionBytes ? {
-      delivery: "invocation-prompt",
-      sha256: `sha256:${createHash("sha256").update(instructionBytes).digest("hex")}`,
-      byteLength: instructionBytes.byteLength
-    } : { delivery: "none", sha256: null, byteLength: 0 }
-  };
-}
-async function runWorktreeChecks(opts) {
-  if (opts.testCmd === void 0 && opts.typecheckCmd === void 0) return void 0;
-  const runCommand = opts.runCommand ?? defaultRunCommand;
-  const run = async (command) => {
-    const res = await 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
 function createWorktreeCliExecutor(options) {
   if (!options.repoRoot) {
     throw new ValidationError("createWorktreeCliExecutor: repoRoot required");
@@ -2404,12 +1203,12 @@ function linkSignals(a, b) {
 }
 
 // src/runtime/supervise/runtime.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { Readable } from "stream";
-import { estimateCost as estimateCost2, isModelPriced as isModelPriced2 } from "@tangle-network/agent-eval";
+import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
 var routerSeamKey = "router";
 var sandboxSeamKey = "sandbox";
 var cliSeamKey = "cli";
@@ -2430,7 +1229,7 @@ function contentRef(prefix, value) {
   }
   return `${prefix}:${(h >>> 0).toString(16).padStart(8, "0")}`;
 }
-function zeroSpend2() {
+function zeroSpend() {
   return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
 }
 var routerInlineExecutor = (spec, ctx) => {
@@ -2624,7 +1423,7 @@ var routerToolsInlineExecutor = (spec, ctx) => {
           }
         }
       }
-      const usd = isModelPriced2(model) ? estimateCost2(tokens.input, tokens.output, model) : 0;
+      const usd = isModelPriced(model) ? estimateCost(tokens.input, tokens.output, model) : 0;
       const spent = { iterations: turns, tokens, usd, ms: Date.now() - started };
       const out = { content: lastText };
       artifact = { outRef: contentRef("router-tools", { model, content: lastText }), out, spent };
@@ -2799,7 +1598,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 = spawn(args.seam.bin, args.seam.args ?? [], {
     ...args.seam.cwd ? { cwd: args.seam.cwd } : {},
     env: { ...process.env, ...args.seam.env ?? {} },
     stdio: ["pipe", "pipe", "pipe"]
@@ -2836,7 +1635,7 @@ async function* streamCliLeaf(args) {
     );
   }
   const out = { content: chunks.join("") };
-  args.onArtifact({ outRef: contentRef("cli", out), out, spent: zeroSpend2() });
+  args.onArtifact({ outRef: contentRef("cli", out), out, spent: zeroSpend() });
   yield { kind: "iteration" };
 }
 function killWithGrace(proc, grace) {
@@ -3224,7 +2023,7 @@ function bridgeWorktreeExecutor(spec, ctx, seam) {
           inner = bridgeExecutor(spec, bridgeCtx);
           for (const msg of pending.splice(0)) inner.deliver?.(msg);
           const run = inner.execute(seam.taskPrompt, linked);
-          if (isAsyncIterable3(run)) {
+          if (isAsyncIterable2(run)) {
             for await (const event of run) yield event;
             bridgeArtifact = inner.resultArtifact();
           } else {
@@ -3317,7 +2116,7 @@ function bridgeOutputText(out) {
     return String(out);
   }
 }
-function isAsyncIterable3(value) {
+function isAsyncIterable2(value) {
   return value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
 }
 var cliWorktreeExecutor = (spec, ctx) => {
@@ -3477,181 +2276,6 @@ function mergeAbortSignals(...signals) {
   return c.signal;
 }
 
-// src/runtime/supervise/driver-executor.ts
-var driverRuntime = "driver";
-var driverRole = "driver";
-function isDriverSpec(spec) {
-  const role = spec.profile.metadata?.role;
-  if (role !== driverRole) return false;
-  const driver = spec.driver;
-  if (!isAgent(driver)) {
-    throw new ValidationError(
-      "driverExecutor: a driver-role spec must carry a `driver` Agent to run inside its nested scope"
-    );
-  }
-  return true;
-}
-var driverExecutorFactory = (spec, ctx) => {
-  if (!isDriverSpec(spec)) {
-    throw new ValidationError(
-      'driverExecutorFactory: spec is not a driver child (no role:"driver" marker)'
-    );
-  }
-  const driver = spec.driver;
-  const journal = spec.journal;
-  const seam = readNestedScopeSeam(ctx);
-  let artifact;
-  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);
-      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 });
-    },
-    resultArtifact() {
-      if (!artifact) {
-        throw new ValidationError("driverExecutor: resultArtifact() read before execute()");
-      }
-      return artifact;
-    }
-  };
-};
-function withDriverExecutor(base) {
-  return {
-    register: base.register.bind(base),
-    resolve(spec) {
-      const role = spec.profile.metadata?.role;
-      if (role === driverRole && !spec.executor) {
-        return { succeeded: true, value: driverExecutorFactory };
-      }
-      return base.resolve(spec);
-    }
-  };
-}
-function nestedTreeKey(seam, journal) {
-  return `${seam.journalRoot}/d${nextNestOrdinal(journal)}`;
-}
-var nestCounters = /* @__PURE__ */ new WeakMap();
-function nextNestOrdinal(journal) {
-  let c = nestCounters.get(journal);
-  if (!c) {
-    c = { n: 0 };
-    nestCounters.set(journal, c);
-  }
-  return c.n++;
-}
-async function 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;
-}
-function isSettled(ev) {
-  return ev.kind === "settled";
-}
-function sumSpend(settled) {
-  const total = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
-  for (const ev of settled) {
-    total.iterations += ev.spent.iterations;
-    total.tokens.input += ev.spent.tokens.input;
-    total.tokens.output += ev.spent.tokens.output;
-    total.usd += ev.spent.usd;
-    if (ev.spent.usdKnown === false) total.usdKnown = false;
-    total.ms += ev.spent.ms;
-  }
-  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;
-    if (ev.spend.usdKnown === false) total.usdKnown = false;
-    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;
-  let bestValidScore;
-  let bestDoneScore;
-  for (const ev of settled) {
-    sawChild = true;
-    if (ev.status !== "done") continue;
-    const score = ev.verdict?.score;
-    if (score !== void 0 && (bestDoneScore === void 0 || score > bestDoneScore)) {
-      bestDoneScore = score;
-    }
-    if (ev.verdict?.valid === true) {
-      anyValid = true;
-      if (score !== void 0 && (bestValidScore === void 0 || score > bestValidScore)) {
-        bestValidScore = score;
-      }
-    }
-  }
-  if (!sawChild) return void 0;
-  return {
-    valid: anyValid,
-    score: anyValid ? bestValidScore ?? 1 : bestDoneScore ?? 0
-  };
-}
-function readNestedScopeSeam(ctx) {
-  const seam = ctx.seams[nestedScopeSeamKey];
-  if (!seam || typeof seam.mount !== "function") {
-    throw new ValidationError(
-      `driverExecutor: missing required seam "${nestedScopeSeamKey}" \u2014 a driver child must be spawned through a Scope that seeds it (the keystone scope does)`
-    );
-  }
-  return seam;
-}
-function isAgent(value) {
-  return typeof value === "object" && value !== null && typeof value.act === "function" && typeof value.name === "string";
-}
-
 // src/runtime/supervise/run-context.ts
 function createInMemoryRunContext(opts = {}) {
   const base = createExecutorRegistry();
@@ -3662,364 +2286,6 @@ function createInMemoryRunContext(opts = {}) {
   };
 }
 
-// src/runtime/supervise/budget.ts
-function spendFromUsageEvents(events) {
-  const tokens = zeroTokenUsage();
-  let usd = 0;
-  let iterations = 0;
-  for (const ev of events) {
-    if (ev.kind === "tokens") {
-      addTokenUsage(tokens, { input: ev.input, output: ev.output });
-    } else if (ev.kind === "cost") {
-      usd += ev.usd;
-    } else {
-      iterations += 1;
-    }
-  }
-  return { iterations, tokens, usd, ms: 0 };
-}
-async function foldUsage(events) {
-  if (Array.isArray(events)) return spendFromUsageEvents(events);
-  const tokens = zeroTokenUsage();
-  let usd = 0;
-  let iterations = 0;
-  for await (const ev of events) {
-    if (ev.kind === "tokens") {
-      addTokenUsage(tokens, { input: ev.input, output: ev.output });
-    } else if (ev.kind === "cost") {
-      usd += ev.usd;
-    } else {
-      iterations += 1;
-    }
-  }
-  return { iterations, tokens, usd, ms: 0 };
-}
-function totalTokens(usage) {
-  return usage.input + usage.output;
-}
-function createBudgetPool(root, now = Date.now) {
-  let freeTokens = root.maxTokens;
-  let reservedTokens = 0;
-  let committedTokens = 0;
-  const usdCapped = root.maxUsd !== void 0;
-  let freeUsd = root.maxUsd ?? 0;
-  let reservedUsd = 0;
-  let committedUsd = 0;
-  let freeIterations = root.maxIterations;
-  let reservedIterations = 0;
-  let committedIterations = 0;
-  const absoluteDeadlineMs = root.deadlineMs !== void 0 ? now() + root.deadlineMs : 0;
-  let nextTicketId = 0;
-  const open = /* @__PURE__ */ new Set();
-  function reserve(b) {
-    const wantTokens = b.maxTokens;
-    const wantUsd = b.maxUsd ?? 0;
-    const wantIterations = b.maxIterations;
-    if (wantTokens > freeTokens) return { ok: false, reason: "budget-exhausted" };
-    if (wantIterations > freeIterations) return { ok: false, reason: "budget-exhausted" };
-    if (wantUsd > 0 && (!usdCapped || wantUsd > freeUsd)) {
-      return { ok: false, reason: "budget-exhausted" };
-    }
-    freeTokens -= wantTokens;
-    reservedTokens += wantTokens;
-    freeIterations -= wantIterations;
-    reservedIterations += wantIterations;
-    if (wantUsd > 0) {
-      freeUsd -= wantUsd;
-      reservedUsd += wantUsd;
-    }
-    const id = nextTicketId++;
-    open.add(id);
-    return {
-      ok: true,
-      ticket: { id, reserved: { tokens: wantTokens, usd: wantUsd, iterations: wantIterations } }
-    };
-  }
-  function reconcile(ticket, spent) {
-    if (!open.has(ticket.id)) {
-      throw new Error(`budget pool: reconcile of unknown or already-settled ticket ${ticket.id}`);
-    }
-    open.delete(ticket.id);
-    const { tokens: rTokens, usd: rUsd, iterations: rIterations } = ticket.reserved;
-    if (usdCapped && spent.usdKnown === false) {
-      throw new Error(
-        `budget pool: ticket ${ticket.id} reported unknown dollar cost under a dollar-capped budget`
-      );
-    }
-    const spentTokens = totalTokens(spent.tokens);
-    if (spentTokens > rTokens) {
-      throw new Error(
-        `budget pool: ticket ${ticket.id} spent ${spentTokens} tokens > reserved ${rTokens}`
-      );
-    }
-    if (spent.iterations > rIterations) {
-      throw new Error(
-        `budget pool: ticket ${ticket.id} spent ${spent.iterations} iterations > reserved ${rIterations}`
-      );
-    }
-    if (usdCapped && spent.usd > rUsd) {
-      throw new Error(`budget pool: ticket ${ticket.id} spent $${spent.usd} > reserved $${rUsd}`);
-    }
-    reservedTokens -= rTokens;
-    committedTokens += spentTokens;
-    freeTokens += rTokens - spentTokens;
-    reservedIterations -= rIterations;
-    committedIterations += spent.iterations;
-    freeIterations += rIterations - spent.iterations;
-    if (usdCapped && rUsd > 0) {
-      reservedUsd -= rUsd;
-      committedUsd += spent.usd;
-      freeUsd += rUsd - spent.usd;
-    } else {
-      committedUsd += spent.usd;
-    }
-  }
-  function observe(spend) {
-    if (usdCapped && spend.usdKnown === false) {
-      throw new Error(
-        "budget pool: cannot observe unknown dollar cost under a dollar-capped budget"
-      );
-    }
-    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
-    };
-  }
-  function assertNoOpenTickets() {
-    if (open.size > 0) {
-      throw new Error(
-        `budget pool: ${open.size} reservation(s) still open at join barrier (leaked ticket ids: ${[...open].join(", ")}) \u2014 conserved-pool invariant violated`
-      );
-    }
-  }
-  return {
-    reserve,
-    reconcile,
-    spendFrom: foldUsage,
-    readout,
-    observe,
-    assertNoOpenTickets
-  };
-}
-
-// src/runtime/supervise/supervisor.ts
-var defaultMaxDepth = 4;
-function createSupervisor() {
-  let attached;
-  async function run(root, task, opts) {
-    const now = opts.now ?? Date.now;
-    const pool = createBudgetPool(opts.budget, now);
-    await opts.journal.beginTree(opts.runId, new Date(now()).toISOString());
-    await opts.journal.appendEvent(opts.runId, {
-      kind: "spawned",
-      id: opts.runId,
-      label: "root",
-      budget: opts.budget,
-      runtime: "inline",
-      seq: 0,
-      at: new Date(now()).toISOString()
-    });
-    const controller = new AbortController();
-    const cascadeAbort = (reason) => {
-      if (controller.signal.aborted) return;
-      controller.abort(reason);
-    };
-    const onCallerAbort = () => cascadeAbort("caller signal aborted");
-    if (opts.signal) {
-      if (opts.signal.aborted) cascadeAbort("caller signal aborted");
-      else opts.signal.addEventListener("abort", onCallerAbort, { once: true });
-    }
-    const breaker = createIntensityBreaker(opts, () => cascadeAbort("intensity breaker tripped"));
-    const journal = wrapJournalForBreaker(opts.journal, breaker);
-    const scope = createScope({
-      parentId: opts.runId,
-      root: opts.runId,
-      pool,
-      journal,
-      blobs: opts.blobs,
-      executors: opts.executors,
-      seams: {},
-      depth: 0,
-      maxDepth: opts.maxDepth ?? defaultMaxDepth,
-      signal: controller.signal,
-      now,
-      hooks: opts.hooks
-    });
-    const openScope = scope;
-    if (attached) {
-      attached.bind({ scope: openScope, cascadeAbort, signal: pushRootSignal(cascadeAbort) });
-    }
-    let actOutcome;
-    try {
-      const out = await root.act(task, scope);
-      actOutcome = { ok: true, out };
-    } catch (error) {
-      actOutcome = { ok: false, error };
-    } finally {
-      await drainLiveChildren(openScope, controller);
-      if (opts.signal) opts.signal.removeEventListener("abort", onCallerAbort);
-      if (attached) attached.unbind();
-    }
-    const tree = scope.view;
-    if (actOutcome.ok) {
-      pool.assertNoOpenTickets();
-      const out = actOutcome.out;
-      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: addSpend(childWork, driverInference),
-          ...isNonEmptySpend(driverInference) ? { spentBreakdown: { driverInference, childWork } } : {}
-        };
-      }
-      return noWinner();
-    }
-    return noWinner();
-    async function noWinner() {
-      const { childWork, driverInference } = await spentFromJournal(journal, opts.runId);
-      return {
-        kind: "no-winner",
-        reason: classifyNoWinner(controller, pool, opts, breaker),
-        tree,
-        downCount: breaker.downCount(),
-        spentTotal: addSpend(childWork, driverInference)
-      };
-    }
-  }
-  function attach(h) {
-    const control = rootControls.get(h);
-    if (!control) {
-      throw new RuntimeRunStateError(
-        "supervisor.attach: handle was not minted by createRootHandle (no control channel)"
-      );
-    }
-    attached = control;
-  }
-  return { run, attach };
-}
-var rootControls = /* @__PURE__ */ new WeakMap();
-function pushRootSignal(cascadeAbort) {
-  return (msg) => {
-    if (msg.kind === "cancel") cascadeAbort(msg.reason ?? "root signal: cancel");
-  };
-}
-function createIntensityBreaker(opts, trip) {
-  const max = opts.maxRestarts;
-  const within = opts.withinMs;
-  const armed = max !== void 0 && within !== void 0;
-  const recent = [];
-  let total = 0;
-  let isTripped = false;
-  return {
-    recordDown(at) {
-      total += 1;
-      if (!armed || isTripped) return;
-      recent.push(at);
-      const cutoff = at - within;
-      while (recent.length > 0 && recent[0] < cutoff) recent.shift();
-      if (recent.length > max) {
-        isTripped = true;
-        trip();
-      }
-    },
-    tripped() {
-      return isTripped;
-    },
-    downCount() {
-      return total;
-    }
-  };
-}
-function wrapJournalForBreaker(journal, breaker) {
-  return {
-    loadTree: (root) => journal.loadTree(root),
-    beginTree: (root, at) => journal.beginTree(root, at),
-    appendEvent: (root, ev) => {
-      if (ev.kind === "settled" && ev.status === "down") breaker.recordDown(Date.parse(ev.at));
-      return journal.appendEvent(root, ev);
-    }
-  };
-}
-async function drainLiveChildren(scope, controller) {
-  const hasLive = scope.view.inFlight > 0;
-  if (!hasLive) return;
-  if (!controller.signal.aborted) controller.abort();
-  await Promise.allSettled([drainCursor(scope)]);
-}
-async function drainCursor(scope) {
-  for (; ; ) {
-    const settled = await scope.next();
-    if (settled === null) return;
-  }
-}
-function classifyNoWinner(controller, pool, opts, breaker) {
-  if (breaker.tripped()) return "all-children-down";
-  if (controller.signal.aborted) return "aborted";
-  if (poolExhausted(pool, opts)) return "budget-exhausted";
-  return "all-children-down";
-}
-function poolExhausted(pool, opts) {
-  const r = pool.readout();
-  if (r.tokensLeft <= 0) return true;
-  if (opts.budget.maxUsd !== void 0 && r.usdLeft <= 0) return true;
-  if (opts.budget.deadlineMs !== void 0 && r.deadlineMs > 0 && (opts.now ?? Date.now)() >= r.deadlineMs) {
-    return true;
-  }
-  return false;
-}
-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 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") accumulate(childWork, ev.spent);
-    else if (ev.kind === "metered") accumulate(driverInference, ev.spend);
-  }
-  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;
-  if (b.usdKnown === false) a.usdKnown = false;
-  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,
-    ...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
-    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/supervise/event-bus.ts
 function createEventBus(now = Date.now) {
   const queue = [];
@@ -4676,7 +2942,7 @@ ${narrative}` : roster;
             return `${roster}
 
 ## Progress notes
-Summary unavailable: ${errMessage2(e)}`;
+Summary unavailable: ${errMessage(e)}`;
           }
         }),
         ...opts.compaction.onCompact ? { onCompact: opts.compaction.onCompact } : {},
@@ -4747,7 +3013,7 @@ function safeJson(v) {
     return String(v);
   }
 }
-function errMessage2(e) {
+function errMessage(e) {
   return e instanceof Error ? e.message : String(e);
 }
 
@@ -6748,21 +5014,6 @@ async function delegate(intent, opts = {}) {
 
 export {
   gateOnDeliverable,
-  defineRuntimeHooks,
-  composeRuntimeHooks,
-  notifyRuntimeHookEvent,
-  notifyRuntimeDecisionPoint,
-  createScope,
-  settledToIteration,
-  withDriverExecutor,
-  createWorktree,
-  captureWorktreeDiff,
-  removeWorktree,
-  runWorktreeHarness,
-  routerChatWithUsage,
-  routerChatWithTools,
-  routerToolLoop,
-  routerBrain,
   acquireSandbox,
   probeSandboxCapabilities,
   createSandboxLineage,
@@ -6775,9 +5026,6 @@ export {
   createExecutor,
   createExecutorRegistry,
   createInMemoryRunContext,
-  spendFromUsageEvents,
-  createBudgetPool,
-  createSupervisor,
   createEventBus,
   createCoordinationTools,
   driverAgent,
@@ -6836,4 +5084,4 @@ export {
   workerFromBackend,
   supervise
 };
-//# sourceMappingURL=chunk-KVJQV342.js.map
+//# sourceMappingURL=chunk-6MR4IJRW.js.map