@tangle-network/agent-runtime 0.93.1 → 0.94.0

package/dist/{chunk-UO2L5VTP.js → chunk-FHZHADIM.js}

@@ -3,14 +3,8 @@ import {
 } from "./chunk-DPEUKJRO.js";
 import {
   assertModelAllowed,
-  buildLoopSpanNodes,
-  createSupervisor,
-  notifyRuntimeHookEvent,
-  routerBrain,
-  routerChatWithUsage,
-  runBrainLoop,
-  withDriverExecutor
-} from "./chunk-J2K6WIG6.js";
+  buildLoopSpanNodes
+} from "./chunk-ISTDY47H.js";
 import {
   InMemoryResultBlobStore,
   InMemorySpawnJournal,
@@ -39,11 +33,12 @@ import {
 import {
   harnessInvocation,
   runLocalHarness
-} from "./chunk-CMYMTRGA.js";
+} from "./chunk-PX6SXX3M.js";
 import {
   AgentEvalError,
   ConfigError,
   NotFoundError,
+  RuntimeRunStateError,
   ValidationError
 } from "./chunk-YEJR7IXO.js";
 
@@ -89,6 +84,576 @@ 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),
+    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";
 async function runGitAsync(args, cwd, runner) {
@@ -175,6 +740,216 @@ async function removeWorktree(options) {
   ).catch(() => void 0);
 }
 
+// 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"]);
@@ -865,13 +1640,13 @@ async function executeIteration(args) {
       await destroySandboxSafe(box, args.ctx.traceEmitter, args.runId, args.now);
     }
   }
-  if (isAbortError(slot.error) || args.signal.aborted) {
+  if (isAbortError2(slot.error) || args.signal.aborted) {
     if (slot.error) throw slot.error;
     throwAbort();
   }
   if (slot.error instanceof ValidationError) throw slot.error;
 }
-function isAbortError(err) {
+function isAbortError2(err) {
   return err instanceof Error && err.name === "AbortError";
 }
 var TEARDOWN_TIMEOUT_MS2 = 15e3;
@@ -1385,7 +2160,7 @@ import { randomUUID as randomUUID2 } from "crypto";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { Readable } from "stream";
-import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
+import { estimateCost as estimateCost2, isModelPriced as isModelPriced2 } from "@tangle-network/agent-eval";
 var routerSeamKey = "router";
 var sandboxSeamKey = "sandbox";
 var cliSeamKey = "cli";
@@ -1406,7 +2181,7 @@ function contentRef(prefix, value) {
   }
   return `${prefix}:${(h >>> 0).toString(16).padStart(8, "0")}`;
 }
-function zeroSpend() {
+function zeroSpend2() {
   return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
 }
 var routerInlineExecutor = (spec, ctx) => {
@@ -1600,7 +2375,7 @@ var routerToolsInlineExecutor = (spec, ctx) => {
           }
         }
       }
-      const usd = isModelPriced(model) ? estimateCost(tokens.input, tokens.output, model) : 0;
+      const usd = isModelPriced2(model) ? estimateCost2(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 };
@@ -1812,7 +2587,7 @@ async function* streamCliLeaf(args) {
     );
   }
   const out = { content: chunks.join("") };
-  args.onArtifact({ outRef: contentRef("cli", out), out, spent: zeroSpend() });
+  args.onArtifact({ outRef: contentRef("cli", out), out, spent: zeroSpend2() });
   yield { kind: "iteration" };
 }
 function killWithGrace(proc, grace) {
@@ -2200,7 +2975,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 (isAsyncIterable2(run)) {
+          if (isAsyncIterable3(run)) {
             for await (const event of run) yield event;
             bridgeArtifact = inner.resultArtifact();
           } else {
@@ -2293,7 +3068,7 @@ function bridgeOutputText(out) {
     return String(out);
   }
 }
-function isAsyncIterable2(value) {
+function isAsyncIterable3(value) {
   return value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
 }
 var cliWorktreeExecutor = (spec, ctx) => {
@@ -2451,6 +3226,179 @@ 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;
+    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;
+    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();
@@ -2461,6 +3409,352 @@ 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;
+    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) {
+    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;
+  a.ms += b.ms;
+}
+function addSpend(a, b) {
+  return {
+    iterations: a.iterations + b.iterations,
+    tokens: { input: a.tokens.input + b.tokens.input, output: a.tokens.output + b.tokens.output },
+    usd: a.usd + b.usd,
+    ms: a.ms + b.ms
+  };
+}
+function isNonEmptySpend(s) {
+  return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0;
+}
+
 // src/runtime/supervise/event-bus.ts
 function createEventBus(now = Date.now) {
   const queue = [];
@@ -3117,7 +4411,7 @@ ${narrative}` : roster;
             return `${roster}
 
 ## Progress notes
-Summary unavailable: ${errMessage(e)}`;
+Summary unavailable: ${errMessage2(e)}`;
           }
         }),
         ...opts.compaction.onCompact ? { onCompact: opts.compaction.onCompact } : {},
@@ -3188,7 +4482,7 @@ function safeJson(v) {
     return String(v);
   }
 }
-function errMessage(e) {
+function errMessage2(e) {
   return e instanceof Error ? e.message : String(e);
 }
 
@@ -5189,10 +6483,21 @@ 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,
@@ -5205,6 +6510,9 @@ export {
   createExecutor,
   createExecutorRegistry,
   createInMemoryRunContext,
+  spendFromUsageEvents,
+  createBudgetPool,
+  createSupervisor,
   createEventBus,
   createCoordinationTools,
   driverAgent,
@@ -5263,4 +6571,4 @@ export {
   workerFromBackend,
   supervise
 };
-//# sourceMappingURL=chunk-UO2L5VTP.js.map
+//# sourceMappingURL=chunk-FHZHADIM.js.map