@tangle-network/agent-runtime 0.90.0 → 0.91.0

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

@@ -3,7 +3,7 @@ import {
 } from "./chunk-DPEUKJRO.js";
 import {
   buildLoopSpanNodes
-} from "./chunk-UD4BHQMI.js";
+} from "./chunk-IVGYLCFH.js";
 import {
   addTokenUsage,
   deleteBoxSafe,
@@ -25,7 +25,7 @@ import {
 import {
   harnessInvocation,
   runLocalHarness
-} from "./chunk-7LO5GMAO.js";
+} from "./chunk-CMYMTRGA.js";
 import {
   AgentEvalError,
   ConfigError,
@@ -34,58 +34,6 @@ import {
   ValidationError
 } from "./chunk-YEJR7IXO.js";
 
-// src/runtime/supervise/model-policy.ts
-function assertModelAllowed(model, allowed) {
-  if (!allowed || model === void 0) return;
-  if (!allowed.includes(model)) {
-    throw new ConfigError(
-      `model ${JSON.stringify(model)} is not in the allowed set ${JSON.stringify([...allowed])}`
-    );
-  }
-}
-
-// src/runtime/supervise/completion-gate.ts
-function gateOnDeliverable(inner, deliverable) {
-  let gated;
-  const check = async (out, baseScore) => {
-    let delivered;
-    try {
-      delivered = await deliverable.check(out) === true;
-    } catch {
-      delivered = false;
-    }
-    return { valid: delivered, score: baseScore ?? (delivered ? 1 : 0) };
-  };
-  return {
-    runtime: inner.runtime,
-    ...inner.budgetExempt !== void 0 ? { budgetExempt: inner.budgetExempt } : {},
-    ...inner.deliver ? { deliver: (m) => inner.deliver?.(m) } : {},
-    execute(task, signal) {
-      const r = inner.execute(task, signal);
-      if (isAsyncIterable(r)) {
-        return (async function* () {
-          for await (const ev of r) yield ev;
-          const art = inner.resultArtifact();
-          gated = await check(art.out, art.verdict?.score);
-        })();
-      }
-      return (async () => {
-        const res = await r;
-        gated = await check(res.out, res.verdict?.score);
-        return { ...res, verdict: gated };
-      })();
-    },
-    teardown: (grace) => inner.teardown(grace),
-    resultArtifact() {
-      const art = inner.resultArtifact();
-      return { ...art, verdict: gated ?? art.verdict };
-    }
-  };
-}
-function isAsyncIterable(v) {
-  return v != null && typeof v[Symbol.asyncIterator] === "function";
-}
-
 // src/durable/spawn-journal.ts
 import { createHash } from "crypto";
 function contentAddress(artifact) {
@@ -153,574 +101,1182 @@ function assertSeqUnique(root, events, ev) {
   }
 }
 
-// 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
-    });
+// 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])}`
+    );
   }
 }
-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
-    });
+
+// 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 notifyRuntimeHookError(hooks, error, context) {
+function safeJsonLength(value) {
+  if (value === void 0 || value === null) return 0;
   try {
-    const result = hooks?.onHookError?.(error, context);
-    if (isThenable(result)) void result.catch(() => void 0);
+    return JSON.stringify(value)?.length ?? 0;
   } catch {
+    return String(value).length;
   }
 }
-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 } : {}
-      });
-    }
-  };
+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;
 }
-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" };
+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);
     }
-    const spec = agent.executorSpec;
-    if (!isAgentSpec(spec)) {
-      throw new ValidationError(
-        `scope.spawn: agent "${agent.name}" exposes no \`executorSpec\` (AgentSpec) to resolve a Executor`
-      );
+    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 };
     }
-    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;
+    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 });
     }
   }
-  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 { 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));
       }
-      return finalizeSettlement(chosen, settlement, seq, args, now);
+      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;
     }
   }
-  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 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 send(nodeId, msg) {
-    const child = children.get(nodeId);
-    if (!child || child.delivered || !child.deliver) return false;
-    child.deliver(msg);
-    return true;
+  function readout() {
+    return {
+      tokensLeft: freeTokens,
+      usdLeft: usdCapped ? freeUsd : 0,
+      usdCapped,
+      deadlineMs: absoluteDeadlineMs,
+      reservedTokens
+    };
   }
-  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 }
-    );
+  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 {
-    spawn: spawn4,
-    next,
-    nextResolved,
-    send,
-    signal: args.signal,
-    meter,
-    get view() {
-      return makeTreeView(args.parentId, children);
-    },
-    get budget() {
-      return args.pool.readout();
-    }
+    reserve,
+    reconcile,
+    spendFrom: foldUsage,
+    readout,
+    observe,
+    assertNoOpenTickets
   };
 }
-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,
+
+// 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()
     });
-    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
+    const controller = new AbortController();
+    const cascadeAbort = (reason) => {
+      if (controller.signal.aborted) return;
+      controller.abort(reason);
     };
-  }
-  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()
+    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
     });
-  }
-  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);
+    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();
     }
-    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 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)
+      };
     }
-    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`
-    );
+  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 {
-    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 }
+  return { run, attach };
+}
+var rootControls = /* @__PURE__ */ new WeakMap();
+function pushRootSignal(cascadeAbort) {
+  return (msg) => {
+    if (msg.kind === "cancel") cascadeAbort(msg.reason ?? "root signal: cancel");
   };
 }
-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 } : {}
-  }));
+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 {
-    root,
-    nodes,
-    inFlight: nodes.filter((n) => n.status === "running" || n.status === "acquiring").length
+    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 frozenHandle(child) {
+function wrapJournalForBreaker(journal, breaker) {
   return {
-    id: child.id,
-    label: child.label,
-    status: child.status,
-    abort() {
+    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 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;
-    }
+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;
   }
-  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;
+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: 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
+    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;
+  const check = async (out, baseScore) => {
+    let delivered;
+    try {
+      delivered = await deliverable.check(out) === true;
+    } catch {
+      delivered = false;
+    }
+    return { valid: delivered, score: baseScore ?? (delivered ? 1 : 0) };
+  };
+  return {
+    runtime: inner.runtime,
+    ...inner.budgetExempt !== void 0 ? { budgetExempt: inner.budgetExempt } : {},
+    ...inner.deliver ? { deliver: (m) => inner.deliver?.(m) } : {},
+    execute(task, signal) {
+      const r = inner.execute(task, signal);
+      if (isAsyncIterable2(r)) {
+        return (async function* () {
+          for await (const ev of r) yield ev;
+          const art = inner.resultArtifact();
+          gated = await check(art.out, art.verdict?.score);
+        })();
+      }
+      return (async () => {
+        const res = await r;
+        gated = await check(res.out, res.verdict?.score);
+        return { ...res, verdict: gated };
+      })();
+    },
+    teardown: (grace) => inner.teardown(grace),
+    resultArtifact() {
+      const art = inner.resultArtifact();
+      return { ...art, verdict: gated ?? art.verdict };
+    }
   };
 }
-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);
+function isAsyncIterable2(v) {
+  return v != null && typeof v[Symbol.asyncIterator] === "function";
 }
 
 // src/mcp/worktree.ts
@@ -790,231 +1346,23 @@ function parseShortstat(text) {
   return out;
 }
 async function removeWorktree(options) {
-  const force = options.force ?? true;
-  const args = ["worktree", "remove"];
-  if (force) args.push("--force");
-  args.push(options.worktree.path);
-  const result = await runGitAsync(args, options.repoRoot, options.runGit);
-  if (result.exitCode !== 0 && !/not a working tree/.test(result.stderr)) {
-    await runGitAsync(
-      ["branch", "-D", options.worktree.branch],
-      options.repoRoot,
-      options.runGit
-    ).catch(() => void 0);
-  }
-  await runGitAsync(
-    ["branch", "-D", options.worktree.branch],
-    options.repoRoot,
-    options.runGit
-  ).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)
-      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" });
+  const force = options.force ?? true;
+  const args = ["worktree", "remove"];
+  if (force) args.push("--force");
+  args.push(options.worktree.path);
+  const result = await runGitAsync(args, options.repoRoot, options.runGit);
+  if (result.exitCode !== 0 && !/not a working tree/.test(result.stderr)) {
+    await runGitAsync(
+      ["branch", "-D", options.worktree.branch],
+      options.repoRoot,
+      options.runGit
+    ).catch(() => void 0);
+  }
+  await runGitAsync(
+    ["branch", "-D", options.worktree.branch],
+    options.repoRoot,
+    options.runGit
+  ).catch(() => void 0);
 }
 
 // src/runtime/sandbox-acquire.ts
@@ -2044,7 +2392,11 @@ async function runWorktreeHarness(opts) {
     ...opts.runGit ? { runGit: opts.runGit } : {}
   }).catch(() => void 0);
   try {
-    const { command, args } = harnessInvocation(opts.harness, opts.profile, opts.taskPrompt);
+    const { command, args } = harnessInvocation(opts.harness, opts.profile, opts.taskPrompt, {
+      // This helper created the candidate worktree above; autonomous Claude
+      // edits are permitted only inside that isolated checkout.
+      dangerouslySkipPermissions: opts.harness === "claude"
+    });
     const harnessResult = await runHarness({
       harness: opts.harness,
       cwd: worktree.path,
@@ -3099,723 +3451,377 @@ function bridgeWorktreeExecutor(spec, ctx, seam) {
       } finally {
         await cleanupWorktree();
       }
-      return { destroyed };
-    },
-    resultArtifact() {
-      if (!artifact) {
-        throw new ValidationError(
-          "cliWorktreeExecutor: bridge resultArtifact() read before stream drained"
-        );
-      }
-      return artifact;
-    }
-  };
-}
-function resolveBridgeWorktreeModel(spec, bridge) {
-  if (bridge.model) return bridge.model;
-  const model = spec.profile.model?.default;
-  if (typeof model === "string" && model.length > 0) return model;
-  throw new ValidationError(
-    "cliWorktreeExecutor: bridge.model or AgentProfile.model.default required"
-  );
-}
-function bridgeOutputText(out) {
-  if (typeof out === "string") return out;
-  if (out && typeof out === "object") {
-    const content = out.content;
-    if (typeof content === "string") return content;
-  }
-  try {
-    return JSON.stringify(out) ?? String(out);
-  } catch {
-    return String(out);
-  }
-}
-function isAsyncIterable3(value) {
-  return value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
-}
-var cliWorktreeExecutor = (spec, ctx) => {
-  const seam = readSeam(ctx, cliWorktreeSeamKey, "cli-worktree");
-  if (!seam.repoRoot || !seam.taskPrompt) {
-    throw new ValidationError("cliWorktreeExecutor: CliWorktreeSeam.repoRoot + taskPrompt required");
-  }
-  if (seam.bridge) return bridgeWorktreeExecutor(spec, ctx, seam);
-  if (!seam.harness) {
-    throw new ValidationError(
-      "cliWorktreeExecutor: CliWorktreeSeam.harness required when bridge is not set"
-    );
-  }
-  return createWorktreeCliExecutor({
-    repoRoot: seam.repoRoot,
-    profile: spec.profile,
-    harness: seam.harness,
-    taskPrompt: seam.taskPrompt,
-    ...seam.runId ? { runId: seam.runId } : {},
-    ...seam.baseRef ? { baseRef: seam.baseRef } : {},
-    ...seam.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: seam.harnessTimeoutMs } : {},
-    ...seam.testCmd !== void 0 ? { testCmd: seam.testCmd } : {},
-    ...seam.typecheckCmd !== void 0 ? { typecheckCmd: seam.typecheckCmd } : {},
-    ...seam.checkTimeoutMs !== void 0 ? { checkTimeoutMs: seam.checkTimeoutMs } : {},
-    ...seam.checkOutputCap !== void 0 ? { checkOutputCap: seam.checkOutputCap } : {},
-    ...seam.runGit ? { runGit: seam.runGit } : {},
-    ...seam.runCommand ? { runCommand: seam.runCommand } : {},
-    ...seam.budgetExempt !== void 0 ? { budgetExempt: seam.budgetExempt } : {}
-  });
-};
-function createExecutor(config) {
-  return (spec, ctx) => {
-    const { backend, ...seam } = config;
-    const seamed = { ...ctx, seams: { ...ctx.seams, [backend]: seam } };
-    switch (config.backend) {
-      case "router":
-        return routerInlineExecutor(spec, seamed);
-      case "router-tools":
-        return routerToolsInlineExecutor(spec, seamed);
-      case "bridge":
-        return bridgeExecutor(spec, seamed);
-      case "cli":
-        return cliExecutor(spec, seamed);
-      case "cli-worktree":
-        return cliWorktreeExecutor(spec, seamed);
-      case "provider": {
-        const providerSeam = readSeam(seamed, providerSeamKey, "provider");
-        const provider = resolveAgentEnvironmentProvider(
-          providerSeam.provider,
-          providerSeam.registry
-        );
-        return providerAsExecutor(provider, providerSeam)(spec, seamed);
-      }
-      case "sandbox": {
-        const harness = spec.harness ?? config.harness ?? null;
-        return sandboxExecutor({ ...spec, harness }, seamed);
-      }
-    }
-  };
-}
-function createExecutorRegistry() {
-  const factories = /* @__PURE__ */ new Map();
-  factories.set("router", routerInlineExecutor);
-  factories.set("inline", routerInlineExecutor);
-  factories.set("sandbox", sandboxExecutor);
-  factories.set("cli", cliExecutor);
-  return {
-    register(runtime, factory) {
-      if (factories.has(runtime)) {
-        throw new ValidationError(`executor registry: runtime "${runtime}" already registered`);
-      }
-      factories.set(runtime, factory);
-    },
-    resolve(spec) {
-      if (spec.executor) {
-        const byo = spec.executor;
-        return { succeeded: true, value: (() => byo) };
-      }
-      if (spec.harness === null) {
-        const f2 = factories.get("router");
-        if (!f2) return { succeeded: false, error: 'executor registry: no "router" factory' };
-        return { succeeded: true, value: f2 };
-      }
-      const runtimeTag = "sandbox";
-      const f = factories.get(runtimeTag);
-      if (!f) {
-        return {
-          succeeded: false,
-          error: `executor registry: no factory for runtime "${runtimeTag}" (harness "${spec.harness}") and no BYO executor`
-        };
-      }
-      return { succeeded: true, value: f };
-    }
-  };
-}
-function readSeam(ctx, key, who) {
-  const seam = ctx.seams[key];
-  if (seam === void 0 || seam === null) {
-    throw new ValidationError(`${who} executor: missing required seam "${key}" on ExecutorContext`);
-  }
-  return seam;
-}
-function taskToPrompt(task) {
-  if (typeof task === "string") return task;
-  if (task && typeof task === "object") {
-    const obj = task;
-    for (const k of ["prompt", "content", "task", "message"]) {
-      if (typeof obj[k] === "string") return obj[k];
-    }
-  }
-  return JSON.stringify(task);
-}
-function taskToMessages(task, spec) {
-  const messages = [];
-  const system = spec.profile.prompt?.systemPrompt;
-  if (typeof system === "string" && system.length > 0) {
-    messages.push({ role: "system", content: system });
-  }
-  messages.push({ role: "user", content: taskToPrompt(task) });
-  return messages;
-}
-function singleShotDriver(maxIterations) {
-  return {
-    name: "leaf",
-    plan(task, history) {
-      return Promise.resolve(history.length >= maxIterations ? [] : [task]);
-    },
-    decide(history) {
-      return history.length >= maxIterations ? "stop" : "continue";
-    }
-  };
-}
-function linkSignals2(a, b) {
-  if (a.aborted || b.aborted) {
-    const c2 = new AbortController();
-    c2.abort();
-    return c2.signal;
-  }
-  const c = new AbortController();
-  const onAbort = () => c.abort();
-  a.addEventListener("abort", onAbort, { once: true });
-  b.addEventListener("abort", onAbort, { once: true });
-  return c.signal;
-}
-function mergeAbortSignals(...signals) {
-  const c = new AbortController();
-  const onAbort = () => c.abort();
-  for (const s of signals) {
-    if (s.aborted) {
-      c.abort();
-      break;
-    }
-    s.addEventListener("abort", onAbort, { once: true });
-  }
-  return c.signal;
-}
-
-// src/runtime/supervise/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 });
+      return { destroyed };
     },
     resultArtifact() {
       if (!artifact) {
-        throw new ValidationError("driverExecutor: resultArtifact() read before execute()");
+        throw new ValidationError(
+          "cliWorktreeExecutor: bridge resultArtifact() read before stream drained"
+        );
       }
       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 resolveBridgeWorktreeModel(spec, bridge) {
+  if (bridge.model) return bridge.model;
+  const model = spec.profile.model?.default;
+  if (typeof model === "string" && model.length > 0) return model;
+  throw new ValidationError(
+    "cliWorktreeExecutor: bridge.model or AgentProfile.model.default required"
+  );
 }
-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;
+function bridgeOutputText(out) {
+  if (typeof out === "string") return out;
+  if (out && typeof out === "object") {
+    const content = out.content;
+    if (typeof content === "string") return content;
   }
-  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)));
+    return JSON.stringify(out) ?? String(out);
   } 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();
-  return {
-    journal: new InMemorySpawnJournal(),
-    blobs: new InMemoryResultBlobStore(),
-    executors: opts.withDriver ? withDriverExecutor(base) : base
-  };
-}
-
-// 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;
+    return String(out);
   }
-  function readout() {
-    return {
-      tokensLeft: freeTokens,
-      usdLeft: usdCapped ? freeUsd : 0,
-      usdCapped,
-      deadlineMs: absoluteDeadlineMs,
-      reservedTokens
-    };
+}
+function isAsyncIterable3(value) {
+  return value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
+}
+var cliWorktreeExecutor = (spec, ctx) => {
+  const seam = readSeam(ctx, cliWorktreeSeamKey, "cli-worktree");
+  if (!seam.repoRoot || !seam.taskPrompt) {
+    throw new ValidationError("cliWorktreeExecutor: CliWorktreeSeam.repoRoot + taskPrompt required");
   }
-  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`
-      );
-    }
+  if (seam.bridge) return bridgeWorktreeExecutor(spec, ctx, seam);
+  if (!seam.harness) {
+    throw new ValidationError(
+      "cliWorktreeExecutor: CliWorktreeSeam.harness required when bridge is not set"
+    );
   }
-  return {
-    reserve,
-    reconcile,
-    spendFrom: foldUsage,
-    readout,
-    observe,
-    assertNoOpenTickets
+  return createWorktreeCliExecutor({
+    repoRoot: seam.repoRoot,
+    profile: spec.profile,
+    harness: seam.harness,
+    taskPrompt: seam.taskPrompt,
+    ...seam.runId ? { runId: seam.runId } : {},
+    ...seam.baseRef ? { baseRef: seam.baseRef } : {},
+    ...seam.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: seam.harnessTimeoutMs } : {},
+    ...seam.testCmd !== void 0 ? { testCmd: seam.testCmd } : {},
+    ...seam.typecheckCmd !== void 0 ? { typecheckCmd: seam.typecheckCmd } : {},
+    ...seam.checkTimeoutMs !== void 0 ? { checkTimeoutMs: seam.checkTimeoutMs } : {},
+    ...seam.checkOutputCap !== void 0 ? { checkOutputCap: seam.checkOutputCap } : {},
+    ...seam.runGit ? { runGit: seam.runGit } : {},
+    ...seam.runCommand ? { runCommand: seam.runCommand } : {},
+    ...seam.budgetExempt !== void 0 ? { budgetExempt: seam.budgetExempt } : {}
+  });
+};
+function createExecutor(config) {
+  return (spec, ctx) => {
+    const { backend, ...seam } = config;
+    const seamed = { ...ctx, seams: { ...ctx.seams, [backend]: seam } };
+    switch (config.backend) {
+      case "router":
+        return routerInlineExecutor(spec, seamed);
+      case "router-tools":
+        return routerToolsInlineExecutor(spec, seamed);
+      case "bridge":
+        return bridgeExecutor(spec, seamed);
+      case "cli":
+        return cliExecutor(spec, seamed);
+      case "cli-worktree":
+        return cliWorktreeExecutor(spec, seamed);
+      case "provider": {
+        const providerSeam = readSeam(seamed, providerSeamKey, "provider");
+        const provider = resolveAgentEnvironmentProvider(
+          providerSeam.provider,
+          providerSeam.registry
+        );
+        return providerAsExecutor(provider, providerSeam)(spec, seamed);
+      }
+      case "sandbox": {
+        const harness = spec.harness ?? config.harness ?? null;
+        return sandboxExecutor({ ...spec, harness }, seamed);
+      }
+    }
   };
 }
-
-// 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);
+function createExecutorRegistry() {
+  const factories = /* @__PURE__ */ new Map();
+  factories.set("router", routerInlineExecutor);
+  factories.set("inline", routerInlineExecutor);
+  factories.set("sandbox", sandboxExecutor);
+  factories.set("cli", cliExecutor);
+  return {
+    register(runtime, factory) {
+      if (factories.has(runtime)) {
+        throw new ValidationError(`executor registry: runtime "${runtime}" already registered`);
+      }
+      factories.set(runtime, factory);
+    },
+    resolve(spec) {
+      if (spec.executor) {
+        const byo = spec.executor;
+        return { succeeded: true, value: (() => byo) };
+      }
+      if (spec.harness === null) {
+        const f2 = factories.get("router");
+        if (!f2) return { succeeded: false, error: 'executor registry: no "router" factory' };
+        return { succeeded: true, value: f2 };
+      }
+      const runtimeTag = "sandbox";
+      const f = factories.get(runtimeTag);
+      if (!f) {
         return {
-          kind: "winner",
-          out,
-          outRef,
-          tree,
-          spentTotal: addSpend(childWork, driverInference),
-          ...isNonEmptySpend(driverInference) ? { spentBreakdown: { driverInference, childWork } } : {}
+          succeeded: false,
+          error: `executor registry: no factory for runtime "${runtimeTag}" (harness "${spec.harness}") and no BYO executor`
         };
       }
-      return noWinner();
+      return { succeeded: true, value: f };
     }
-    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 readSeam(ctx, key, who) {
+  const seam = ctx.seams[key];
+  if (seam === void 0 || seam === null) {
+    throw new ValidationError(`${who} executor: missing required seam "${key}" on ExecutorContext`);
+  }
+  return seam;
+}
+function taskToPrompt(task) {
+  if (typeof task === "string") return task;
+  if (task && typeof task === "object") {
+    const obj = task;
+    for (const k of ["prompt", "content", "task", "message"]) {
+      if (typeof obj[k] === "string") return obj[k];
     }
   }
-  function attach(h) {
-    const control = rootControls.get(h);
-    if (!control) {
-      throw new RuntimeRunStateError(
-        "supervisor.attach: handle was not minted by createRootHandle (no control channel)"
-      );
+  return JSON.stringify(task);
+}
+function taskToMessages(task, spec) {
+  const messages = [];
+  const system = spec.profile.prompt?.systemPrompt;
+  if (typeof system === "string" && system.length > 0) {
+    messages.push({ role: "system", content: system });
+  }
+  messages.push({ role: "user", content: taskToPrompt(task) });
+  return messages;
+}
+function singleShotDriver(maxIterations) {
+  return {
+    name: "leaf",
+    plan(task, history) {
+      return Promise.resolve(history.length >= maxIterations ? [] : [task]);
+    },
+    decide(history) {
+      return history.length >= maxIterations ? "stop" : "continue";
     }
-    attached = control;
+  };
+}
+function linkSignals2(a, b) {
+  if (a.aborted || b.aborted) {
+    const c2 = new AbortController();
+    c2.abort();
+    return c2.signal;
+  }
+  const c = new AbortController();
+  const onAbort = () => c.abort();
+  a.addEventListener("abort", onAbort, { once: true });
+  b.addEventListener("abort", onAbort, { once: true });
+  return c.signal;
+}
+function mergeAbortSignals(...signals) {
+  const c = new AbortController();
+  const onAbort = () => c.abort();
+  for (const s of signals) {
+    if (s.aborted) {
+      c.abort();
+      break;
+    }
+    s.addEventListener("abort", onAbort, { once: true });
   }
-  return { run, attach };
+  return c.signal;
 }
-var rootControls = /* @__PURE__ */ new WeakMap();
-function pushRootSignal(cascadeAbort) {
-  return (msg) => {
-    if (msg.kind === "cancel") cascadeAbort(msg.reason ?? "root signal: cancel");
-  };
+
+// 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;
 }
-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;
+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 {
-    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();
+    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;
       }
     },
-    tripped() {
-      return isTripped;
+    metered() {
+      return meteredSpend;
     },
-    downCount() {
-      return total;
+    teardown() {
+      return Promise.resolve({ destroyed: true });
+    },
+    resultArtifact() {
+      if (!artifact) {
+        throw new ValidationError("driverExecutor: resultArtifact() read before execute()");
+      }
+      return artifact;
     }
   };
-}
-function wrapJournalForBreaker(journal, breaker) {
+};
+function withDriverExecutor(base) {
   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);
+    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);
     }
   };
 }
-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 nestedTreeKey(seam, journal) {
+  return `${seam.journalRoot}/d${nextNestOrdinal(journal)}`;
 }
-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;
+var nestCounters = /* @__PURE__ */ new WeakMap();
+function nextNestOrdinal(journal) {
+  let c = nestCounters.get(journal);
+  if (!c) {
+    c = { n: 0 };
+    nestCounters.set(journal, c);
   }
-  return false;
+  return c.n++;
 }
-async function spentFromJournal(journal, root) {
-  const events = await journal.loadTree(root);
+async function loadTreeEvents(journal, nestedRoot) {
+  const events = await journal.loadTree(nestedRoot);
   if (events === void 0) {
-    throw new RuntimeRunStateError(
-      `supervisor: spawn tree '${root}' is missing from the journal after run (corrupted log)`
+    throw new ValidationError(
+      `driverExecutor: nested tree '${nestedRoot}' 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 };
+  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 === "settled") accumulate(childWork, ev.spent);
-    else if (ev.kind === "metered") accumulate(driverInference, ev.spend);
+    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 { childWork, driverInference };
+  return total;
 }
-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 isNonZeroSpend(s) {
+  return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0;
 }
-function addSpend(a, b) {
+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 {
-    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
+    valid: anyValid,
+    score: anyValid ? bestValidScore ?? 1 : bestDoneScore ?? 0
   };
 }
-function isNonEmptySpend(s) {
-  return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 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();
+  return {
+    journal: new InMemorySpawnJournal(),
+    blobs: new InMemoryResultBlobStore(),
+    executors: opts.withDriver ? withDriverExecutor(base) : base
+  };
 }
 
 // src/runtime/supervise/event-bus.ts
@@ -6545,11 +6551,14 @@ async function delegate(intent, opts = {}) {
 }
 
 export {
-  assertModelAllowed,
-  gateOnDeliverable,
   contentAddress,
   InMemoryResultBlobStore,
   InMemorySpawnJournal,
+  assertModelAllowed,
+  routerChatWithUsage,
+  routerChatWithTools,
+  routerToolLoop,
+  routerBrain,
   defineRuntimeHooks,
   composeRuntimeHooks,
   notifyRuntimeHookEvent,
@@ -6557,14 +6566,14 @@ export {
   createScope,
   settledToIteration,
   withDriverExecutor,
+  spendFromUsageEvents,
+  createBudgetPool,
+  createSupervisor,
+  gateOnDeliverable,
   createWorktree,
   captureWorktreeDiff,
   removeWorktree,
   runWorktreeHarness,
-  routerChatWithUsage,
-  routerChatWithTools,
-  routerToolLoop,
-  routerBrain,
   acquireSandbox,
   probeSandboxCapabilities,
   createSandboxLineage,
@@ -6577,9 +6586,6 @@ export {
   createExecutor,
   createExecutorRegistry,
   createInMemoryRunContext,
-  spendFromUsageEvents,
-  createBudgetPool,
-  createSupervisor,
   createEventBus,
   createCoordinationTools,
   driverAgent,
@@ -6638,4 +6644,4 @@ export {
   workerFromBackend,
   supervise
 };
-//# sourceMappingURL=chunk-QSNSMJSZ.js.map
+//# sourceMappingURL=chunk-NC66AM3S.js.map