@tangle-network/agent-runtime 0.91.0 → 0.92.1

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

@@ -2,23 +2,37 @@ import {
   UI_LENSES
 } from "./chunk-DPEUKJRO.js";
 import {
-  buildLoopSpanNodes
-} from "./chunk-IVGYLCFH.js";
+  assertModelAllowed,
+  buildLoopSpanNodes,
+  createSupervisor,
+  notifyRuntimeHookEvent,
+  routerBrain,
+  routerChatWithUsage,
+  runBrainLoop,
+  withDriverExecutor
+} from "./chunk-J2K6WIG6.js";
+import {
+  InMemoryResultBlobStore,
+  InMemorySpawnJournal,
+  contentAddress
+} from "./chunk-3D2RHC4K.js";
+import {
+  providerAsExecutor,
+  resolveAgentEnvironmentProvider
+} from "./chunk-VSWBYWFK.js";
 import {
   addTokenUsage,
   deleteBoxSafe,
   mapWithConcurrency,
-  providerAsExecutor,
   randomSuffix,
   randomUuid,
-  resolveAgentEnvironmentProvider,
   sleep,
   stringifySafe,
   throwAbort,
   throwIfAborted,
   withTimeout,
   zeroTokenUsage
-} from "./chunk-BZF3KQ6G.js";
+} from "./chunk-3MDZX7YU.js";
 import {
   extractLlmCallEvent
 } from "./chunk-FVJ7M3DA.js";
@@ -30,1213 +44,9 @@ import {
   AgentEvalError,
   ConfigError,
   NotFoundError,
-  RuntimeRunStateError,
   ValidationError
 } from "./chunk-YEJR7IXO.js";
 
-// src/durable/spawn-journal.ts
-import { createHash } from "crypto";
-function contentAddress(artifact) {
-  const hex = createHash("sha256").update(stableStringify(artifact), "utf-8").digest("hex");
-  return `sha256:${hex}`;
-}
-function stableStringify(value) {
-  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
-  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
-}
-var InMemoryResultBlobStore = class {
-  blobs = /* @__PURE__ */ new Map();
-  async put(outRef, artifact) {
-    assertContentAddress(outRef, artifact);
-    this.blobs.set(outRef, artifact);
-  }
-  async get(outRef) {
-    return this.blobs.has(outRef) ? this.blobs.get(outRef) : void 0;
-  }
-};
-function assertContentAddress(outRef, artifact) {
-  const expected = contentAddress(artifact);
-  if (outRef !== expected) {
-    throw new Error(
-      `blob outRef '${outRef}' does not match the artifact content hash '${expected}'; a content-addressed store refuses a mismatched ref (breaks the replay invariant)`
-    );
-  }
-}
-var InMemorySpawnJournal = class {
-  trees = /* @__PURE__ */ new Map();
-  async loadTree(root) {
-    const tree = this.trees.get(root);
-    if (!tree) return void 0;
-    return tree.events.map((ev) => ({ ...ev }));
-  }
-  async beginTree(root, at) {
-    const existing = this.trees.get(root);
-    if (existing) {
-      if (existing.begunAt !== at) {
-        throw new Error(
-          `spawn tree '${root}' already begun at ${existing.begunAt}; refusing to overwrite with ${at}`
-        );
-      }
-      return;
-    }
-    this.trees.set(root, { begunAt: at, events: [] });
-  }
-  async appendEvent(root, ev) {
-    const tree = this.trees.get(root);
-    if (!tree) {
-      throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`);
-    }
-    assertSeqUnique(root, tree.events, ev);
-    tree.events.push({ ...ev });
-  }
-};
-function assertSeqUnique(root, events, ev) {
-  if (ev.kind === "spawned" || ev.kind === "metered") return;
-  if (events.some((e) => e.kind !== "spawned" && e.kind !== "metered" && e.seq === ev.seq)) {
-    throw new Error(
-      `spawn journal corrupted: duplicate cursor seq ${ev.seq} in tree '${root}'; the cursor order replay relies on is not unique`
-    );
-  }
-}
-
-// src/runtime/supervise/model-policy.ts
-function assertModelAllowed(model, allowed) {
-  if (!allowed || model === void 0) return;
-  if (!allowed.includes(model)) {
-    throw new ConfigError(
-      `model ${JSON.stringify(model)} is not in the allowed set ${JSON.stringify([...allowed])}`
-    );
-  }
-}
-
-// src/runtime/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-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 (isAsyncIterable(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 isAsyncIterable(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/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/completion-gate.ts
 function gateOnDeliverable(inner, deliverable) {
   let gated;
@@ -1255,7 +65,7 @@ function gateOnDeliverable(inner, deliverable) {
     ...inner.deliver ? { deliver: (m) => inner.deliver?.(m) } : {},
     execute(task, signal) {
       const r = inner.execute(task, signal);
-      if (isAsyncIterable2(r)) {
+      if (isAsyncIterable(r)) {
         return (async function* () {
           for await (const ev of r) yield ev;
           const art = inner.resultArtifact();
@@ -1275,7 +85,7 @@ function gateOnDeliverable(inner, deliverable) {
     }
   };
 }
-function isAsyncIterable2(v) {
+function isAsyncIterable(v) {
   return v != null && typeof v[Symbol.asyncIterator] === "function";
 }
 
@@ -2055,13 +865,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;
@@ -2575,7 +1385,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 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";
@@ -2596,7 +1406,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) => {
@@ -2790,7 +1600,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 };
@@ -3002,7 +1812,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) {
@@ -3390,7 +2200,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 {
@@ -3483,7 +2293,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) => {
@@ -3641,179 +2451,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;
-    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();
@@ -4480,7 +3117,7 @@ ${narrative}` : roster;
             return `${roster}
 
 ## Progress notes
-Summary unavailable: ${errMessage2(e)}`;
+Summary unavailable: ${errMessage(e)}`;
           }
         }),
         ...opts.compaction.onCompact ? { onCompact: opts.compaction.onCompact } : {},
@@ -4551,7 +3188,7 @@ function safeJson(v) {
     return String(v);
   }
 }
-function errMessage2(e) {
+function errMessage(e) {
   return e instanceof Error ? e.message : String(e);
 }
 
@@ -6551,24 +5188,6 @@ async function delegate(intent, opts = {}) {
 }
 
 export {
-  contentAddress,
-  InMemoryResultBlobStore,
-  InMemorySpawnJournal,
-  assertModelAllowed,
-  routerChatWithUsage,
-  routerChatWithTools,
-  routerToolLoop,
-  routerBrain,
-  defineRuntimeHooks,
-  composeRuntimeHooks,
-  notifyRuntimeHookEvent,
-  notifyRuntimeDecisionPoint,
-  createScope,
-  settledToIteration,
-  withDriverExecutor,
-  spendFromUsageEvents,
-  createBudgetPool,
-  createSupervisor,
   gateOnDeliverable,
   createWorktree,
   captureWorktreeDiff,
@@ -6644,4 +5263,4 @@ export {
   workerFromBackend,
   supervise
 };
-//# sourceMappingURL=chunk-NC66AM3S.js.map
+//# sourceMappingURL=chunk-UO2L5VTP.js.map