@tangle-network/agent-runtime 0.83.0 → 0.85.0

package/dist/{chunk-SSA6OERV.js → chunk-XN5TIJGP.js}

@@ -1162,480 +1162,6 @@ function hashJson(value) {
   return (h >>> 0).toString(16).padStart(8, "0");
 }
 
-// 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 || isAbortError2(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 isAbortError2(err) {
-  return typeof err === "object" && err !== null && "name" in err && err.name === "AbortError";
-}
-function isInfraError(err) {
-  return err instanceof ValidationError;
-}
-function errMessage(err) {
-  if (err instanceof Error) return err.message;
-  return String(err);
-}
-
 // src/mcp/worktree.ts
 import { spawn } from "child_process";
 async function runGitAsync(args, cwd, runner) {
@@ -2198,7 +1724,7 @@ function contentRef(prefix, value) {
   }
   return `${prefix}:${(h >>> 0).toString(16).padStart(8, "0")}`;
 }
-function zeroSpend2() {
+function zeroSpend() {
   return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
 }
 var routerInlineExecutor = (spec, ctx) => {
@@ -2604,7 +2130,7 @@ async function* streamCliLeaf(args) {
     );
   }
   const out = { content: chunks.join("") };
-  args.onArtifact({ outRef: contentRef("cli", out), out, spent: zeroSpend2() });
+  args.onArtifact({ outRef: contentRef("cli", out), out, spent: zeroSpend() });
   yield { kind: "iteration" };
 }
 function killWithGrace(proc, grace) {
@@ -2637,590 +2163,1064 @@ function bridgeCellModel(seamModel, ctx) {
   if (!h) return m;
   return m.startsWith(`${h}/`) ? m : `${h}/${m}`;
 }
-var bridgeExecutor = (spec, ctx) => {
-  const base = readSeam(ctx, bridgeSeamKey, "bridge");
-  const seam = { ...base, model: bridgeCellModel(base.model, ctx) };
-  if (!seam.bridgeUrl || !seam.bridgeBearer || !seam.model) {
+var bridgeExecutor = (spec, ctx) => {
+  const base = readSeam(ctx, bridgeSeamKey, "bridge");
+  const seam = { ...base, model: bridgeCellModel(base.model, ctx) };
+  if (!seam.bridgeUrl || !seam.bridgeBearer || !seam.model) {
+    throw new ValidationError(
+      "bridgeExecutor: BridgeSeam.bridgeUrl + bridgeBearer + model required"
+    );
+  }
+  const maxTurns = seam.maxTurns ?? 200;
+  const sessionId = seam.sessionId ?? `bridge-${spec.profile.name ?? "worker"}-${randomUUID2()}`;
+  const controller = new AbortController();
+  const abortIfSignalled = () => {
+    if (ctx.signal.aborted) controller.abort();
+  };
+  abortIfSignalled();
+  if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+  const inbox = createInbox();
+  let artifact;
+  return {
+    runtime: "cli",
+    deliver: (m) => inbox.deliver(m),
+    execute(task, signal) {
+      return streamBridgeSession({
+        task,
+        signal,
+        spec,
+        seam,
+        sessionId,
+        maxTurns,
+        inbox,
+        controller,
+        onArtifact: (a) => {
+          artifact = a;
+        }
+      });
+    },
+    teardown(_grace) {
+      controller.abort();
+      return Promise.resolve({ destroyed: true });
+    },
+    resultArtifact() {
+      if (!artifact) {
+        throw new ValidationError("bridgeExecutor: resultArtifact() read before stream drained");
+      }
+      return { ...artifact, spent: artifact.spent };
+    }
+  };
+};
+async function* streamBridgeSession(args) {
+  const { seam, inbox } = args;
+  const started = Date.now();
+  const external = mergeAbortSignals(args.signal, args.controller.signal);
+  const tokens = zeroTokenUsage();
+  let usd = 0;
+  let turns = 0;
+  let lastText = "";
+  const toolCalls = [];
+  let nextPrompt = taskToPrompt(args.task);
+  const system = args.spec.profile.prompt?.systemPrompt;
+  for (let t = 0; t < args.maxTurns; t += 1) {
+    const pending = inbox.drain();
+    if (pending.length) {
+      const folded = inbox.fold(pending);
+      nextPrompt = t === 0 && nextPrompt ? `${nextPrompt}
+
+${folded}` : folded;
+    }
+    if (nextPrompt === void 0) break;
+    const messages = [];
+    if (t === 0 && typeof system === "string" && system.length > 0) {
+      messages.push({ role: "system", content: system });
+    }
+    messages.push({ role: "user", content: nextPrompt });
+    nextPrompt = void 0;
+    const interruptSig = inbox.freshInterrupt();
+    const turnController = new AbortController();
+    const abortTurn = () => turnController.abort();
+    if (external.aborted) turnController.abort();
+    else external.addEventListener("abort", abortTurn);
+    interruptSig.addEventListener("abort", abortTurn, { once: true });
+    const timer = seam.timeoutMs ? setTimeout(abortTurn, seam.timeoutMs) : void 0;
+    const cleanup = () => {
+      external.removeEventListener("abort", abortTurn);
+      if (timer) clearTimeout(timer);
+    };
+    let res;
+    try {
+      res = await bridgeStreamPost(seam.bridgeUrl, {
+        bearer: seam.bridgeBearer,
+        sessionId: args.sessionId,
+        body: {
+          model: seam.model,
+          stream: true,
+          session_id: args.sessionId,
+          ...seam.cwd ? { cwd: seam.cwd } : {},
+          ...seam.agentProfile ? { agent_profile: seam.agentProfile } : {},
+          messages
+        },
+        signal: turnController.signal
+      });
+    } catch (e) {
+      cleanup();
+      const interruptAbort = e instanceof DOMException && e.name === "AbortError" && interruptSig.aborted && !args.signal.aborted && !args.controller.signal.aborted;
+      if (interruptAbort) continue;
+      throw e;
+    }
+    if (!res.ok) {
+      cleanup();
+      throw new ValidationError(
+        `bridgeExecutor: bridge ${res.status}: ${(await res.text()).slice(0, 300)}`
+      );
+    }
+    if (!res.body) {
+      cleanup();
+      throw new ValidationError("bridgeExecutor: bridge response had no body to stream");
+    }
+    let turnText = "";
+    try {
+      for await (const chunk of parseSseChatStream(res.body)) {
+        if (chunk.content) {
+          turnText += chunk.content;
+          yield { kind: "iteration" };
+        }
+        if (chunk.toolCall) toolCalls.push(chunk.toolCall);
+        if (chunk.usage) {
+          tokens.input += chunk.usage.input;
+          tokens.output += chunk.usage.output;
+          yield { kind: "tokens", input: chunk.usage.input, output: chunk.usage.output };
+        }
+        if (typeof chunk.cost === "number" && chunk.cost > 0) {
+          usd += chunk.cost;
+          yield { kind: "cost", usd: chunk.cost };
+        }
+      }
+    } finally {
+      cleanup();
+    }
+    turns += 1;
+    if (turnText) lastText = turnText;
+    if (inbox.pending() === 0) break;
+  }
+  const spent = {
+    iterations: turns,
+    tokens,
+    usd,
+    ms: Date.now() - started
+  };
+  const out = { content: lastText, toolCalls };
+  args.onArtifact({
+    outRef: contentRef("bridge", { model: seam.model, session: args.sessionId, content: lastText }),
+    out,
+    spent
+  });
+}
+function bridgeStreamPost(url, args) {
+  const target = new URL(`${url.replace(/\/$/, "")}/v1/chat/completions`);
+  const payload = JSON.stringify(args.body);
+  const requestFn = target.protocol === "https:" ? httpsRequest : httpRequest;
+  return new Promise((resolve, reject) => {
+    if (args.signal.aborted) {
+      reject(new DOMException("bridgeExecutor: aborted before request", "AbortError"));
+      return;
+    }
+    const req = requestFn(
+      target,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${args.bearer}`,
+          "x-session-id": args.sessionId,
+          "content-length": Buffer.byteLength(payload)
+        },
+        // No header/body idle timeout: a slow bridge is a live bridge; the abort
+        // signal is the sole deadline.
+        timeout: 0
+      },
+      (res) => {
+        const status = res.statusCode ?? 0;
+        const ok = status >= 200 && status < 300;
+        const body = Readable.toWeb(res);
+        resolve({
+          ok,
+          status,
+          body,
+          text: async () => {
+            const chunks = [];
+            for await (const c of res) chunks.push(c);
+            return Buffer.concat(chunks).toString("utf8");
+          }
+        });
+      }
+    );
+    const onAbort = () => {
+      req.destroy(new DOMException("bridgeExecutor: turn aborted", "AbortError"));
+    };
+    if (args.signal.aborted) onAbort();
+    else args.signal.addEventListener("abort", onAbort, { once: true });
+    req.on("error", (e) => {
+      args.signal.removeEventListener("abort", onAbort);
+      reject(e);
+    });
+    req.on("close", () => args.signal.removeEventListener("abort", onAbort));
+    req.write(payload);
+    req.end();
+  });
+}
+async function* parseSseChatStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      let sep = buf.indexOf("\n\n");
+      while (sep !== -1) {
+        const frame = buf.slice(0, sep);
+        buf = buf.slice(sep + 2);
+        const chunk = parseSseFrame(frame);
+        if (chunk === "done") return;
+        if (chunk) yield chunk;
+        sep = buf.indexOf("\n\n");
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseSseFrame(frame) {
+  const dataLines = [];
+  for (const rawLine of frame.split("\n")) {
+    const line = rawLine.replace(/\r$/, "");
+    if (!line || line.startsWith(":")) continue;
+    if (line.startsWith("data:")) dataLines.push(line.slice("data:".length).trimStart());
+  }
+  if (dataLines.length === 0) return void 0;
+  const data = dataLines.join("\n");
+  if (data === "[DONE]") return "done";
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return void 0;
+  }
+  if (parsed.error) {
+    throw new ValidationError(
+      `bridgeExecutor: bridge stream error: ${parsed.error.message ?? "unknown"}`
+    );
+  }
+  const out = {};
+  const choice = parsed.choices?.[0];
+  const content = choice?.delta?.content ?? choice?.message?.content;
+  if (typeof content === "string" && content.length > 0) out.content = content;
+  const toolName = choice?.delta?.tool_calls?.[0]?.function?.name;
+  if (typeof toolName === "string" && toolName.length > 0) out.toolCall = toolName;
+  const u = parsed.usage;
+  if (u && (typeof u.prompt_tokens === "number" || typeof u.completion_tokens === "number")) {
+    out.usage = { input: u.prompt_tokens ?? 0, output: u.completion_tokens ?? 0 };
+  }
+  if (typeof u?.cost === "number") out.cost = u.cost;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function bridgeWorktreeExecutor(spec, ctx, seam) {
+  const bridge = seam.bridge;
+  if (!bridge) {
+    throw new ValidationError("cliWorktreeExecutor: bridge transport missing");
+  }
+  if (!bridge.bridgeUrl || !bridge.bridgeBearer) {
     throw new ValidationError(
-      "bridgeExecutor: BridgeSeam.bridgeUrl + bridgeBearer + model required"
+      "cliWorktreeExecutor: bridge.bridgeUrl + bridge.bridgeBearer required"
     );
   }
-  const maxTurns = seam.maxTurns ?? 200;
-  const sessionId = seam.sessionId ?? `bridge-${spec.profile.name ?? "worker"}-${randomUUID2()}`;
+  const runId = seam.runId ?? randomUUID2();
+  const sessionId = bridge.sessionId ?? `bridge-worktree-${runId}`;
   const controller = new AbortController();
-  const abortIfSignalled = () => {
-    if (ctx.signal.aborted) controller.abort();
-  };
-  abortIfSignalled();
-  if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
-  const inbox = createInbox();
+  const pending = [];
+  let inner;
+  let worktree;
+  let removed = false;
   let artifact;
+  const cleanupWorktree = async () => {
+    if (!worktree || removed) return;
+    const target = worktree;
+    removed = true;
+    worktree = void 0;
+    await removeWorktree({
+      worktree: target,
+      repoRoot: seam.repoRoot,
+      ...seam.runGit ? { runGit: seam.runGit } : {}
+    }).catch(() => void 0);
+  };
+  const deliver = (msg) => {
+    if (inner?.deliver) {
+      inner.deliver(msg);
+      return;
+    }
+    pending.push(msg);
+  };
   return {
     runtime: "cli",
-    deliver: (m) => inbox.deliver(m),
-    execute(task, signal) {
-      return streamBridgeSession({
-        task,
-        signal,
-        spec,
-        seam,
-        sessionId,
-        maxTurns,
-        inbox,
-        controller,
-        onArtifact: (a) => {
-          artifact = a;
+    budgetExempt: seam.budgetExempt ?? false,
+    deliver,
+    execute(_task, signal) {
+      return (async function* bridgeWorktreeStream() {
+        const started = Date.now();
+        const linked = mergeAbortSignals(signal, controller.signal);
+        let bridgeArtifact;
+        try {
+          worktree = await createWorktree({
+            repoRoot: seam.repoRoot,
+            runId,
+            ...seam.baseRef ? { baseRef: seam.baseRef } : {},
+            ...seam.runGit ? { runGit: seam.runGit } : {}
+          });
+          removed = false;
+          const bridgeSeam = {
+            bridgeUrl: bridge.bridgeUrl,
+            bridgeBearer: bridge.bridgeBearer,
+            model: resolveBridgeWorktreeModel(spec, bridge),
+            cwd: worktree.path,
+            sessionId,
+            ...bridge.agentProfile ? { agentProfile: bridge.agentProfile } : { agentProfile: spec.profile },
+            ...bridge.timeoutMs !== void 0 ? { timeoutMs: bridge.timeoutMs } : {},
+            ...bridge.maxTurns !== void 0 ? { maxTurns: bridge.maxTurns } : {}
+          };
+          const bridgeCtx = {
+            ...ctx,
+            signal: linked,
+            seams: { ...ctx.seams, [bridgeSeamKey]: bridgeSeam }
+          };
+          inner = bridgeExecutor(spec, bridgeCtx);
+          for (const msg of pending.splice(0)) inner.deliver?.(msg);
+          const run = inner.execute(seam.taskPrompt, linked);
+          if (isAsyncIterable(run)) {
+            for await (const event of run) yield event;
+            bridgeArtifact = inner.resultArtifact();
+          } else {
+            bridgeArtifact = await run;
+          }
+          const diff = await captureWorktreeDiff({
+            worktree,
+            ...seam.runGit ? { runGit: seam.runGit } : {}
+          });
+          const checks = await runWorktreeChecks({
+            worktreePath: worktree.path,
+            ...seam.testCmd !== void 0 ? { testCmd: seam.testCmd } : {},
+            ...seam.typecheckCmd !== void 0 ? { typecheckCmd: seam.typecheckCmd } : {},
+            timeoutMs: seam.checkTimeoutMs ?? seam.harnessTimeoutMs ?? bridge.timeoutMs ?? 5 * 60 * 1e3,
+            cap: seam.checkOutputCap ?? 16e3,
+            ...seam.runCommand ? { runCommand: seam.runCommand } : {},
+            signal: linked
+          });
+          const result = {
+            branch: worktree.branch,
+            patch: diff.patch,
+            stats: diff.stats,
+            harness: {
+              name: "bridge",
+              exitCode: null,
+              timedOut: false,
+              killedBySignal: null,
+              durationMs: bridgeArtifact.spent.ms || Date.now() - started,
+              stdout: bridgeOutputText(bridgeArtifact.out),
+              stderr: ""
+            },
+            ...checks ? { checks } : {}
+          };
+          const spent = {
+            ...bridgeArtifact.spent,
+            ms: bridgeArtifact.spent.ms || Date.now() - started
+          };
+          artifact = {
+            outRef: contentRef("bridge-worktree", { sessionId, result }),
+            out: result,
+            spent
+          };
+        } catch (err) {
+          controller.abort();
+          await inner?.teardown("brutalKill").catch(() => void 0);
+          await cleanupWorktree();
+          throw err;
         }
-      });
+      })();
     },
-    teardown(_grace) {
+    async teardown(grace) {
       controller.abort();
-      return Promise.resolve({ destroyed: true });
-    },
-    resultArtifact() {
-      if (!artifact) {
-        throw new ValidationError("bridgeExecutor: resultArtifact() read before stream drained");
-      }
-      return { ...artifact, spent: artifact.spent };
-    }
-  };
-};
-async function* streamBridgeSession(args) {
-  const { seam, inbox } = args;
-  const started = Date.now();
-  const external = mergeAbortSignals(args.signal, args.controller.signal);
-  const tokens = zeroTokenUsage();
-  let usd = 0;
-  let turns = 0;
-  let lastText = "";
-  const toolCalls = [];
-  let nextPrompt = taskToPrompt(args.task);
-  const system = args.spec.profile.prompt?.systemPrompt;
-  for (let t = 0; t < args.maxTurns; t += 1) {
-    const pending = inbox.drain();
-    if (pending.length) {
-      const folded = inbox.fold(pending);
-      nextPrompt = t === 0 && nextPrompt ? `${nextPrompt}
-
-${folded}` : folded;
-    }
-    if (nextPrompt === void 0) break;
-    const messages = [];
-    if (t === 0 && typeof system === "string" && system.length > 0) {
-      messages.push({ role: "system", content: system });
-    }
-    messages.push({ role: "user", content: nextPrompt });
-    nextPrompt = void 0;
-    const interruptSig = inbox.freshInterrupt();
-    const turnController = new AbortController();
-    const abortTurn = () => turnController.abort();
-    if (external.aborted) turnController.abort();
-    else external.addEventListener("abort", abortTurn);
-    interruptSig.addEventListener("abort", abortTurn, { once: true });
-    const timer = seam.timeoutMs ? setTimeout(abortTurn, seam.timeoutMs) : void 0;
-    const cleanup = () => {
-      external.removeEventListener("abort", abortTurn);
-      if (timer) clearTimeout(timer);
-    };
-    let res;
-    try {
-      res = await bridgeStreamPost(seam.bridgeUrl, {
-        bearer: seam.bridgeBearer,
-        sessionId: args.sessionId,
-        body: {
-          model: seam.model,
-          stream: true,
-          session_id: args.sessionId,
-          ...seam.cwd ? { cwd: seam.cwd } : {},
-          ...seam.agentProfile ? { agent_profile: seam.agentProfile } : {},
-          messages
-        },
-        signal: turnController.signal
-      });
-    } catch (e) {
-      cleanup();
-      const interruptAbort = e instanceof DOMException && e.name === "AbortError" && interruptSig.aborted && !args.signal.aborted && !args.controller.signal.aborted;
-      if (interruptAbort) continue;
-      throw e;
-    }
-    if (!res.ok) {
-      cleanup();
-      throw new ValidationError(
-        `bridgeExecutor: bridge ${res.status}: ${(await res.text()).slice(0, 300)}`
-      );
-    }
-    if (!res.body) {
-      cleanup();
-      throw new ValidationError("bridgeExecutor: bridge response had no body to stream");
-    }
-    let turnText = "";
-    try {
-      for await (const chunk of parseSseChatStream(res.body)) {
-        if (chunk.content) {
-          turnText += chunk.content;
-          yield { kind: "iteration" };
-        }
-        if (chunk.toolCall) toolCalls.push(chunk.toolCall);
-        if (chunk.usage) {
-          tokens.input += chunk.usage.input;
-          tokens.output += chunk.usage.output;
-          yield { kind: "tokens", input: chunk.usage.input, output: chunk.usage.output };
-        }
-        if (typeof chunk.cost === "number" && chunk.cost > 0) {
-          usd += chunk.cost;
-          yield { kind: "cost", usd: chunk.cost };
+      let destroyed = true;
+      try {
+        if (inner) {
+          destroyed = (await inner.teardown(grace)).destroyed;
         }
+      } finally {
+        await cleanupWorktree();
       }
-    } finally {
-      cleanup();
+      return { destroyed };
+    },
+    resultArtifact() {
+      if (!artifact) {
+        throw new ValidationError(
+          "cliWorktreeExecutor: bridge resultArtifact() read before stream drained"
+        );
+      }
+      return artifact;
     }
-    turns += 1;
-    if (turnText) lastText = turnText;
-    if (inbox.pending() === 0) break;
-  }
-  const spent = {
-    iterations: turns,
-    tokens,
-    usd,
-    ms: Date.now() - started
   };
-  const out = { content: lastText, toolCalls };
-  args.onArtifact({
-    outRef: contentRef("bridge", { model: seam.model, session: args.sessionId, content: lastText }),
-    out,
-    spent
-  });
-}
-function bridgeStreamPost(url, args) {
-  const target = new URL(`${url.replace(/\/$/, "")}/v1/chat/completions`);
-  const payload = JSON.stringify(args.body);
-  const requestFn = target.protocol === "https:" ? httpsRequest : httpRequest;
-  return new Promise((resolve, reject) => {
-    if (args.signal.aborted) {
-      reject(new DOMException("bridgeExecutor: aborted before request", "AbortError"));
-      return;
-    }
-    const req = requestFn(
-      target,
-      {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: `Bearer ${args.bearer}`,
-          "x-session-id": args.sessionId,
-          "content-length": Buffer.byteLength(payload)
-        },
-        // No header/body idle timeout: a slow bridge is a live bridge; the abort
-        // signal is the sole deadline.
-        timeout: 0
-      },
-      (res) => {
-        const status = res.statusCode ?? 0;
-        const ok = status >= 200 && status < 300;
-        const body = Readable.toWeb(res);
-        resolve({
-          ok,
-          status,
-          body,
-          text: async () => {
-            const chunks = [];
-            for await (const c of res) chunks.push(c);
-            return Buffer.concat(chunks).toString("utf8");
-          }
-        });
-      }
-    );
-    const onAbort = () => {
-      req.destroy(new DOMException("bridgeExecutor: turn aborted", "AbortError"));
-    };
-    if (args.signal.aborted) onAbort();
-    else args.signal.addEventListener("abort", onAbort, { once: true });
-    req.on("error", (e) => {
-      args.signal.removeEventListener("abort", onAbort);
-      reject(e);
-    });
-    req.on("close", () => args.signal.removeEventListener("abort", onAbort));
-    req.write(payload);
-    req.end();
-  });
 }
-async function* parseSseChatStream(body) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buf = "";
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buf += decoder.decode(value, { stream: true });
-      let sep = buf.indexOf("\n\n");
-      while (sep !== -1) {
-        const frame = buf.slice(0, sep);
-        buf = buf.slice(sep + 2);
-        const chunk = parseSseFrame(frame);
-        if (chunk === "done") return;
-        if (chunk) yield chunk;
-        sep = buf.indexOf("\n\n");
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
+function 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 parseSseFrame(frame) {
-  const dataLines = [];
-  for (const rawLine of frame.split("\n")) {
-    const line = rawLine.replace(/\r$/, "");
-    if (!line || line.startsWith(":")) continue;
-    if (line.startsWith("data:")) dataLines.push(line.slice("data:".length).trimStart());
+function bridgeOutputText(out) {
+  if (typeof out === "string") return out;
+  if (out && typeof out === "object") {
+    const content = out.content;
+    if (typeof content === "string") return content;
   }
-  if (dataLines.length === 0) return void 0;
-  const data = dataLines.join("\n");
-  if (data === "[DONE]") return "done";
-  let parsed;
   try {
-    parsed = JSON.parse(data);
+    return JSON.stringify(out) ?? String(out);
   } catch {
-    return void 0;
+    return String(out);
   }
-  if (parsed.error) {
+}
+function isAsyncIterable(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(
-      `bridgeExecutor: bridge stream error: ${parsed.error.message ?? "unknown"}`
+      "cliWorktreeExecutor: CliWorktreeSeam.harness required when bridge is not set"
     );
   }
-  const out = {};
-  const choice = parsed.choices?.[0];
-  const content = choice?.delta?.content ?? choice?.message?.content;
-  if (typeof content === "string" && content.length > 0) out.content = content;
-  const toolName = choice?.delta?.tool_calls?.[0]?.function?.name;
-  if (typeof toolName === "string" && toolName.length > 0) out.toolCall = toolName;
-  const u = parsed.usage;
-  if (u && (typeof u.prompt_tokens === "number" || typeof u.completion_tokens === "number")) {
-    out.usage = { input: u.prompt_tokens ?? 0, output: u.completion_tokens ?? 0 };
+  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 });
   }
-  if (typeof u?.cost === "number") out.cost = u.cost;
-  return Object.keys(out).length > 0 ? out : void 0;
+  messages.push({ role: "user", content: taskToPrompt(task) });
+  return messages;
 }
-function bridgeWorktreeExecutor(spec, ctx, seam) {
-  const bridge = seam.bridge;
-  if (!bridge) {
-    throw new ValidationError("cliWorktreeExecutor: bridge transport missing");
+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;
   }
-  if (!bridge.bridgeUrl || !bridge.bridgeBearer) {
-    throw new ValidationError(
-      "cliWorktreeExecutor: bridge.bridgeUrl + bridge.bridgeBearer required"
-    );
+  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 });
   }
-  const runId = seam.runId ?? randomUUID2();
-  const sessionId = bridge.sessionId ?? `bridge-worktree-${runId}`;
-  const controller = new AbortController();
-  const pending = [];
-  let inner;
-  let worktree;
-  let removed = false;
-  let artifact;
-  const cleanupWorktree = async () => {
-    if (!worktree || removed) return;
-    const target = worktree;
-    removed = true;
-    worktree = void 0;
-    await removeWorktree({
-      worktree: target,
-      repoRoot: seam.repoRoot,
-      ...seam.runGit ? { runGit: seam.runGit } : {}
-    }).catch(() => void 0);
-  };
-  const deliver = (msg) => {
-    if (inner?.deliver) {
-      inner.deliver(msg);
-      return;
+  return c.signal;
+}
+
+// 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 } : {}
+      });
     }
-    pending.push(msg);
   };
-  return {
-    runtime: "cli",
-    budgetExempt: seam.budgetExempt ?? false,
-    deliver,
-    execute(_task, signal) {
-      return (async function* bridgeWorktreeStream() {
-        const started = Date.now();
-        const linked = mergeAbortSignals(signal, controller.signal);
-        let bridgeArtifact;
-        try {
-          worktree = await createWorktree({
-            repoRoot: seam.repoRoot,
-            runId,
-            ...seam.baseRef ? { baseRef: seam.baseRef } : {},
-            ...seam.runGit ? { runGit: seam.runGit } : {}
-          });
-          removed = false;
-          const bridgeSeam = {
-            bridgeUrl: bridge.bridgeUrl,
-            bridgeBearer: bridge.bridgeBearer,
-            model: resolveBridgeWorktreeModel(spec, bridge),
-            cwd: worktree.path,
-            sessionId,
-            ...bridge.agentProfile ? { agentProfile: bridge.agentProfile } : { agentProfile: spec.profile },
-            ...bridge.timeoutMs !== void 0 ? { timeoutMs: bridge.timeoutMs } : {},
-            ...bridge.maxTurns !== void 0 ? { maxTurns: bridge.maxTurns } : {}
-          };
-          const bridgeCtx = {
-            ...ctx,
-            signal: linked,
-            seams: { ...ctx.seams, [bridgeSeamKey]: bridgeSeam }
-          };
-          inner = bridgeExecutor(spec, bridgeCtx);
-          for (const msg of pending.splice(0)) inner.deliver?.(msg);
-          const run = inner.execute(seam.taskPrompt, linked);
-          if (isAsyncIterable2(run)) {
-            for await (const event of run) yield event;
-            bridgeArtifact = inner.resultArtifact();
-          } else {
-            bridgeArtifact = await run;
-          }
-          const diff = await captureWorktreeDiff({
-            worktree,
-            ...seam.runGit ? { runGit: seam.runGit } : {}
-          });
-          const checks = await runWorktreeChecks({
-            worktreePath: worktree.path,
-            ...seam.testCmd !== void 0 ? { testCmd: seam.testCmd } : {},
-            ...seam.typecheckCmd !== void 0 ? { typecheckCmd: seam.typecheckCmd } : {},
-            timeoutMs: seam.checkTimeoutMs ?? seam.harnessTimeoutMs ?? bridge.timeoutMs ?? 5 * 60 * 1e3,
-            cap: seam.checkOutputCap ?? 16e3,
-            ...seam.runCommand ? { runCommand: seam.runCommand } : {},
-            signal: linked
-          });
-          const result = {
-            branch: worktree.branch,
-            patch: diff.patch,
-            stats: diff.stats,
-            harness: {
-              name: "bridge",
-              exitCode: null,
-              timedOut: false,
-              killedBySignal: null,
-              durationMs: bridgeArtifact.spent.ms || Date.now() - started,
-              stdout: bridgeOutputText(bridgeArtifact.out),
-              stderr: ""
-            },
-            ...checks ? { checks } : {}
-          };
-          const spent = {
-            ...bridgeArtifact.spent,
-            ms: bridgeArtifact.spent.ms || Date.now() - started
-          };
-          artifact = {
-            outRef: contentRef("bridge-worktree", { sessionId, result }),
-            out: result,
-            spent
-          };
-        } catch (err) {
-          controller.abort();
-          await inner?.teardown("brutalKill").catch(() => void 0);
-          await cleanupWorktree();
-          throw err;
-        }
-      })();
-    },
-    async teardown(grace) {
-      controller.abort();
-      let destroyed = true;
-      try {
-        if (inner) {
-          destroyed = (await inner.teardown(grace)).destroyed;
+}
+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);
         }
-      } finally {
-        await cleanupWorktree();
-      }
-      return { destroyed };
-    },
-    resultArtifact() {
-      if (!artifact) {
+      };
+      const live = {
+        id,
+        status: "acquiring",
+        runtime: executor.runtime,
+        budget: opts.budget,
+        label: opts.label,
+        spent: zeroSpend2(),
+        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, zeroSpend2());
+      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(
-          "cliWorktreeExecutor: bridge resultArtifact() read before stream drained"
+          `scope.next: child '${chosen.id}' won the settle race without a resolved value`
         );
       }
-      return artifact;
+      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();
     }
   };
 }
-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"
-  );
+async function raceFirstSettled(pending) {
+  return Promise.race(pending.map((c) => c.settled.then(() => c)));
 }
-function bridgeOutputText(out) {
-  if (typeof out === "string") return out;
-  if (out && typeof out === "object") {
-    const content = out.content;
-    if (typeof content === "string") return content;
+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 {
-    return JSON.stringify(out) ?? String(out);
-  } catch {
-    return String(out);
+    live.status = "running";
+    const ran = executor.execute(task, childAbort.signal);
+    let artifact;
+    if (isAsyncIterable2(ran)) {
+      const spend = await foldStream(ran);
+      live.spent = spend;
+      artifact = executor.resultArtifact();
+      reconcileOnce(spend);
+    } else {
+      const terminal = await ran;
+      live.spent = terminal.spent;
+      artifact = terminal;
+      reconcileOnce(terminal.spent);
+    }
+    live.executorDone = true;
+    const ownMetered = executor.metered?.();
+    if (childAbort.signal.aborted) {
+      await teardownSafe(executor, opts.shutdown ?? "brutalKill");
+      return downRecord("aborted before settle", true, ownMetered);
+    }
+    const outRef = contentAddress(artifact.out);
+    await blobs.put(outRef, artifact.out);
+    await teardownSafe(executor, opts.shutdown ?? "infinity");
+    return {
+      kind: "done",
+      out: artifact.out,
+      outRef,
+      ...artifact.verdict ? { verdict: artifact.verdict } : {},
+      spent: live.spent,
+      ...ownMetered ? { metered: ownMetered } : {}
+    };
+  } catch (err) {
+    live.executorDone = true;
+    reconcileOnce(live.spent);
+    await teardownSafe(executor, "brutalKill");
+    const aborted = childAbort.signal.aborted || isAbortError2(err);
+    return downRecord(errMessage(err), aborted || isInfraError(err), executor.metered?.());
   }
 }
-function isAsyncIterable2(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) {
+function settledToIteration(settled) {
+  if (settled.kind === "down") {
     throw new ValidationError(
-      "cliWorktreeExecutor: CliWorktreeSeam.harness required when bridge is not set"
+      `settledToIteration: cannot adapt a 'down' settlement (node '${settled.handle.id}', seq ${settled.seq}) to an Iteration`
     );
   }
-  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);
-      }
-    }
+  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 createExecutorRegistry() {
-  const factories = /* @__PURE__ */ new Map();
-  factories.set("router", routerInlineExecutor);
-  factories.set("inline", routerInlineExecutor);
-  factories.set("sandbox", sandboxExecutor);
-  factories.set("cli", cliExecutor);
+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 {
-    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 };
-    }
+    root,
+    nodes,
+    inFlight: nodes.filter((n) => n.status === "running" || n.status === "acquiring").length
   };
 }
-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 frozenHandle(child) {
+  return {
+    id: child.id,
+    label: child.label,
+    status: child.status,
+    abort() {
     }
-  }
-  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 });
+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;
+    }
   }
-  messages.push({ role: "user", content: taskToPrompt(task) });
-  return messages;
+  return { iterations, tokens, usd, ms: 0 };
 }
-function singleShotDriver(maxIterations) {
+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 {
-    name: "leaf",
-    plan(task, history) {
-      return Promise.resolve(history.length >= maxIterations ? [] : [task]);
-    },
-    decide(history) {
-      return history.length >= maxIterations ? "stop" : "continue";
-    }
+    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
   };
 }
-function linkSignals2(a, b) {
-  if (a.aborted || b.aborted) {
-    const c2 = new AbortController();
-    c2.abort();
-    return c2.signal;
+async function teardownSafe(executor, grace) {
+  try {
+    await executor.teardown(grace);
+  } catch {
   }
-  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;
+function downRecord(reason, infra, metered) {
+  return { kind: "down", reason, infra, restartCount: 0, ...metered ? { metered } : {} };
+}
+function zeroSpend2() {
+  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 isAbortError2(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
@@ -6511,9 +6511,6 @@ export {
   runLoop,
   createSandboxForSpec,
   defaultSelectWinner,
-  createScope,
-  settledToIteration,
-  withDriverExecutor,
   createWorktree,
   captureWorktreeDiff,
   removeWorktree,
@@ -6527,6 +6524,9 @@ export {
   cliWorktreeExecutor,
   createExecutor,
   createExecutorRegistry,
+  createScope,
+  settledToIteration,
+  withDriverExecutor,
   spendFromUsageEvents,
   createBudgetPool,
   createSupervisor,
@@ -6590,4 +6590,4 @@ export {
   createInProcessTransport,
   serveCoordinationMcp
 };
-//# sourceMappingURL=chunk-SSA6OERV.js.map
+//# sourceMappingURL=chunk-XN5TIJGP.js.map