@tangle-network/agent-runtime 0.102.2 → 0.103.0

package/dist/{chunk-ZUCUAFVF.js → chunk-EAQ5YRRY.js}

@@ -7,6 +7,7 @@ import {
 import {
   assertModelAllowed,
   captureWorktreeDiff,
+  createActivityLog,
   createSupervisor,
   createWorktree,
   notifyRuntimeHookEvent,
@@ -17,12 +18,14 @@ import {
   runWorktreeChecks,
   runWorktreeHarness,
   withDriverExecutor
-} from "./chunk-SQ3ZJH3Y.js";
+} from "./chunk-6WZZXQV5.js";
 import {
+  FileResultBlobStore,
+  FileSpawnJournal,
   InMemoryResultBlobStore,
   InMemorySpawnJournal,
   contentAddress
-} from "./chunk-IMSNJSXH.js";
+} from "./chunk-ISPWRSEC.js";
 import {
   providerAsExecutor,
   resolveAgentEnvironmentProvider
@@ -1037,15 +1040,15 @@ function copyPlainSpine(value, seen) {
   return copy;
 }
 function hashJson(value) {
-  let str;
+  let str2;
   try {
-    str = JSON.stringify(value) ?? String(value);
+    str2 = JSON.stringify(value) ?? String(value);
   } catch {
-    str = String(value);
+    str2 = String(value);
   }
   let h = 2166136261;
-  for (let i = 0; i < str.length; i += 1) {
-    h ^= str.charCodeAt(i);
+  for (let i = 0; i < str2.length; i += 1) {
+    h ^= str2.charCodeAt(i);
     h = Math.imul(h, 16777619);
   }
   return (h >>> 0).toString(16).padStart(8, "0");
@@ -1096,6 +1099,735 @@ ${lines.join("\n")}`;
   };
 }
 
+// src/runtime/supervise/trace-source.ts
+function toToolSpan(input, runId, seq, at) {
+  const startedAt = typeof input.startedAt === "number" ? input.startedAt : at;
+  const endedAt = typeof input.endedAt === "number" ? input.endedAt : startedAt;
+  return {
+    spanId: `${runId}-t${seq}`,
+    runId,
+    kind: "tool",
+    name: input.toolName,
+    toolName: input.toolName,
+    args: input.args,
+    status: input.status ?? "ok",
+    startedAt,
+    endedAt,
+    ...input.result !== void 0 ? { result: input.result } : {}
+  };
+}
+var obj = (v) => v && typeof v === "object" ? v : void 0;
+var str = (v) => typeof v === "string" && v ? v : void 0;
+var decodeOpencodePart = (raw) => {
+  if (str(raw.type)?.toLowerCase() !== "tool" || !str(raw.tool)) return void 0;
+  const part = raw;
+  const state = obj(part.state);
+  const status = state?.status;
+  if (!status || status === "pending" || status === "running") return void 0;
+  return {
+    toolName: part.tool,
+    args: state?.input ?? {},
+    // ToolStateError carries 'error' OR 'failed' — the reverse-engineered decoder missed 'failed'.
+    status: status === "error" || status === "failed" ? "error" : "ok",
+    ...str(part.callID) ? { callId: part.callID } : {}
+  };
+};
+var decodeAnthropicPart = (p) => {
+  if (str(p.type)?.toLowerCase() !== "tool_use") return void 0;
+  const name = str(p.name) ?? str(p.tool);
+  if (!name) return void 0;
+  const id = str(p.id) ?? str(p.tool_use_id);
+  return {
+    toolName: name,
+    args: p.input ?? {},
+    ...id ? { callId: id } : {}
+  };
+};
+var decodeOpenAiPart = (p) => {
+  const type = str(p.type)?.toLowerCase();
+  const fn = obj(p.function);
+  if (type !== "function" && type !== "tool_call") return void 0;
+  const name = str(fn?.name) ?? str(p.name);
+  if (!name) return void 0;
+  const rawArgs = fn?.arguments ?? p.arguments;
+  return {
+    toolName: name,
+    args: typeof rawArgs === "string" ? safeParse(rawArgs) : rawArgs ?? {},
+    ...str(p.id) ? { callId: p.id } : str(fn?.id) ? { callId: fn?.id } : {}
+  };
+};
+var toolPartDecoders = {
+  opencode: decodeOpencodePart,
+  "claude-code": decodeAnthropicPart,
+  anthropic: decodeAnthropicPart,
+  codex: decodeOpenAiPart,
+  openai: decodeOpenAiPart,
+  router: decodeOpenAiPart,
+  kimi: decodeOpenAiPart
+};
+function decodeToolPart(part, harness) {
+  const p = obj(part);
+  if (!p) return void 0;
+  const specific = harness ? toolPartDecoders[harness] : void 0;
+  if (specific) return specific(p);
+  for (const decode of new Set(Object.values(toolPartDecoders))) {
+    const step = decode(p);
+    if (step) return step;
+  }
+  return void 0;
+}
+function safeParse(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return s;
+  }
+}
+var runSeq = 0;
+function createPushTraceSource(opts = {}) {
+  const runId = opts.runId ?? `push-${runSeq++}`;
+  const now = opts.now ?? Date.now;
+  const spans = [];
+  const subs = /* @__PURE__ */ new Set();
+  return {
+    record(input) {
+      const span = toToolSpan(input, runId, spans.length, now());
+      spans.push(span);
+      for (const fn of subs) {
+        try {
+          fn(span);
+        } catch {
+        }
+      }
+      return span;
+    },
+    source: {
+      onSpan(handler) {
+        subs.add(handler);
+        return () => subs.delete(handler);
+      },
+      collect: () => Promise.resolve([...spans])
+    }
+  };
+}
+function createPartsTraceSource(opts) {
+  const runId = opts.runId ?? `parts-${runSeq++}`;
+  const now = opts.now ?? Date.now;
+  const subs = /* @__PURE__ */ new Set();
+  const seenLive = /* @__PURE__ */ new Set();
+  let liveSeq = 0;
+  let unsub;
+  const startLive = () => {
+    if (unsub || !opts.subscribeParts) return;
+    unsub = opts.subscribeParts((part) => {
+      const step = decodeToolPart(part, opts.harness);
+      if (!step) return;
+      if (step.callId) {
+        if (seenLive.has(step.callId)) return;
+        seenLive.add(step.callId);
+      }
+      const span = toToolSpan(step, runId, liveSeq++, now());
+      for (const fn of subs) {
+        try {
+          fn(span);
+        } catch {
+        }
+      }
+    });
+  };
+  return {
+    onSpan(handler) {
+      subs.add(handler);
+      startLive();
+      return () => {
+        subs.delete(handler);
+        if (subs.size === 0 && unsub) {
+          unsub();
+          unsub = void 0;
+        }
+      };
+    },
+    async collect() {
+      const parts = await opts.collectParts();
+      const spans = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const part of parts) {
+        const step = decodeToolPart(part, opts.harness);
+        if (!step) continue;
+        if (step.callId) {
+          if (seen.has(step.callId)) continue;
+          seen.add(step.callId);
+        }
+        spans.push(toToolSpan(step, runId, spans.length, now()));
+      }
+      return spans;
+    }
+  };
+}
+function sandboxSessionTraceSource(box, sessionId, opts = {}) {
+  return createPartsTraceSource({
+    collectParts: async () => {
+      const msgs = await box.messages({ sessionId });
+      return msgs.flatMap((m) => m.parts ? [...m.parts] : []);
+    },
+    ...opts.harness ? { harness: opts.harness } : {},
+    ...opts.subscribeParts ? { subscribeParts: opts.subscribeParts } : {},
+    runId: opts.runId ?? `box-${sessionId}`,
+    ...opts.now ? { now: opts.now } : {}
+  });
+}
+
+// src/runtime/supervise/pi-executor.ts
+import { spawn } from "child_process";
+var PI_RUNTIME = "pi";
+var piSeamKey = "pi";
+var piExecutor = (spec, ctx) => {
+  const seam = readPiSeam(ctx);
+  const inbox = createInbox();
+  const activity = createActivityLog(seam.activityWindow ?? 12);
+  const trace = createPushTraceSource({
+    runId: `pi-${spec.profile.name ?? "worker"}-${Date.now()}`
+  });
+  const controller = new AbortController();
+  const cascade = () => controller.abort();
+  if (ctx.signal.aborted) controller.abort();
+  else ctx.signal.addEventListener("abort", cascade, { once: true });
+  const state = {
+    turns: 0,
+    lastText: "",
+    note: "starting",
+    proc: void 0,
+    artifact: void 0
+  };
+  return {
+    runtime: PI_RUNTIME,
+    // pi owns the queue; `deliver` only routes. A forceful message becomes pi's `steer` (which
+    // pi delivers after the current tool batch and before the next model call); a queued one
+    // becomes `follow_up` (after the turn finishes). Never throws — the inbox contract.
+    deliver: (m) => inbox.deliver(m),
+    progress: () => ({
+      turns: state.turns,
+      pendingMessages: inbox.pending(),
+      recentActivity: activity.read(),
+      note: state.note
+    }),
+    traceSource: () => trace.source,
+    execute(task, signal) {
+      return streamPiSession({
+        task,
+        signal,
+        controller,
+        seam,
+        spec,
+        inbox,
+        activity,
+        record: (step) => {
+          trace.record(step);
+        },
+        state
+      });
+    },
+    async teardown(grace) {
+      controller.abort();
+      const proc = state.proc;
+      if (!proc || proc.exitCode !== null || proc.killed) return { destroyed: true };
+      sendCommand(proc, { type: "abort" });
+      return killPi(proc, grace);
+    },
+    resultArtifact() {
+      if (!state.artifact) {
+        throw new ValidationError("piExecutor: resultArtifact() read before stream drained");
+      }
+      return state.artifact;
+    }
+  };
+};
+async function* streamPiSession(args) {
+  const { seam, inbox, activity, state } = args;
+  const started = Date.now();
+  const tokens = { input: 0, output: 0 };
+  let usd = 0;
+  const proc = spawnPi(seam);
+  state.proc = proc;
+  state.note = "connected";
+  const events = [];
+  let idle = false;
+  let failure;
+  let wake;
+  const notify = () => {
+    const w = wake;
+    wake = void 0;
+    w?.();
+  };
+  const stdoutLines = readJsonLines(proc, (value) => {
+    const ev = value;
+    if (ev.type === "agent_end") idle = true;
+    events.push(ev);
+    notify();
+  });
+  proc.once("exit", (code) => {
+    if (!idle && code !== 0 && code !== null) {
+      failure = new ValidationError(`piExecutor: pi exited with code ${code}`);
+    }
+    idle = true;
+    notify();
+  });
+  proc.once("error", (e) => {
+    failure = new ValidationError(`piExecutor: pi failed to start: ${e.message}`);
+    idle = true;
+    notify();
+  });
+  const abortAll = () => {
+    sendCommand(proc, { type: "abort" });
+    idle = true;
+    notify();
+  };
+  if (args.signal.aborted || args.controller.signal.aborted) abortAll();
+  else {
+    args.signal.addEventListener("abort", abortAll, { once: true });
+    args.controller.signal.addEventListener("abort", abortAll, { once: true });
+  }
+  const system = args.spec.profile.prompt?.systemPrompt;
+  const opening = system ? `${system}
+
+${taskText(args.task)}` : taskText(args.task);
+  const deadline = seam.turnTimeoutMs ? Date.now() + seam.turnTimeoutMs : void 0;
+  try {
+    sendCommand(proc, { type: "prompt", message: opening });
+    state.note = "turn 0";
+    for (; ; ) {
+      forwardPending(proc, inbox, activity);
+      while (events.length > 0) {
+        const ev = events.shift();
+        for (const usage of projectPiEvent(ev, args, tokens)) {
+          if (usage.kind === "cost") usd += usage.usd;
+          yield usage;
+        }
+      }
+      if (failure) throw failure;
+      if (deadline !== void 0 && Date.now() > deadline) {
+        throw new ValidationError("piExecutor: turn exceeded turnTimeoutMs");
+      }
+      if (idle) {
+        const pending = inbox.drain();
+        if (pending.length === 0) break;
+        idle = false;
+        sendCommand(proc, { type: "prompt", message: inbox.fold(pending) });
+        state.note = `turn ${state.turns}`;
+        continue;
+      }
+      await new Promise((resolve) => {
+        wake = resolve;
+        const t = setTimeout(() => {
+          if (wake === resolve) {
+            wake = void 0;
+            resolve();
+          }
+        }, 50);
+        if (typeof t.unref === "function") t.unref();
+      });
+    }
+  } finally {
+    stdoutLines();
+    state.note = "settled";
+    args.signal.removeEventListener("abort", abortAll);
+    args.controller.signal.removeEventListener("abort", abortAll);
+    await killPi(proc, 2e3).catch(() => ({ destroyed: false }));
+  }
+  const spent = { iterations: state.turns, tokens, usd, ms: Date.now() - started };
+  state.artifact = {
+    outRef: `pi:${hash(state.lastText)}`,
+    out: { content: state.lastText, turns: state.turns },
+    spent
+  };
+}
+function forwardPending(proc, inbox, activity) {
+  const pending = inbox.drain();
+  for (const m of pending) {
+    sendCommand(proc, {
+      type: m.interrupt ? "steer" : "follow_up",
+      message: renderOne(m)
+    });
+    activity.push({
+      at: Date.now(),
+      kind: "note",
+      label: m.interrupt ? "steer" : "follow-up",
+      detail: m.text.length > 80 ? `${m.text.slice(0, 77)}...` : m.text
+    });
+  }
+}
+function renderOne(m) {
+  if (m.kind === "answer") {
+    return `Answer to your question${m.questionId ? ` (${m.questionId})` : ""}: ${m.text}`;
+  }
+  return `New instruction from your supervisor: ${m.text}`;
+}
+function projectPiEvent(ev, args, tokens) {
+  const out = [];
+  const at = Date.now();
+  if (ev.type === "tool_execution_start" && typeof ev.toolName === "string") {
+    args.activity.push({ at, kind: "tool", label: ev.toolName, detail: describeArgs(ev.args) });
+    return out;
+  }
+  if (ev.type === "tool_execution_end" && typeof ev.toolName === "string") {
+    const status = ev.isError === true ? "error" : "ok";
+    args.activity.push({ at, kind: "tool", label: ev.toolName, status });
+    args.record({
+      toolName: ev.toolName,
+      args: ev.args ?? {},
+      status,
+      ...typeof ev.toolCallId === "string" ? { callId: ev.toolCallId } : {}
+    });
+    return out;
+  }
+  if (ev.type === "turn_end" || ev.type === "message_end") {
+    const usage = readUsage(ev.message);
+    if (usage && (usage.input || usage.output)) {
+      tokens.input += usage.input;
+      tokens.output += usage.output;
+      out.push({ kind: "tokens", input: usage.input, output: usage.output });
+    }
+    if (usage?.usd) out.push({ kind: "cost", usd: usage.usd });
+    const text = readText(ev.message);
+    if (text) args.state.lastText = text;
+    if (ev.type === "turn_end") {
+      args.state.turns += 1;
+      args.activity.push({ at, kind: "turn", label: `turn ${args.state.turns}` });
+      out.push({ kind: "iteration" });
+    }
+  }
+  return out;
+}
+function readUsage(message) {
+  if (!message || typeof message !== "object") return void 0;
+  const usage = message.usage;
+  if (!usage || typeof usage !== "object") return void 0;
+  const u = usage;
+  const input = num(u.input) ?? num(u.inputTokens) ?? num(u.prompt_tokens) ?? 0;
+  const output = num(u.output) ?? num(u.outputTokens) ?? num(u.completion_tokens) ?? 0;
+  const costRaw = u.cost;
+  const usd = num(costRaw) ?? (costRaw && typeof costRaw === "object" ? num(costRaw.totalCost) ?? 0 : 0);
+  return { input, output, usd };
+}
+function readText(message) {
+  if (!message || typeof message !== "object") return void 0;
+  const content = message.content;
+  if (typeof content === "string" && content.length > 0) return content;
+  if (!Array.isArray(content)) return void 0;
+  const text = content.map(
+    (block) => block && typeof block === "object" && typeof block.text === "string" ? block.text ?? "" : ""
+  ).join("");
+  return text.length > 0 ? text : void 0;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function describeArgs(argsValue) {
+  if (!argsValue || typeof argsValue !== "object") return void 0;
+  const a = argsValue;
+  for (const key of ["filePath", "file_path", "path", "file", "command", "cmd", "pattern"]) {
+    const v = a[key];
+    if (typeof v === "string" && v.length > 0) return v.length > 120 ? `${v.slice(0, 117)}...` : v;
+  }
+  return void 0;
+}
+function taskText(task) {
+  if (typeof task === "string") return task;
+  try {
+    return JSON.stringify(task) ?? String(task);
+  } catch {
+    return String(task);
+  }
+}
+function spawnPi(seam) {
+  const bin = seam.bin ?? "pi";
+  const argv = ["--mode", "rpc"];
+  if (seam.model) {
+    const slash = seam.model.indexOf("/");
+    if (slash > 0) {
+      argv.push("--provider", seam.model.slice(0, slash), "--model", seam.model.slice(slash + 1));
+    } else {
+      argv.push("--model", seam.model);
+    }
+  }
+  if (seam.args) argv.push(...seam.args);
+  return spawn(bin, argv, {
+    ...seam.cwd ? { cwd: seam.cwd } : {},
+    env: { ...process.env, ...seam.env ?? {} },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+function sendCommand(proc, command) {
+  try {
+    proc.stdin?.write(`${JSON.stringify(command)}
+`);
+  } catch {
+  }
+}
+function readJsonLines(proc, onValue) {
+  let buffer = "";
+  const onData = (chunk) => {
+    buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    for (; ; ) {
+      const nl = buffer.indexOf("\n");
+      if (nl < 0) break;
+      const line = buffer.slice(0, nl).trim();
+      buffer = buffer.slice(nl + 1);
+      if (!line) continue;
+      try {
+        onValue(JSON.parse(line));
+      } catch {
+      }
+    }
+  };
+  proc.stdout?.on("data", onData);
+  return () => {
+    proc.stdout?.off("data", onData);
+  };
+}
+var PI_ABORT_GRACE_MS = 500;
+async function killPi(proc, grace) {
+  if (proc.exitCode !== null || proc.killed) return { destroyed: true };
+  if (grace === "brutalKill") {
+    endStdin(proc);
+    proc.kill("SIGKILL");
+    return { destroyed: true };
+  }
+  const total = grace === "infinity" ? 1e4 : Math.max(0, grace);
+  if (await waitForExit(proc, Math.min(PI_ABORT_GRACE_MS, total))) return { destroyed: true };
+  endStdin(proc);
+  proc.kill("SIGTERM");
+  if (await waitForExit(proc, Math.max(0, total - PI_ABORT_GRACE_MS))) return { destroyed: true };
+  proc.kill("SIGKILL");
+  return { destroyed: true };
+}
+function endStdin(proc) {
+  try {
+    proc.stdin?.end();
+  } catch {
+  }
+}
+function waitForExit(proc, ms) {
+  if (proc.exitCode !== null) return Promise.resolve(true);
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(false), ms);
+    if (typeof timer.unref === "function") timer.unref();
+    proc.once("exit", () => {
+      clearTimeout(timer);
+      resolve(true);
+    });
+  });
+}
+function readPiSeam(ctx) {
+  const seam = ctx.seams[piSeamKey];
+  if (seam === void 0) return {};
+  if (!seam || typeof seam !== "object") {
+    throw new ValidationError(`piExecutor: seams['${piSeamKey}'] must be a PiSeam object`);
+  }
+  return seam;
+}
+function hash(value) {
+  let h = 2166136261;
+  for (let i = 0; i < value.length; i += 1) {
+    h ^= value.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+// src/runtime/supervise/sandbox-session.ts
+var DEFAULT_SANDBOX_STEERING_MAX_TURNS = 24;
+function createSteerableSandboxSession(args) {
+  const now = args.now ?? Date.now;
+  const maxTurns = Math.max(
+    1,
+    Math.floor(args.options?.maxTurns ?? DEFAULT_SANDBOX_STEERING_MAX_TURNS)
+  );
+  const activity = createActivityLog(args.options?.activityWindow ?? 12);
+  const trace = createPushTraceSource({ runId: `sandbox-${args.harness}-${now()}`, now });
+  const state = {
+    turns: 0,
+    lastText: "",
+    seenToolCalls: /* @__PURE__ */ new Set(),
+    artifact: void 0,
+    teardown: void 0,
+    note: "starting"
+  };
+  const recordEvent = (event) => {
+    const at = now();
+    const data = event.data;
+    const part = data && typeof data === "object" ? data.part : void 0;
+    if (part !== void 0) {
+      const step = decodeToolPart(part, args.harness);
+      if (step) {
+        const key = step.callId ?? `${step.toolName}:${activity.size()}`;
+        if (!state.seenToolCalls.has(key)) {
+          state.seenToolCalls.add(key);
+          trace.record(step);
+          const note = {
+            at,
+            kind: "tool",
+            label: step.toolName,
+            ...step.status ? { status: step.status } : {},
+            ...describeArgs2(step.args) ? { detail: describeArgs2(step.args) } : {}
+          };
+          activity.push(note);
+        }
+      }
+    }
+    const text = readFinalText(event);
+    if (text) state.lastText = text;
+  };
+  async function* stream(task, signal) {
+    const capabilities = await probeSandboxCapabilities(args.sandboxClient);
+    const lineage = createSandboxLineage(args.sandboxClient, capabilities, { maxConcurrency: 1 });
+    state.teardown = () => lineage.teardown();
+    const spec = {
+      profile: args.profile,
+      taskToPrompt: args.taskToPrompt,
+      name: args.profile.name ?? String(args.harness),
+      sandboxOverrides: { backend: { type: args.harness } }
+    };
+    const promptOptions = readPromptOptions(args.loopCtx);
+    const started = now();
+    const tokens = zeroTokenUsage();
+    let usd = 0;
+    let handle;
+    let nextPrompt = args.taskToPrompt(task);
+    try {
+      for (let turn = 0; turn < maxTurns; turn += 1) {
+        const pending = args.inbox.drain();
+        if (pending.length > 0) {
+          const folded = args.inbox.fold(pending);
+          nextPrompt = turn === 0 && nextPrompt ? `${nextPrompt}
+
+${folded}` : folded;
+          activity.push({
+            at: now(),
+            kind: "note",
+            label: "steer-folded",
+            detail: `${pending.length} message(s)`
+          });
+        }
+        if (nextPrompt === void 0) break;
+        const prompt = nextPrompt;
+        nextPrompt = void 0;
+        state.note = `turn ${turn}`;
+        const interruptSig = args.inbox.freshInterrupt();
+        const turnController = new AbortController();
+        const abortTurn = () => turnController.abort();
+        if (signal.aborted || args.controller.signal.aborted) turnController.abort();
+        else {
+          signal.addEventListener("abort", abortTurn);
+          args.controller.signal.addEventListener("abort", abortTurn);
+        }
+        interruptSig.addEventListener("abort", abortTurn, { once: true });
+        const timer = args.options?.turnTimeoutMs ? setTimeout(abortTurn, args.options.turnTimeoutMs) : void 0;
+        const cleanup = () => {
+          signal.removeEventListener("abort", abortTurn);
+          args.controller.signal.removeEventListener("abort", abortTurn);
+          if (timer) clearTimeout(timer);
+        };
+        let events;
+        try {
+          if (!handle) {
+            const opened = await lineage.start(spec, prompt, turnController.signal, promptOptions);
+            handle = opened.handle;
+            events = opened.events;
+          } else {
+            events = await lineage.continue(handle, prompt, turnController.signal, promptOptions);
+          }
+          for await (const event of events) {
+            recordEvent(event);
+            const call = extractLlmCallEvent(event, spec.name ?? String(args.harness));
+            if (!call) continue;
+            const input = call.tokensIn ?? 0;
+            const output = call.tokensOut ?? 0;
+            if (input || output) {
+              tokens.input += input;
+              tokens.output += output;
+              yield { kind: "tokens", input, output };
+            }
+            if (typeof call.costUsd === "number" && call.costUsd > 0) {
+              usd += call.costUsd;
+              yield { kind: "cost", usd: call.costUsd };
+            }
+          }
+        } catch (e) {
+          cleanup();
+          if (isInterruptAbort(e, interruptSig, signal, args.controller.signal)) {
+            activity.push({ at: now(), kind: "note", label: "interrupted", detail: "replanning" });
+            continue;
+          }
+          throw e;
+        }
+        cleanup();
+        state.turns += 1;
+        activity.push({ at: now(), kind: "turn", label: `turn ${turn}` });
+        yield { kind: "iteration" };
+        if (args.inbox.pending() === 0) break;
+      }
+    } finally {
+      state.note = "settled";
+      await lineage.teardown().catch(() => {
+      });
+      state.teardown = void 0;
+    }
+    const spent = { iterations: state.turns, tokens, usd, ms: now() - started };
+    const out = {
+      content: state.lastText,
+      turns: state.turns,
+      toolCalls: activity.read().filter((n) => n.kind === "tool").map((n) => n.label)
+    };
+    state.artifact = {
+      outRef: args.contentRef("sandbox-steerable", { harness: args.harness, out }),
+      out,
+      spent
+    };
+  }
+  return {
+    stream,
+    progress: () => ({
+      turns: state.turns,
+      pendingMessages: args.inbox.pending(),
+      recentActivity: activity.read(),
+      note: state.note
+    }),
+    traceSource: () => trace.source,
+    artifact: () => state.artifact,
+    async teardown() {
+      await state.teardown?.().catch(() => {
+      });
+    }
+  };
+}
+function isInterruptAbort(err, interrupt, external, owned) {
+  const aborted = err instanceof DOMException && err.name === "AbortError" || typeof err === "object" && err !== null && err.name === "AbortError";
+  return aborted && interrupt.aborted && !external.aborted && !owned.aborted;
+}
+function readFinalText(event) {
+  const data = event.data;
+  if (!data || typeof data !== "object") return void 0;
+  const text = data.finalText;
+  if (typeof text === "string" && text.length > 0) return text;
+  const alt = data.text;
+  return typeof alt === "string" && alt.length > 0 ? alt : void 0;
+}
+function describeArgs2(argsValue) {
+  if (!argsValue || typeof argsValue !== "object") return void 0;
+  const a = argsValue;
+  for (const key of ["filePath", "file_path", "path", "file", "command", "cmd", "pattern"]) {
+    const v = a[key];
+    if (typeof v === "string" && v.length > 0) return v.length > 120 ? `${v.slice(0, 117)}...` : v;
+  }
+  return void 0;
+}
+function readPromptOptions(loopCtx) {
+  const opts = loopCtx?.promptOptions;
+  if (!opts || typeof opts !== "object") return void 0;
+  return opts;
+}
+
 // src/runtime/supervise/worktree-cli-executor.ts
 import { randomUUID } from "crypto";
 function createWorktreeCliExecutor(options) {
@@ -1203,7 +1935,7 @@ function linkSignals(a, b) {
 }
 
 // src/runtime/supervise/runtime.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
@@ -1216,15 +1948,15 @@ var bridgeSeamKey = "bridge";
 var cliWorktreeSeamKey = "cli-worktree";
 var providerSeamKey = "provider";
 function contentRef(prefix, value) {
-  let str;
+  let str2;
   try {
-    str = JSON.stringify(value) ?? String(value);
+    str2 = JSON.stringify(value) ?? String(value);
   } catch {
-    str = String(value);
+    str2 = String(value);
   }
   let h = 2166136261;
-  for (let i = 0; i < str.length; i += 1) {
-    h ^= str.charCodeAt(i);
+  for (let i = 0; i < str2.length; i += 1) {
+    h ^= str2.charCodeAt(i);
     h = Math.imul(h, 16777619);
   }
   return `${prefix}:${(h >>> 0).toString(16).padStart(8, "0")}`;
@@ -1463,6 +2195,43 @@ var sandboxExecutor = (spec, ctx) => {
   abortIfSignalled();
   if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
   let artifact;
+  if (seam.steering) {
+    const inbox = createInbox();
+    const session = createSteerableSandboxSession({
+      controller,
+      profile: spec.profile,
+      harness,
+      sandboxClient: seam.sandboxClient,
+      inbox,
+      taskToPrompt: (t) => taskToPrompt(t),
+      options: seam.steering,
+      ...seam.loopCtx ? { loopCtx: seam.loopCtx } : {},
+      contentRef
+    });
+    return {
+      runtime: "sandbox",
+      deliver: (m) => inbox.deliver(m),
+      progress: () => session.progress(),
+      traceSource: () => session.traceSource(),
+      execute(task, signal) {
+        return session.stream(task, signal);
+      },
+      async teardown(_grace) {
+        controller.abort();
+        await session.teardown();
+        return { destroyed: true };
+      },
+      resultArtifact() {
+        const a = session.artifact();
+        if (!a) {
+          throw new ValidationError(
+            "sandboxExecutor(steering): resultArtifact() read before stream drained"
+          );
+        }
+        return a;
+      }
+    };
+  }
   const output = {
     parse(events) {
       return { events };
@@ -1598,7 +2367,7 @@ var cliExecutor = (_spec, ctx) => {
 };
 async function* streamCliLeaf(args) {
   const prompt = taskToPrompt(args.task);
-  const proc = spawn(args.seam.bin, args.seam.args ?? [], {
+  const proc = spawn2(args.seam.bin, args.seam.args ?? [], {
     ...args.seam.cwd ? { cwd: args.seam.cwd } : {},
     env: { ...process.env, ...args.seam.env ?? {} },
     stdio: ["pipe", "pipe", "pipe"]
@@ -2164,6 +2933,8 @@ function createExecutor(config) {
         return cliExecutor(spec, seamed);
       case "cli-worktree":
         return cliWorktreeExecutor(spec, seamed);
+      case "pi":
+        return piExecutor(spec, seamed);
       case "provider": {
         const providerSeam = readSeam(seamed, providerSeamKey, "provider");
         const provider = resolveAgentEnvironmentProvider(
@@ -2185,6 +2956,7 @@ function createExecutorRegistry() {
   factories.set("inline", routerInlineExecutor);
   factories.set("sandbox", sandboxExecutor);
   factories.set("cli", cliExecutor);
+  factories.set(PI_RUNTIME, piExecutor);
   return {
     register(runtime, factory) {
       if (factories.has(runtime)) {
@@ -2224,9 +2996,9 @@ function readSeam(ctx, key, who) {
 function taskToPrompt(task) {
   if (typeof task === "string") return task;
   if (task && typeof task === "object") {
-    const obj = task;
+    const obj2 = task;
     for (const k of ["prompt", "content", "task", "message"]) {
-      if (typeof obj[k] === "string") return obj[k];
+      if (typeof obj2[k] === "string") return obj2[k];
     }
   }
   return JSON.stringify(task);
@@ -2285,6 +3057,119 @@ function createInMemoryRunContext(opts = {}) {
     executors: opts.withDriver ? withDriverExecutor(base) : base
   };
 }
+function createFileRunContext(dir, opts = {}) {
+  const base = createExecutorRegistry();
+  return {
+    journal: new FileSpawnJournal(`${dir}/spawn-journal.jsonl`),
+    blobs: new FileResultBlobStore(`${dir}/blobs`),
+    executors: opts.withDriver ? withDriverExecutor(base) : base,
+    resume: true
+  };
+}
+
+// src/runtime/supervise/detector-monitor.ts
+import {
+  argHash,
+  errorStreakDetector,
+  observeAll,
+  repeatedActionDetector
+} from "@tangle-network/agent-eval";
+function defaultToolDetectors() {
+  return [repeatedActionDetector({ maxRepeated: 3 }), errorStreakDetector({ maxErrors: 3 })];
+}
+function watchTrace(source, opts = {}) {
+  const detectors = opts.detectors ?? defaultToolDetectors();
+  return source.onSpan((span) => {
+    let fingerprint;
+    try {
+      fingerprint = `${span.toolName}|${argHash(span.args)}`;
+    } catch {
+      fingerprint = `${span.toolName}|<unhashable>`;
+    }
+    const signals = observeAll(detectors, {
+      actionFingerprint: fingerprint,
+      ...span.status ? { status: span.status } : {},
+      label: span.toolName
+    });
+    for (const s of signals) void opts.onSignal?.(s, span);
+  });
+}
+
+// src/runtime/supervise/dispatch.ts
+async function rollingDispatch(scope, opts) {
+  if (!Number.isInteger(opts.width) || opts.width < 1) {
+    throw new ValidationError(
+      `rollingDispatch: width must be a positive integer, got ${String(opts.width)}`
+    );
+  }
+  const settled = [];
+  const rejected = [];
+  const live = /* @__PURE__ */ new Set();
+  let admitted = 0;
+  let peakLive = 0;
+  let queueDry = false;
+  let stopReason = "drained";
+  const fill = async () => {
+    while (live.size < opts.width) {
+      if (queueDry) return;
+      if (scope.signal.aborted) {
+        stopReason = "aborted";
+        queueDry = true;
+        return;
+      }
+      if (opts.shouldStop?.() === true) {
+        stopReason = "stopped";
+        queueDry = true;
+        return;
+      }
+      const unit = await opts.nextUnit();
+      if (unit === void 0) {
+        queueDry = true;
+        return;
+      }
+      const res = scope.spawn(unit.agent, unit.task, unit.opts);
+      if (!res.ok) {
+        rejected.push(`${unit.opts.label}: ${res.reason}`);
+        stopReason = "not-admitted";
+        queueDry = true;
+        return;
+      }
+      live.add(res.handle.id);
+      admitted += 1;
+      if (live.size > peakLive) peakLive = live.size;
+    }
+  };
+  await fill();
+  while (live.size > 0) {
+    const s = await scope.next();
+    if (s === null) break;
+    live.delete(s.handle.id);
+    settled.push(s);
+    await opts.onSettled?.(s);
+    await fill();
+  }
+  return { settled, admitted, rejected, stopReason, peakLive };
+}
+function freeSlots(liveCount, cap) {
+  if (cap === void 0 || cap <= 0) return null;
+  return Math.max(0, cap - liveCount);
+}
+function effectiveConcurrency(caps) {
+  const applicable = [caps.maxLiveWorkers, caps.maxSandboxes].filter(
+    (c) => typeof c === "number" && c > 0
+  );
+  if (applicable.length === 0) return void 0;
+  return Math.min(...applicable);
+}
+function queueOf(units, budget) {
+  let i = 0;
+  return () => {
+    const u = units[i];
+    if (u === void 0) return void 0;
+    i += 1;
+    return { agent: u.agent, task: u.task, opts: { budget, label: u.label } };
+  };
+}
 
 // src/runtime/supervise/event-bus.ts
 function createEventBus(now = Date.now) {
@@ -2370,12 +3255,12 @@ function createCoordinationTools(opts) {
     bus.subscribe((rec) => cb(rec.event));
   }
   const urgencyPriority = (u) => u === "blocks-run" ? 20 : u === "blocks-step" ? 10 : 0;
-  const str = (v, field) => {
+  const str2 = (v, field) => {
     if (typeof v !== "string" || v.length === 0)
       throw new Error(`coordination tools: "${field}" must be a non-empty string`);
     return v;
   };
-  const obj = (raw) => {
+  const obj2 = (raw) => {
     if (!raw || typeof raw !== "object")
       throw new Error("coordination tools: arguments must be an object");
     return raw;
@@ -2413,14 +3298,17 @@ function createCoordinationTools(opts) {
     );
   };
   const recordSettled = (s) => {
+    const settledAt = Date.now();
     const w = s.kind === "done" ? {
       id: s.handle.id,
       status: "done",
       score: s.verdict?.score ?? 0,
       valid: s.verdict?.valid ?? false,
-      outRef: s.outRef
-    } : { id: s.handle.id, status: "down", reason: s.reason };
+      outRef: s.outRef,
+      settledAt
+    } : { id: s.handle.id, status: "down", reason: s.reason, settledAt };
     ledger.push(w);
+    unwatchWorker(w.id);
     return w;
   };
   const drainSettlement = async () => {
@@ -2449,7 +3337,7 @@ function createCoordinationTools(opts) {
   };
   async function sendDown(type, down, questionId) {
     await bus.publish(
-      type === "answer" ? { type, down, questionId: str(questionId, "questionId") } : { type, down },
+      type === "answer" ? { type, down, questionId: str2(questionId, "questionId") } : { type, down },
       { queue: false }
     );
   }
@@ -2472,13 +3360,13 @@ function createCoordinationTools(opts) {
   };
   const nextQuestionId = (from) => `${from}:q${questionSeq++}`;
   const normalizeQuestion = (q, fallbackFrom) => {
-    const from = str(q.from ?? fallbackFrom, "from");
+    const from = str2(q.from ?? fallbackFrom, "from");
     return {
       id: typeof q.id === "string" && q.id.length > 0 ? q.id : nextQuestionId(from),
       from,
       level: level(q.level),
-      question: str(q.question, "question"),
-      reason: str(q.reason, "reason"),
+      question: str2(q.question, "question"),
+      reason: str2(q.reason, "reason"),
       ...q.options ? { options: q.options } : {},
       urgency: urgency(q.urgency)
     };
@@ -2532,6 +3420,69 @@ function createCoordinationTools(opts) {
   const isLive = (status) => status !== "done" && status !== "failed" && status !== "cancelled";
   const liveWorkerCount = () => opts.scope.view.nodes.filter((n) => isLive(n.status)).length;
   const liveSnapshot = () => opts.scope.view.nodes.filter((n) => isLive(n.status)).map((n) => ({ id: n.id, status: n.status, spent: n.spent }));
+  const freeWorkerSlots = () => freeSlots(liveWorkerCount(), maxLiveWorkers);
+  const readProgress = (id) => {
+    const scope = opts.scope;
+    if (typeof scope.progress !== "function") return void 0;
+    try {
+      return scope.progress(
+        id,
+        opts.stallAfterMs !== void 0 ? { stallAfterMs: opts.stallAfterMs } : {}
+      );
+    } catch {
+      return void 0;
+    }
+  };
+  const watchers = /* @__PURE__ */ new Map();
+  const watchWorker = (id) => {
+    const watch = opts.watchWorkers;
+    if (!watch) return;
+    const scope = opts.scope;
+    if (typeof scope.traceSource !== "function") return;
+    let source;
+    try {
+      source = scope.traceSource(id);
+    } catch {
+      return;
+    }
+    if (!source) return;
+    const cap = watch.maxFindingsPerWorker ?? 3;
+    let raised = 0;
+    const unsub = watchTrace(source, {
+      ...watch.detectors ? { detectors: watch.detectors } : {},
+      onSignal: async (signal, span) => {
+        if (cap > 0 && raised >= cap) return;
+        raised += 1;
+        await bus.publish({
+          type: "finding",
+          finding: {
+            fromWorker: id,
+            analyst: `online:${signal.detector}`,
+            findings: {
+              detector: signal.detector,
+              severity: signal.severity,
+              reason: signal.reason,
+              streak: signal.streak,
+              ...signal.failureClass ? { failureClass: signal.failureClass } : {},
+              toolName: span.toolName,
+              at: span.endedAt,
+              progress: readProgress(id)
+            }
+          }
+        });
+      }
+    });
+    watchers.set(id, unsub);
+  };
+  const unwatchWorker = (id) => {
+    const unsub = watchers.get(id);
+    if (!unsub) return;
+    watchers.delete(id);
+    try {
+      unsub();
+    } catch {
+    }
+  };
   const awaitTimeoutMs = opts.awaitTimeoutMs ?? DEFAULT_AWAIT_EVENT_TIMEOUT_MS;
   let inFlightDrain = null;
   const ensureDrain = () => {
@@ -2557,7 +3508,7 @@ function createCoordinationTools(opts) {
   const tools = [
     {
       name: "spawn_agent",
-      description: 'Start a worker the driver will drive. `profile` is the worker or another driver; `task` is what it should do. Reserves budget from the conserved pool and fails closed. Pass an optional `budget` (per-field) to give a hard sub-task more than the default \u2014 it merges over the per-worker default; the conserved pool is still the hard fence. When a max-live-workers cap is set it also fails closed (`error: "max-live-workers"`) while that many workers are still in flight \u2014 settle or steer one before spawning another.',
+      description: 'Start a worker the driver will drive. `profile` is the worker or another driver; `task` is what it should do. Reserves budget from the conserved pool and fails closed. Pass an optional `budget` (per-field) to give a hard sub-task more than the default \u2014 it merges over the per-worker default; the conserved pool is still the hard fence. When a max-live-workers cap is set it also fails closed (`error: "max-live-workers"`) while that many workers are still in flight \u2014 settle or steer one before spawning another. Returns `freeSlots`: how many MORE workers you can start right now (`null` = uncapped). While `freeSlots > 0` there is idle capacity \u2014 call this again to fill it rather than waiting; parallel workers finish the run sooner than one at a time.',
       inputSchema: {
         type: "object",
         properties: {
@@ -2578,32 +3529,41 @@ function createCoordinationTools(opts) {
         required: ["profile", "task"]
       },
       handler: (raw) => {
-        const a = obj(raw);
+        const a = obj2(raw);
         if (maxLiveWorkers !== void 0 && maxLiveWorkers > 0 && liveWorkerCount() >= maxLiveWorkers)
-          return Promise.resolve({ error: "max-live-workers" });
+          return Promise.resolve({
+            error: "max-live-workers",
+            live: liveWorkerCount(),
+            freeSlots: freeWorkerSlots()
+          });
         const agent = opts.makeWorkerAgent(a.profile);
         const budget = a.budget === void 0 ? opts.perWorker : mergeBudget(opts.perWorker, a.budget);
         const res = opts.scope.spawn(agent, a.task, {
           budget,
           label: typeof a.label === "string" ? a.label : "worker"
         });
-        return Promise.resolve(res.ok ? { workerId: res.handle.id } : { error: res.reason });
+        if (res.ok) watchWorker(res.handle.id);
+        return Promise.resolve(
+          res.ok ? { workerId: res.handle.id, live: liveWorkerCount(), freeSlots: freeWorkerSlots() } : { error: res.reason, live: liveWorkerCount(), freeSlots: freeWorkerSlots() }
+        );
       }
     },
     {
       name: "observe_agent",
-      description: "Inspect a worker status, spend, and settled output artifact when available.",
+      description: "Inspect a worker WHILE IT RUNS, not only after it finishes: status, spend so far, and `progress` \u2014 how long since it last did anything (`idleMs`), whether that counts as stalled, how many turns it has taken, the last tools/files it touched (`recentActivity`), whether a steer can even reach it (`steerable`), and how many steers it has not yet read (`pendingMessages`). Returns the settled output artifact once it exists. Use this BEFORE steer_agent: a steer is only worth sending when the progress says the worker is on the wrong path or has stopped making any.",
       inputSchema: { type: "object", properties: { workerId: idArg }, required: ["workerId"] },
       handler: async (raw) => {
-        const id = str(obj(raw).workerId, "workerId");
+        const id = str2(obj2(raw).workerId, "workerId");
         const node = opts.scope.view.nodes.find((n) => n.id === id);
         if (!node) return { error: `unknown workerId ${JSON.stringify(id)}` };
         const output = node.outRef ? await opts.blobs.get(node.outRef) : void 0;
+        const progress = readProgress(id);
         return {
           status: node.status,
           spent: node.spent,
           outRef: node.outRef ?? null,
-          output: output ?? null
+          output: output ?? null,
+          progress: progress ?? null
         };
       }
     },
@@ -2623,18 +3583,21 @@ function createCoordinationTools(opts) {
         required: ["workerId", "instruction"]
       },
       handler: async (raw) => {
-        const a = obj(raw);
-        const workerId = str(a.workerId, "workerId");
-        const instruction = str(a.instruction, "instruction");
+        const a = obj2(raw);
+        const workerId = str2(a.workerId, "workerId");
+        const instruction = str2(a.instruction, "instruction");
         const interrupt = a.interrupt === true;
         const delivered = opts.scope.send(workerId, { steer: instruction, interrupt });
         await sendDown("steer", { toWorker: workerId, instruction, delivered });
-        return { delivered };
+        if (delivered) return { delivered, progress: readProgress(workerId) ?? null };
+        const progress = readProgress(workerId);
+        const reason2 = !progress ? "unknown-worker" : !progress.live ? "already-settled" : "runtime-has-no-inbox";
+        return { delivered, reason: reason2, progress: progress ?? null };
       }
     },
     {
       name: "await_event",
-      description: "Wait for and pull the next message a worker, sub-driver, or analyst sent up \u2014 the unified inbox. An event is one of: a settled worker output ('settled'), a question needing your answer ('question', from ask_parent / the worker's ask-user), or a trace-analyst finding ('finding', from analyze-on-settle). Pass kinds:['settled'] for just the next finished worker; omit `kinds` to also receive questions and findings. Returns { idle: true } when nothing is queued and no workers are live. If a worker is still running when the wait elapses, returns { pending: true, live: [...] } (the workers still in flight) instead of blocking indefinitely \u2014 call await_event again to keep waiting; the settlement is not lost.",
+      description: "Wait for and pull the next message a worker, sub-driver, or analyst sent up \u2014 the unified inbox. An event is one of: a settled worker output ('settled'), a question needing your answer ('question', from ask_parent / the worker's ask-user), or a trace-analyst finding ('finding', from analyze-on-settle). Pass kinds:['settled'] for just the next finished worker; omit `kinds` to also receive questions and findings. Returns { idle: true } when nothing is queued and no workers are live. If a worker is still running when the wait elapses, returns { pending: true, live: [...] } (the workers still in flight) instead of blocking indefinitely \u2014 call await_event again to keep waiting; the settlement is not lost. Every reply carries `freeSlots`: how many more workers you can start right now (`null` = uncapped). A settled worker frees its slot, so `freeSlots > 0` means capacity is sitting idle \u2014 spawn into it before waiting again.",
       inputSchema: {
         type: "object",
         properties: {
@@ -2646,15 +3609,16 @@ function createCoordinationTools(opts) {
         }
       },
       handler: async (raw) => {
-        const k = obj(raw).kinds;
+        const k = obj2(raw).kinds;
         const kinds = Array.isArray(k) ? k.filter((x) => x === "settled" || x === "question" || x === "finding") : void 0;
         let ev = bus.pull(kinds);
-        if (ev) return projectEvent(ev);
+        if (ev) return { ...projectEvent(ev), freeSlots: freeWorkerSlots() };
         const raced = await raceDrainWithTimeout(ensureDrain());
-        if (raced === void 0) return { pending: true, live: liveSnapshot() };
+        if (raced === void 0)
+          return { pending: true, live: liveSnapshot(), freeSlots: freeWorkerSlots() };
         ev = bus.pull(kinds);
-        if (!ev) return { idle: !raced.drained };
-        return projectEvent(ev);
+        if (!ev) return { idle: !raced.drained, freeSlots: freeWorkerSlots() };
+        return { ...projectEvent(ev), freeSlots: freeWorkerSlots() };
       }
     },
     {
@@ -2679,8 +3643,8 @@ function createCoordinationTools(opts) {
         required: ["questionId"]
       },
       handler: async (raw) => {
-        const a = obj(raw);
-        const questionId = str(a.questionId, "questionId");
+        const a = obj2(raw);
+        const questionId = str2(a.questionId, "questionId");
         if (typeof a.answer === "string" && a.answer.length > 0) {
           const answer = a.answer;
           const question = decideQuestion(questionId, {
@@ -2733,15 +3697,15 @@ function createCoordinationTools(opts) {
         required: ["from", "level", "question", "reason", "urgency"]
       },
       handler: async (raw) => {
-        const a = obj(raw);
-        const from = str(a.from, "from");
+        const a = obj2(raw);
+        const from = str2(a.from, "from");
         const q = await emitNewQuestion(
           addQuestion(
             {
               from,
               level: level(a.level),
-              question: str(a.question, "question"),
-              reason: str(a.reason, "reason"),
+              question: str2(a.question, "question"),
+              reason: str2(a.reason, "reason"),
               urgency: urgency(a.urgency)
             },
             from,
@@ -2768,7 +3732,7 @@ function createCoordinationTools(opts) {
           });
         }
         stopped = true;
-        const r = obj(raw).reason;
+        const r = obj2(raw).reason;
         reason = typeof r === "string" ? r : void 0;
         return Promise.resolve({ stopped: true });
       }
@@ -2793,14 +3757,14 @@ function createCoordinationTools(opts) {
         required: ["kind", "workerId"]
       },
       handler: async (raw) => {
-        const a = obj(raw);
-        const id = str(a.workerId, "workerId");
+        const a = obj2(raw);
+        const id = str2(a.workerId, "workerId");
         const node = opts.scope.view.nodes.find((n) => n.id === id);
         if (!node) return { error: `unknown workerId ${JSON.stringify(id)}` };
         if (!node.outRef)
           return { error: `worker ${JSON.stringify(id)} has not settled \u2014 no trace to analyze yet` };
         const trace = await opts.blobs.get(node.outRef);
-        return { findings: await opts.analysts?.run(str(a.kind, "kind"), trace) };
+        return { findings: await opts.analysts?.run(str2(a.kind, "kind"), trace) };
       }
     });
   }
@@ -2817,6 +3781,287 @@ function createCoordinationTools(opts) {
   };
 }
 
+// src/runtime/anytime.ts
+function bestSoFar(values) {
+  const out = [];
+  let best = 0;
+  for (const v of values) {
+    if (typeof v === "number" && v > best) best = v;
+    out.push(best);
+  }
+  return out;
+}
+function areaUnderCurve(curve) {
+  if (curve.length === 0) return 0;
+  return curve.reduce((s, v) => s + v, 0) / curve.length;
+}
+function plateauLength(curve, minDelta) {
+  if (curve.length === 0) return 0;
+  const last = curve[curve.length - 1];
+  let i = curve.length - 1;
+  while (i > 0 && last - curve[i - 1] <= minDelta) i -= 1;
+  return curve.length - 1 - i;
+}
+var median = (xs) => {
+  if (xs.length === 0) return null;
+  const s = [...xs].sort((a, b) => a - b);
+  const mid = Math.floor(s.length / 2);
+  return s.length % 2 === 1 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+};
+function anytimeReport(spans, opts) {
+  const targets = opts?.targets ?? [1];
+  const byRun = /* @__PURE__ */ new Map();
+  for (const s of spans) {
+    if (!s.label.startsWith("shot:")) continue;
+    const list = byRun.get(s.runId) ?? [];
+    list.push(s);
+    byRun.set(s.runId, list);
+  }
+  const perTask = [];
+  for (const [runId, shots] of byRun) {
+    const m = runId.match(/^agentic:(.+):(.+)$/);
+    const strategy = m?.[1] ?? runId;
+    const taskId = m?.[2] ?? runId;
+    const ordered = [...shots].sort((a, b) => (a.endMs ?? a.startMs) - (b.endMs ?? b.startMs));
+    const t0 = Math.min(...ordered.map((s) => s.startMs));
+    const taskTargets = opts?.targetFor ? [opts.targetFor(taskId)] : targets;
+    const bests = bestSoFar(ordered.map((s) => typeof s.score === "number" ? s.score : void 0));
+    let cumUsd = 0;
+    const points = [];
+    const hits = {};
+    for (const t of taskTargets) hits[String(t)] = null;
+    for (const [i, s] of ordered.entries()) {
+      cumUsd += s.usd;
+      const best = bests[i];
+      const elapsedMs = (s.endMs ?? s.startMs) - t0;
+      points.push({ elapsedMs, cumUsd, best });
+      for (const t of taskTargets) {
+        if (hits[String(t)] === null && best >= t) {
+          hits[String(t)] = { ms: elapsedMs, shots: points.length, usd: cumUsd };
+        }
+      }
+    }
+    perTask.push({ taskId, strategy, points, hits });
+  }
+  const byStrategy = /* @__PURE__ */ new Map();
+  for (const t of perTask) {
+    const list = byStrategy.get(t.strategy) ?? [];
+    list.push(t);
+    byStrategy.set(t.strategy, list);
+  }
+  const perStrategy = [];
+  for (const [strategy, tasks] of byStrategy) {
+    const totalMs = tasks.reduce((s, t) => s + (t.points[t.points.length - 1]?.elapsedMs ?? 0), 0);
+    const totalUsd = tasks.reduce((s, t) => s + (t.points[t.points.length - 1]?.cumUsd ?? 0), 0);
+    const maxShots = Math.max(0, ...tasks.map((t) => t.points.length));
+    const curveByShot = [];
+    for (let i = 0; i < maxShots; i += 1) {
+      const vals = tasks.map(
+        (t) => t.points[Math.min(i, t.points.length - 1)].best
+      );
+      curveByShot.push(vals.reduce((s, v) => s + v, 0) / vals.length);
+    }
+    const auc = areaUnderCurve(curveByShot);
+    const summaryTargets = opts?.targetFor ? [Number.NaN] : targets;
+    for (const t of summaryTargets) {
+      const key = (taskCurve) => opts?.targetFor ? Object.values(taskCurve.hits)[0] ?? null : taskCurve.hits[String(t)] ?? null;
+      const reached = tasks.filter((x) => key(x) !== null);
+      perStrategy.push({
+        strategy,
+        target: t,
+        tasks: tasks.length,
+        reachedTarget: reached.length,
+        medianTttMs: median(reached.map((x) => key(x).ms)),
+        medianShotsToTarget: median(reached.map((x) => key(x).shots)),
+        ertMs: reached.length > 0 ? totalMs / reached.length : null,
+        erUsd: reached.length > 0 ? totalUsd / reached.length : null,
+        curveByShot,
+        auc
+      });
+    }
+  }
+  perStrategy.sort((a, b) => a.strategy.localeCompare(b.strategy) || a.target - b.target);
+  return { targets, perTask, perStrategy };
+}
+function renderAnytimeTable(report) {
+  const lines = [
+    `anytime metrics \xB7 satisficing targets [${report.targets.join(", ")}] \xB7 ERT = \u03A3 all wall-time / #successes (COCO)`,
+    "strategy            \u2265tgt   reach   med-TTT   med-shots   ERT(all-in)   $/success   AUC   curve"
+  ];
+  for (const s of report.perStrategy) {
+    const curve = s.curveByShot.map((v) => "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588"[Math.min(7, Math.floor(v * 8))]).join("");
+    const tgt = Number.isNaN(s.target) ? "task" : s.target.toFixed(2);
+    lines.push(
+      `${s.strategy.padEnd(19)} ${tgt.padStart(4)} ${String(s.reachedTarget).padStart(4)}/${String(s.tasks).padEnd(3)} ${s.medianTttMs === null ? "      \u2014" : `${(s.medianTttMs / 1e3).toFixed(1).padStart(6)}s`}   ${s.medianShotsToTarget === null ? "    \u2014" : String(s.medianShotsToTarget).padStart(5)}   ${s.ertMs === null ? "         \u2014" : `${(s.ertMs / 1e3).toFixed(1).padStart(9)}s`}   ${s.erUsd === null ? "       \u2014" : `$${s.erUsd.toFixed(4)}`}   ${s.auc.toFixed(2)}   ${curve}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/runtime/supervise/stop-rules.ts
+var CONTINUE = { stop: false };
+function createProgressTracker(opts = {}) {
+  const now = opts.now ?? Date.now;
+  const requireDelivered = opts.requireDelivered ?? true;
+  const minImprovement = opts.minImprovement ?? 0;
+  const seen = /* @__PURE__ */ new Set();
+  const recorded = [];
+  return {
+    record(sample) {
+      if (seen.has(sample.id)) return false;
+      seen.add(sample.id);
+      recorded.push(sample);
+      return true;
+    },
+    samples: () => [...recorded],
+    view(scope, viewOpts) {
+      const objectives = recorded.map(
+        (s) => requireDelivered && !s.delivered ? void 0 : s.objective
+      );
+      const curve = bestSoFar(objectives);
+      const best = curve.length > 0 ? curve[curve.length - 1] : 0;
+      let lastImprovementAt = 0;
+      let lastImprovementIdx = -1;
+      let prev = 0;
+      for (const [i, value] of curve.entries()) {
+        if (value - prev > minImprovement) {
+          lastImprovementAt = recorded[i].at;
+          lastImprovementIdx = i;
+        }
+        prev = value;
+      }
+      const treeView = scope?.view;
+      const workers = [];
+      if (scope && treeView) {
+        for (const node of treeView.nodes) {
+          if (node.status === "done" || node.status === "failed" || node.status === "cancelled") {
+            continue;
+          }
+          if (node.status === "waiting") continue;
+          const p = scope.progress(
+            node.id,
+            viewOpts?.stallAfterMs !== void 0 ? { now: now(), stallAfterMs: viewOpts.stallAfterMs } : { now: now() }
+          );
+          if (p) workers.push(p);
+        }
+      }
+      return {
+        now: now(),
+        settles: recorded.length,
+        delivered: recorded.filter((s) => s.delivered).length,
+        curve,
+        best,
+        auc: areaUnderCurve(curve),
+        lastSettleAt: recorded.length > 0 ? recorded[recorded.length - 1].at : 0,
+        lastImprovementAt,
+        settlesSinceImprovement: lastImprovementIdx < 0 ? recorded.length : recorded.length - 1 - lastImprovementIdx,
+        workers,
+        inFlight: treeView?.inFlight ?? 0,
+        waiting: treeView?.waiting ?? 0
+      };
+    },
+    evaluate(rule, scope, viewOpts) {
+      return rule(this.view(scope, viewOpts));
+    }
+  };
+}
+function sampleFromSettled(settled, at) {
+  if (settled.kind === "down") {
+    return { id: settled.handle.id, at, delivered: false };
+  }
+  return {
+    id: settled.handle.id,
+    at,
+    ...settled.verdict?.score !== void 0 ? { objective: settled.verdict.score } : {},
+    delivered: settled.verdict?.valid === true
+  };
+}
+function noProgressFor(opts) {
+  if (opts.ms === void 0 && opts.settles === void 0) {
+    throw new ValidationError("noProgressFor: set at least one of { ms, settles }");
+  }
+  if (opts.ms !== void 0 && opts.ms <= 0) {
+    throw new ValidationError("noProgressFor: ms must be > 0");
+  }
+  if (opts.settles !== void 0 && opts.settles < 1) {
+    throw new ValidationError("noProgressFor: settles must be >= 1");
+  }
+  const minSettles = opts.minSettles ?? 1;
+  return (v) => {
+    if (v.settles < minSettles) return CONTINUE;
+    if (opts.settles !== void 0 && v.settlesSinceImprovement >= opts.settles) {
+      return {
+        stop: true,
+        reason: `no-progress: ${v.settlesSinceImprovement} settles with no improvement (limit ${opts.settles}), best=${v.best}`
+      };
+    }
+    if (opts.ms !== void 0 && v.waiting === 0 && v.lastSettleAt > 0) {
+      const idle = v.now - v.lastSettleAt;
+      if (idle >= opts.ms) {
+        return {
+          stop: true,
+          reason: `no-progress: ${idle}ms since the last settlement (limit ${opts.ms}ms)`
+        };
+      }
+    }
+    return CONTINUE;
+  };
+}
+function plateau(opts) {
+  if (!Number.isInteger(opts.window) || opts.window < 1) {
+    throw new ValidationError("plateau: window must be a positive integer");
+  }
+  if (!Number.isFinite(opts.minDelta) || opts.minDelta < 0) {
+    throw new ValidationError("plateau: minDelta must be >= 0");
+  }
+  const minSettles = opts.minSettles ?? opts.window;
+  return (v) => {
+    if (v.settles < minSettles) return CONTINUE;
+    const flat = plateauLength(v.curve, opts.minDelta);
+    if (flat >= opts.window) {
+      return {
+        stop: true,
+        reason: `plateau: best-so-far rose <= ${opts.minDelta} over the last ${flat} settles (window ${opts.window}), best=${v.best}, auc=${v.auc.toFixed(3)}`
+      };
+    }
+    return CONTINUE;
+  };
+}
+function allWorkersStalled(opts = {}) {
+  const minWorkers = opts.minWorkers ?? 1;
+  return (v) => {
+    if (v.waiting > 0) return CONTINUE;
+    if (v.workers.length < minWorkers) return CONTINUE;
+    if (!v.workers.every((w) => w.stalled)) return CONTINUE;
+    const worst = Math.max(...v.workers.map((w) => w.idleMs));
+    return {
+      stop: true,
+      reason: `all-stalled: ${v.workers.length} live workers idle, worst ${worst}ms`
+    };
+  };
+}
+function anyOf(...rules) {
+  return (v) => {
+    for (const rule of rules) {
+      const d = rule(v);
+      if (d.stop) return d;
+    }
+    return CONTINUE;
+  };
+}
+function allOf(...rules) {
+  if (rules.length === 0) throw new ValidationError("allOf: needs at least one rule");
+  return (v) => {
+    const reasons = [];
+    for (const rule of rules) {
+      const d = rule(v);
+      if (!d.stop) return CONTINUE;
+      reasons.push(d.reason);
+    }
+    return { stop: true, reason: reasons.join(" AND ") };
+  };
+}
+
 // src/runtime/supervise/coordination-driver.ts
 var distillInstruction = "CONTEXT COMPACTION. Your detailed turn-by-turn history is about to be discarded to free your context window. Write a COMPLETE, compact handoff note for your future self so you can keep going without it. Cover: (1) what you have accomplished; (2) every worker you spawned and its current status/result; (3) what subtasks remain unfinished, failing, or unverified \u2014 be specific and exhaustive here, this is the part you must not lose; (4) your immediate next action. Do not call any tools; respond with the note only.";
 function summarizeRoster(view, settled) {
@@ -2842,6 +4087,17 @@ function deadlinePassed(scope, now) {
   const b = scope.budget;
   return b.deadlineMs > 0 && now() >= b.deadlineMs;
 }
+function progressStop(tracker, rule, coord, scope, now, stallAfterMs) {
+  for (const w of coord.settled()) {
+    tracker.record({
+      id: w.id,
+      at: w.settledAt ?? now(),
+      ...w.score !== void 0 ? { objective: w.score } : {},
+      delivered: w.status === "done" && w.valid === true
+    });
+  }
+  return tracker.evaluate(rule, scope, stallAfterMs !== void 0 ? { stallAfterMs } : void 0);
+}
 function driverAgent(opts) {
   if (typeof opts.brain !== "function") {
     throw new ValidationError("driverAgent: opts.brain must be a function");
@@ -2881,7 +4137,9 @@ function driverAgent(opts) {
         perWorker: opts.perWorker,
         ...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {},
         ...opts.analysts ? { analysts: opts.analysts } : {},
-        ...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {}
+        ...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
+        ...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
+        ...opts.stallAfterMs !== void 0 ? { stallAfterMs: opts.stallAfterMs } : {}
       });
       const byName = new Map(coord.tools.map((t) => [t.name, t]));
       const toolSpecs = [
@@ -2896,6 +4154,8 @@ function driverAgent(opts) {
         }))
       ];
       const system = typeof opts.systemPrompt === "function" ? opts.systemPrompt(task) : opts.systemPrompt;
+      const tracker = opts.stopRule ? createProgressTracker({ now }) : void 0;
+      let progressStopReason;
       let driverTurn = 0;
       const meteredBrain = async (messages, tools, detail) => {
         const res = await opts.brain(messages, tools);
@@ -2971,7 +4231,26 @@ Summary unavailable: ${errMessage(e)}`;
         // that can no longer spawn (pool starved) or has run past the deadline stops here instead of
         // burning turns. Checked before each inference turn.
         hooks: {
-          stopBefore: () => coord.isStopped() || scope.signal.aborted || poolStarved(scope, opts.perWorker) || deadlinePassed(scope, now)
+          stopBefore: () => {
+            if (coord.isStopped() || scope.signal.aborted || poolStarved(scope, opts.perWorker) || deadlinePassed(scope, now)) {
+              return true;
+            }
+            if (!opts.stopRule || !tracker) return false;
+            const decision = progressStop(
+              tracker,
+              opts.stopRule,
+              coord,
+              scope,
+              now,
+              opts.stallAfterMs
+            );
+            if (!decision.stop) return false;
+            if (progressStopReason === void 0) {
+              progressStopReason = decision.reason;
+              opts.onProgressStop?.(decision.reason);
+            }
+            return true;
+          }
         }
       });
       await coord.drainResolved();
@@ -3755,15 +5034,15 @@ function randomTaskId() {
   return `dlg-${t}-${r}`;
 }
 function hashIdempotencyInput(value) {
-  let str;
+  let str2;
   try {
-    str = JSON.stringify(canonicalize(value));
+    str2 = JSON.stringify(canonicalize(value));
   } catch {
-    str = String(value);
+    str2 = String(value);
   }
   let h = 2166136261;
-  for (let i = 0; i < str.length; i += 1) {
-    h ^= str.charCodeAt(i);
+  for (let i = 0; i < str2.length; i += 1) {
+    h ^= str2.charCodeAt(i);
     h = Math.imul(h, 16777619);
   }
   return (h >>> 0).toString(16).padStart(8, "0");
@@ -4774,6 +6053,8 @@ async function serveCoordinationMcp(opts) {
     ...opts.awaitTimeoutMs !== void 0 ? { awaitTimeoutMs: opts.awaitTimeoutMs } : {},
     ...opts.analysts ? { analysts: opts.analysts } : {},
     ...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
+    ...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
+    ...opts.stallAfterMs !== void 0 ? { stallAfterMs: opts.stallAfterMs } : {},
     ...opts.onEvent ? { onEvent: opts.onEvent } : {},
     ...opts.questionPolicy ? { questionPolicy: opts.questionPolicy } : {}
   });
@@ -4876,6 +6157,10 @@ function supervisorAgent(profile, deps) {
       ...deps.executeExtraTool ? { executeExtraTool: deps.executeExtraTool } : {},
       ...deps.analysts ? { analysts: deps.analysts } : {},
       ...deps.analyzeOnSettle ? { analyzeOnSettle: deps.analyzeOnSettle } : {},
+      ...deps.watchWorkers ? { watchWorkers: deps.watchWorkers } : {},
+      ...deps.stallAfterMs !== void 0 ? { stallAfterMs: deps.stallAfterMs } : {},
+      ...deps.stopRule ? { stopRule: deps.stopRule } : {},
+      ...deps.onProgressStop ? { onProgressStop: deps.onProgressStop } : {},
       ...deps.maxTurns !== void 0 ? { maxTurns: deps.maxTurns } : {},
       ...deps.compaction ? { compaction: deps.compaction } : {}
     });
@@ -4896,7 +6181,9 @@ function supervisorAgent(profile, deps) {
         perWorker: deps.perWorker,
         ...deps.maxLiveWorkers !== void 0 ? { maxLiveWorkers: deps.maxLiveWorkers } : {},
         ...deps.analysts ? { analysts: deps.analysts } : {},
-        ...deps.analyzeOnSettle ? { analyzeOnSettle: deps.analyzeOnSettle } : {}
+        ...deps.analyzeOnSettle ? { analyzeOnSettle: deps.analyzeOnSettle } : {},
+        ...deps.watchWorkers ? { watchWorkers: deps.watchWorkers } : {},
+        ...deps.stallAfterMs !== void 0 ? { stallAfterMs: deps.stallAfterMs } : {}
       });
       try {
         await driveHarness({ profile, task, scope, coordinationMcpUrl: mcp.url });
@@ -4943,7 +6230,7 @@ function supervise(profile, task, opts) {
     typeof backendModel === "string" ? backendModel : void 0,
     opts.allowedModels
   );
-  const ctx = createInMemoryRunContext({ withDriver: true });
+  const ctx = opts.runDir !== void 0 ? createFileRunContext(opts.runDir, { withDriver: true }) : createInMemoryRunContext({ withDriver: true });
   const blobs = opts.blobs ?? ctx.blobs;
   const perWorker = opts.perWorker ?? defaultPerWorker(opts.budget);
   let makeWorkerAgent = opts.makeWorkerAgent;
@@ -4967,16 +6254,22 @@ function supervise(profile, task, opts) {
     ...opts.executeExtraTool ? { executeExtraTool: opts.executeExtraTool } : {},
     ...opts.analysts ? { analysts: opts.analysts } : {},
     ...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
+    ...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
+    ...opts.stallAfterMs !== void 0 ? { stallAfterMs: opts.stallAfterMs } : {},
+    ...opts.stopRule ? { stopRule: opts.stopRule } : {},
+    ...opts.onProgressStop ? { onProgressStop: opts.onProgressStop } : {},
     ...opts.maxTurns !== void 0 ? { maxTurns: opts.maxTurns } : {},
     ...opts.compaction ? { compaction: opts.compaction } : {}
   });
   return createSupervisor().run(agent, task, {
     budget: opts.budget,
     runId: opts.runId ?? "supervise",
-    journal: ctx.journal,
+    journal: opts.journal ?? ctx.journal,
     blobs,
     executors: ctx.executors,
     maxDepth: opts.maxDepth ?? 8,
+    ...opts.probes ? { probes: opts.probes } : {},
+    ...ctx.resume === true ? { resume: true } : {},
     ...opts.now ? { now: opts.now } : {}
   });
 }
@@ -5021,13 +6314,40 @@ export {
   createSandboxForSpec,
   defaultSelectWinner,
   createInbox,
+  decodeToolPart,
+  createPushTraceSource,
+  sandboxSessionTraceSource,
+  PI_RUNTIME,
+  piSeamKey,
+  piExecutor,
+  DEFAULT_SANDBOX_STEERING_MAX_TURNS,
+  createSteerableSandboxSession,
   createWorktreeCliExecutor,
   cliWorktreeExecutor,
   createExecutor,
   createExecutorRegistry,
   createInMemoryRunContext,
+  createFileRunContext,
+  defaultToolDetectors,
+  watchTrace,
+  rollingDispatch,
+  freeSlots,
+  effectiveConcurrency,
+  queueOf,
   createEventBus,
   createCoordinationTools,
+  bestSoFar,
+  areaUnderCurve,
+  plateauLength,
+  anytimeReport,
+  renderAnytimeTable,
+  createProgressTracker,
+  sampleFromSettled,
+  noProgressFor,
+  plateau,
+  allWorkersStalled,
+  anyOf,
+  allOf,
   driverAgent,
   finalizeBestDelivered,
   InMemoryFeedbackStore,
@@ -5084,4 +6404,4 @@ export {
   workerFromBackend,
   supervise
 };
-//# sourceMappingURL=chunk-ZUCUAFVF.js.map
+//# sourceMappingURL=chunk-EAQ5YRRY.js.map