@tangle-network/agent-runtime 0.43.0 → 0.45.0

package/dist/chunk-KEWO4KI6.js

@@ -0,0 +1,3599 @@
+import {
+  AnalystError,
+  PlannerError,
+  RuntimeRunStateError,
+  ValidationError,
+  addTokenUsage,
+  deleteBoxSafe,
+  extractLlmCallEvent,
+  mapWithConcurrency,
+  randomSuffix,
+  randomUuid,
+  sleep,
+  stringifySafe,
+  throwAbort,
+  throwIfAborted,
+  withTimeout,
+  zeroTokenUsage
+} from "./chunk-PRX45WE2.js";
+
+// src/durable/spawn-journal.ts
+import { createHash } from "crypto";
+function contentAddress(artifact) {
+  const hex = createHash("sha256").update(stableStringify(artifact), "utf-8").digest("hex");
+  return `sha256:${hex}`;
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+}
+var InMemoryResultBlobStore = class {
+  blobs = /* @__PURE__ */ new Map();
+  async put(outRef, artifact) {
+    assertContentAddress(outRef, artifact);
+    this.blobs.set(outRef, artifact);
+  }
+  async get(outRef) {
+    return this.blobs.has(outRef) ? this.blobs.get(outRef) : void 0;
+  }
+};
+var FileResultBlobStore = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  async put(outRef, artifact) {
+    assertContentAddress(outRef, artifact);
+    const fs = await import("fs/promises");
+    await fs.mkdir(this.dir, { recursive: true });
+    const fh = await fs.open(this.blobPath(outRef), "w");
+    try {
+      await fh.write(JSON.stringify(artifact));
+      await fh.sync();
+    } finally {
+      await fh.close();
+    }
+  }
+  async get(outRef) {
+    const fs = await import("fs/promises");
+    let text;
+    try {
+      text = await fs.readFile(this.blobPath(outRef), "utf8");
+    } catch (err) {
+      if (isNoEntError(err)) return void 0;
+      throw err;
+    }
+    return JSON.parse(text);
+  }
+  blobPath(outRef) {
+    return `${this.dir}/${outRef.replace(/:/g, "-")}.json`;
+  }
+};
+function assertContentAddress(outRef, artifact) {
+  const expected = contentAddress(artifact);
+  if (outRef !== expected) {
+    throw new Error(
+      `blob outRef '${outRef}' does not match the artifact content hash '${expected}'; a content-addressed store refuses a mismatched ref (breaks the replay invariant)`
+    );
+  }
+}
+var InMemorySpawnJournal = class {
+  trees = /* @__PURE__ */ new Map();
+  async loadTree(root) {
+    const tree = this.trees.get(root);
+    if (!tree) return void 0;
+    return tree.events.map((ev) => ({ ...ev }));
+  }
+  async beginTree(root, at) {
+    const existing = this.trees.get(root);
+    if (existing) {
+      if (existing.begunAt !== at) {
+        throw new Error(
+          `spawn tree '${root}' already begun at ${existing.begunAt}; refusing to overwrite with ${at}`
+        );
+      }
+      return;
+    }
+    this.trees.set(root, { begunAt: at, events: [] });
+  }
+  async appendEvent(root, ev) {
+    const tree = this.trees.get(root);
+    if (!tree) {
+      throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`);
+    }
+    assertSeqUnique(root, tree.events, ev);
+    tree.events.push({ ...ev });
+  }
+};
+var FileSpawnJournal = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  async loadTree(root) {
+    const fs = await import("fs/promises");
+    let text;
+    try {
+      text = await fs.readFile(this.path, "utf8");
+    } catch (err) {
+      if (isNoEntError(err)) return void 0;
+      throw err;
+    }
+    const lines = text.split("\n").filter((line) => line.length > 0);
+    let begun = false;
+    const events = [];
+    for (const line of lines) {
+      const record = JSON.parse(line);
+      if (record.root !== root) continue;
+      if (record.kind === "begin") {
+        begun = true;
+      } else {
+        if (!begun) {
+          throw new Error(
+            `spawn journal corrupted: event for tree '${root}' precedes its begin record`
+          );
+        }
+        assertSeqUnique(root, events, record.event);
+        events.push(record.event);
+      }
+    }
+    return begun ? events : void 0;
+  }
+  async beginTree(root, at) {
+    const existing = await this.loadTreeBegin(root);
+    if (existing) {
+      if (existing !== at) {
+        throw new Error(
+          `spawn tree '${root}' already begun in ${this.path} at ${existing}; refusing to overwrite with ${at}`
+        );
+      }
+      return;
+    }
+    await this.appendRecord({ kind: "begin", root, at });
+  }
+  async appendEvent(root, ev) {
+    const events = await this.loadTree(root);
+    if (events === void 0) {
+      throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`);
+    }
+    assertSeqUnique(root, events, ev);
+    await this.appendRecord({ kind: "event", root, event: ev });
+  }
+  async loadTreeBegin(root) {
+    const fs = await import("fs/promises");
+    let text;
+    try {
+      text = await fs.readFile(this.path, "utf8");
+    } catch (err) {
+      if (isNoEntError(err)) return void 0;
+      throw err;
+    }
+    const lines = text.split("\n").filter((line) => line.length > 0);
+    for (const line of lines) {
+      const record = JSON.parse(line);
+      if (record.root === root && record.kind === "begin") return record.at;
+    }
+    return void 0;
+  }
+  async appendRecord(record) {
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    await fs.mkdir(path.dirname(this.path), { recursive: true });
+    const fh = await fs.open(this.path, "a");
+    try {
+      await fh.write(`${JSON.stringify(record)}
+`);
+      await fh.sync();
+    } finally {
+      await fh.close();
+    }
+  }
+};
+function assertSeqUnique(root, events, ev) {
+  if (ev.kind === "spawned") return;
+  if (events.some((e) => e.kind !== "spawned" && e.seq === ev.seq)) {
+    throw new Error(
+      `spawn journal corrupted: duplicate cursor seq ${ev.seq} in tree '${root}'; the cursor order replay relies on is not unique`
+    );
+  }
+}
+async function replaySpawnTree(journal, blobs, root) {
+  const events = await journal.loadTree(root);
+  if (events === void 0) {
+    throw new Error(`replaySpawnTree: no journaled tree for root '${root}'`);
+  }
+  const ordered = [...events].sort((a, b) => a.seq - b.seq);
+  const labels = /* @__PURE__ */ new Map();
+  for (const ev of ordered) {
+    if (ev.kind === "spawned") labels.set(ev.id, ev.label);
+  }
+  const settled = [];
+  for (const ev of ordered) {
+    if (ev.kind === "spawned") continue;
+    if (ev.kind === "cancelled") {
+      settled.push({
+        kind: "down",
+        handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, "cancelled"),
+        reason: ev.reason,
+        infra: false,
+        restartCount: 0,
+        seq: ev.seq
+      });
+      continue;
+    }
+    if (ev.status === "down") {
+      settled.push({
+        kind: "down",
+        handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, "failed"),
+        reason: ev.verdict?.notes ?? "child down",
+        infra: ev.infra === true,
+        restartCount: 0,
+        seq: ev.seq
+      });
+      continue;
+    }
+    if (ev.outRef === void 0) {
+      throw new Error(
+        `replaySpawnTree: settled-done event for '${ev.id}' (seq ${ev.seq}) has no outRef; cannot rehydrate the result the driver branched on`
+      );
+    }
+    const out = await blobs.get(ev.outRef);
+    if (out === void 0) {
+      throw new Error(
+        `replaySpawnTree: blob store has no artifact for outRef '${ev.outRef}' (node '${ev.id}', seq ${ev.seq})`
+      );
+    }
+    settled.push({
+      kind: "done",
+      handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, "done"),
+      out,
+      outRef: ev.outRef,
+      verdict: ev.verdict,
+      spent: ev.spent,
+      seq: ev.seq
+    });
+  }
+  return settled;
+}
+function replayHandle(id, label, status) {
+  return {
+    id,
+    label,
+    status,
+    abort() {
+      throw new Error(`cannot abort node '${id}': replayed handles are terminal, not live`);
+    }
+  };
+}
+function materializeTreeView(events) {
+  const nodes = /* @__PURE__ */ new Map();
+  let root;
+  const spawns = events.filter((ev) => ev.kind === "spawned").sort((a, b) => a.seq - b.seq);
+  const settlements = events.filter((ev) => ev.kind !== "spawned").sort((a, b) => a.seq - b.seq);
+  for (const ev of spawns) {
+    if (ev.parent === void 0 && root === void 0) root = ev.id;
+    nodes.set(ev.id, {
+      id: ev.id,
+      parent: ev.parent,
+      label: ev.label,
+      status: "pending",
+      runtime: ev.runtime,
+      budget: ev.budget,
+      spent: zeroSpend()
+    });
+  }
+  for (const ev of settlements) {
+    if (ev.kind === "settled") {
+      const node = requireNode(nodes, ev.id);
+      node.status = ev.status === "done" ? "done" : "failed";
+      node.spent = ev.spent;
+      node.outRef = ev.outRef;
+    } else {
+      const node = requireNode(nodes, ev.id);
+      node.status = "cancelled";
+    }
+  }
+  const snapshots = [...nodes.values()].map(freezeSnapshot);
+  return {
+    root: root ?? snapshots[0]?.id ?? "",
+    nodes: snapshots,
+    inFlight: snapshots.filter((n) => n.status === "running" || n.status === "acquiring").length
+  };
+}
+function zeroSpend() {
+  return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
+}
+function requireNode(nodes, id) {
+  const node = nodes.get(id);
+  if (!node) {
+    throw new Error(`spawn journal corrupted: settle/cancel for node '${id}' with no prior spawn`);
+  }
+  return node;
+}
+function freezeSnapshot(node) {
+  return {
+    id: node.id,
+    parent: node.parent,
+    label: node.label,
+    status: node.status,
+    runtime: node.runtime,
+    budget: node.budget,
+    spent: node.spent,
+    outRef: node.outRef
+  };
+}
+function isNoEntError(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+
+// src/runtime/completion.ts
+function completionAuthorizes(v, policy) {
+  if (!v?.done) return false;
+  if (v.determinism === "deterministic") return true;
+  return (v.confidence ?? 0) >= (policy?.minConfidence ?? 0.8);
+}
+function stopSentinel(seed) {
+  let h = 2166136261;
+  for (let i = 0; i < seed.length; i += 1) {
+    h ^= seed.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return `<<<{{STOP:${(h >>> 0).toString(16).padStart(8, "0")}}}>>>`;
+}
+function sentinelCompletion(sentinel, opts) {
+  return {
+    assess({ history }) {
+      const last = history[history.length - 1];
+      const out = typeof last?.output === "string" ? last.output : "";
+      const done = out.includes(sentinel);
+      return {
+        done,
+        determinism: "probabilistic",
+        confidence: done ? opts?.confidence ?? 0.9 : 0,
+        reasons: done ? "agent emitted its assigned stop sentinel" : void 0,
+        evidence: done && last ? [{ kind: "artifact", uri: `attempt:${last.index}` }] : []
+      };
+    }
+  };
+}
+function deterministicCompletion(check) {
+  return {
+    assess({ history }) {
+      const last = history[history.length - 1];
+      if (last?.output === void 0) {
+        return { done: false, determinism: "deterministic", reasons: "no output yet" };
+      }
+      const r = check(last.output, history);
+      return {
+        done: r.passed,
+        determinism: "deterministic",
+        reasons: r.reasons,
+        evidence: [{ kind: "artifact", uri: `attempt:${last.index}` }]
+      };
+    }
+  };
+}
+
+// src/runtime/dynamic.ts
+function createDynamicDriver(options) {
+  if (typeof options.planner !== "function") {
+    throw new ValidationError("createDynamicDriver: planner must be a function");
+  }
+  const maxIterations = options.maxIterations ?? 8;
+  if (!Number.isFinite(maxIterations) || maxIterations <= 0) {
+    throw new ValidationError("createDynamicDriver: maxIterations must be > 0");
+  }
+  const maxFanout = options.maxFanout ?? 4;
+  if (!Number.isFinite(maxFanout) || maxFanout < 1) {
+    throw new ValidationError("createDynamicDriver: maxFanout must be >= 1");
+  }
+  let pending;
+  return {
+    name: options.name ?? "dynamic",
+    async plan(task, history) {
+      if (history.length >= maxIterations) {
+        pending = { kind: "stop", rationale: `maxIterations (${maxIterations}) reached` };
+        return [];
+      }
+      const analyses = options.analyze && history.length > 0 ? await runAnalyze(options.analyze, task, history) : void 0;
+      if (options.complete && history.length > 0) {
+        const verdict = await runComplete(options.complete, task, history);
+        if (completionAuthorizes(verdict, options.completionPolicy)) {
+          pending = {
+            kind: "stop",
+            rationale: `complete (${verdict.determinism}): ${verdict.reasons ?? "satisfied"}`
+          };
+          return [];
+        }
+      }
+      const move = await options.planner({
+        task,
+        history,
+        iterationsSpent: history.length,
+        iterationsRemaining: maxIterations - history.length,
+        ...analyses ? { analyses } : {}
+      });
+      pending = validateMove(move, maxFanout);
+      if (pending.kind === "select") {
+        const iter = history[pending.index];
+        if (!iter || iter.output === void 0) {
+          throw new PlannerError(
+            `dynamic planner select.index ${pending.index} is not a completed iteration with output (history length ${history.length})`
+          );
+        }
+      }
+      switch (pending.kind) {
+        case "refine":
+          return [pending.task];
+        case "fanout":
+          return pending.tasks;
+        case "stop":
+        case "select":
+          return [];
+      }
+    },
+    decide() {
+      return pending?.kind === "stop" || pending?.kind === "select" ? "done" : "continue";
+    },
+    describePlan() {
+      if (!pending) return void 0;
+      const out = { kind: pending.kind };
+      if (pending.rationale !== void 0) out.rationale = pending.rationale;
+      if ((pending.kind === "refine" || pending.kind === "fanout") && pending.parentIndex !== void 0) {
+        out.parentIndex = pending.parentIndex;
+      }
+      return out;
+    },
+    selectWinner(history) {
+      if (pending?.kind !== "select") return void 0;
+      const iter = history[pending.index];
+      if (!iter || iter.output === void 0) return void 0;
+      return {
+        task: iter.task,
+        output: iter.output,
+        verdict: iter.verdict,
+        iterationIndex: iter.index,
+        agentRunName: iter.agentRunName
+      };
+    }
+  };
+}
+function validateMove(move, maxFanout) {
+  if (!move || typeof move !== "object" || typeof move.kind !== "string") {
+    throw new PlannerError(`dynamic planner returned a non-move value: ${stringifySafe(move)}`);
+  }
+  switch (move.kind) {
+    case "refine":
+      return move;
+    case "stop":
+      return move;
+    case "select": {
+      if (!Number.isInteger(move.index) || move.index < 0) {
+        throw new PlannerError(
+          `dynamic planner select move must carry a non-negative integer index, got ${stringifySafe(move.index)}`
+        );
+      }
+      return move;
+    }
+    case "fanout": {
+      if (!Array.isArray(move.tasks) || move.tasks.length === 0) {
+        throw new PlannerError("dynamic planner fanout move must carry a non-empty tasks[]");
+      }
+      if (move.tasks.length <= maxFanout) return move;
+      return {
+        kind: "fanout",
+        tasks: move.tasks.slice(0, maxFanout),
+        rationale: `${move.rationale ?? ""} [clamped ${move.tasks.length}\u2192${maxFanout}]`.trim()
+      };
+    }
+    default:
+      throw new PlannerError(
+        `dynamic planner returned unknown move kind: ${stringifySafe(move.kind)}`
+      );
+  }
+}
+async function runAnalyze(analyze, task, history) {
+  const findings = await analyze({ task, history });
+  if (!Array.isArray(findings)) {
+    throw new PlannerError(
+      `createDynamicDriver: analyze hook must return AnalystFinding[], got ${stringifySafe(findings)}`
+    );
+  }
+  assertTraceDerivedFindings(findings);
+  return findings;
+}
+async function runComplete(complete, task, history) {
+  const verdict = await complete.assess({ task, history });
+  if (!verdict || typeof verdict.done !== "boolean" || verdict.determinism !== "deterministic" && verdict.determinism !== "probabilistic") {
+    throw new PlannerError(
+      `createDynamicDriver: complete.assess must return a CompletionVerdict {done, determinism}, got ${stringifySafe(verdict)}`
+    );
+  }
+  return verdict;
+}
+var JUDGE_EVIDENCE_URI = /^(verdict|judge|score)\b/i;
+function assertTraceDerivedFindings(findings) {
+  for (const f of findings) {
+    for (const ref of f.evidence_refs ?? []) {
+      if (ref.kind === "metric" && JUDGE_EVIDENCE_URI.test(ref.uri)) {
+        throw new PlannerError(
+          `steer-firewall: finding ${stringifySafe(f.finding_id)} cites judge-derived evidence (${stringifySafe(ref.uri)}); analyses fed to the driver must be trace-derived, not judge-derived (selector \u2260 judge)`
+        );
+      }
+    }
+  }
+}
+function renderAnalyses(findings) {
+  if (findings.length === 0) return "";
+  const rows = findings.map((f) => {
+    const action = f.recommended_action ? ` \u2192 ${f.recommended_action}` : "";
+    return `  - [${f.severity}/${f.area}] ${f.claim}${action} (conf ${f.confidence.toFixed(2)})`;
+  });
+  return `Trace-analyst findings (diagnosis of the attempts so far \u2014 steer from these, not the verdict score alone):
+${rows.join("\n")}`;
+}
+
+// src/runtime/report-usage.ts
+function reportLoopUsage(cost, result, source = "loop") {
+  cost.observe(result.costUsd, source);
+  cost.observeTokens(result.tokenUsage);
+}
+
+// src/runtime-hooks.ts
+function defineRuntimeHooks(hooks) {
+  return hooks;
+}
+function composeRuntimeHooks(...entries) {
+  const hooks = entries.filter((entry) => !!entry);
+  return {
+    onEvent: hooks.some((hook) => hook.onEvent) ? (event, context) => {
+      const pending = [];
+      for (const hook of hooks) {
+        const result = hook.onEvent?.(event, context);
+        if (isThenable(result)) pending.push(Promise.resolve(result));
+      }
+      if (pending.length > 0) return Promise.all(pending).then(() => void 0);
+      return void 0;
+    } : void 0,
+    onDecisionPoint: hooks.some((hook) => hook.onDecisionPoint) ? (point, context) => {
+      const pending = [];
+      for (const hook of hooks) {
+        const result = hook.onDecisionPoint?.(point, context);
+        if (isThenable(result)) pending.push(Promise.resolve(result));
+      }
+      if (pending.length > 0) return Promise.all(pending).then(() => void 0);
+      return void 0;
+    } : void 0,
+    onHookError: hooks.some((hook) => hook.onHookError) ? (error, context) => {
+      const pending = [];
+      for (const hook of hooks) {
+        const result = hook.onHookError?.(error, context);
+        if (isThenable(result)) pending.push(Promise.resolve(result));
+      }
+      if (pending.length > 0) return Promise.all(pending).then(() => void 0);
+      return void 0;
+    } : void 0
+  };
+}
+function notifyRuntimeHookEvent(hooks, event, context = {}) {
+  const onEvent = hooks?.onEvent;
+  if (!onEvent) return;
+  try {
+    const result = onEvent(event, context);
+    if (isThenable(result)) {
+      void result.catch((error) => {
+        notifyRuntimeHookError(hooks, toError(error), {
+          hook: "onEvent",
+          eventId: event.id,
+          target: event.target,
+          phase: event.phase
+        });
+      });
+    }
+  } catch (error) {
+    notifyRuntimeHookError(hooks, toError(error), {
+      hook: "onEvent",
+      eventId: event.id,
+      target: event.target,
+      phase: event.phase
+    });
+  }
+}
+function notifyRuntimeDecisionPoint(hooks, point, context = {}) {
+  const onDecisionPoint = hooks?.onDecisionPoint;
+  if (!onDecisionPoint) return;
+  try {
+    const result = onDecisionPoint(point, context);
+    if (isThenable(result)) {
+      void result.catch((error) => {
+        notifyRuntimeHookError(hooks, toError(error), {
+          hook: "onDecisionPoint",
+          decisionId: point.id,
+          decisionKind: point.kind
+        });
+      });
+    }
+  } catch (error) {
+    notifyRuntimeHookError(hooks, toError(error), {
+      hook: "onDecisionPoint",
+      decisionId: point.id,
+      decisionKind: point.kind
+    });
+  }
+}
+function notifyRuntimeHookError(hooks, error, context) {
+  try {
+    const result = hooks?.onHookError?.(error, context);
+    if (isThenable(result)) void result.catch(() => void 0);
+  } catch {
+  }
+}
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// src/runtime/sandbox-acquire.ts
+var RETRYABLE_HTTP = /* @__PURE__ */ new Set([502, 503, 504, 522, 524, 408, 425, 429]);
+var TERMINAL_STATUS = /* @__PURE__ */ new Set(["failed", "expired", "stopped"]);
+async function acquireSandbox(client, options, acquire = {}) {
+  if (!client || typeof client.create !== "function") {
+    throw new ValidationError("acquireSandbox: client.create is required");
+  }
+  const now = acquire.now ?? Date.now;
+  const sleep2 = acquire.sleep ?? ((ms) => sleep(ms, acquire.signal));
+  const pollMs = acquire.pollIntervalMs ?? 3e3;
+  const deadline = now() + (acquire.readyTimeoutMs ?? 6e5);
+  const name = options.name ?? acquire.name ?? `loop-sbx-${randomUuid()}`;
+  const createOpts = { ...options, name };
+  const c = client;
+  let lastErr;
+  let attempt = 0;
+  while (now() < deadline) {
+    throwIfAborted(acquire.signal);
+    try {
+      const box = await client.create(createOpts);
+      return await waitReadyOrDestroy(box, deadline, pollMs, acquire.signal, now, sleep2);
+    } catch (err) {
+      throwIfAborted(acquire.signal);
+      if (!isRetryable(err)) throw err;
+      lastErr = err;
+      if (typeof c.list === "function") {
+        const found = (await c.list().catch(() => []))?.find((b) => b.name === name);
+        if (found)
+          return await waitReadyOrDestroy(found, deadline, pollMs, acquire.signal, now, sleep2);
+      }
+      attempt += 1;
+      await sleep2(Math.min(pollMs * attempt, 15e3));
+    }
+  }
+  throw new ValidationError(
+    `acquireSandbox: could not acquire a running sandbox "${name}" within budget`,
+    { cause: lastErr instanceof Error ? lastErr : void 0 }
+  );
+}
+async function waitReadyOrDestroy(box, deadline, pollMs, signal, now, sleep2) {
+  try {
+    return await waitUntilReady(box, deadline, pollMs, signal, now, sleep2);
+  } catch (err) {
+    await deleteBoxSafe(box);
+    throw err;
+  }
+}
+async function waitUntilReady(box, deadline, pollMs, signal, now, sleep2) {
+  for (; ; ) {
+    throwIfAborted(signal);
+    const status = readStatus(box);
+    if (status === void 0 || status === "running") return box;
+    if (TERMINAL_STATUS.has(status)) {
+      throw new ValidationError(
+        `acquireSandbox: sandbox ${box.id ?? "(unknown)"} is ${status}${box.error ? `: ${box.error}` : ""}`
+      );
+    }
+    if (now() >= deadline) {
+      throw new ValidationError(
+        `acquireSandbox: sandbox ${box.id ?? "(unknown)"} not running within budget (last status: ${status})`
+      );
+    }
+    await sleep2(pollMs);
+    if (typeof box.refresh === "function") await box.refresh();
+  }
+}
+function readStatus(box) {
+  const s = box.status;
+  return typeof s === "string" ? s : void 0;
+}
+function isRetryable(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  const status = e.status ?? e.statusCode;
+  if (typeof status === "number" && RETRYABLE_HTTP.has(status)) return true;
+  const name = e.name ?? "";
+  if (name === "TimeoutError" || name === "ServerError" || name === "NetworkError") return true;
+  return /\b(timed out|timeout|gateway|temporarily unavailable|ECONNRESET|ETIMEDOUT|EAI_AGAIN)\b/i.test(
+    e.message ?? ""
+  );
+}
+
+// src/runtime/sandbox-backend.ts
+function resolveBackendType(profile, override) {
+  if (override?.type) return override.type;
+  const explicit = profile.metadata?.backendType;
+  if (typeof explicit === "string") return explicit;
+  return "opencode";
+}
+function buildBackendOptions(profile, overrides) {
+  const base = overrides ?? {};
+  const overrideBackend = base.backend;
+  return {
+    ...base,
+    backend: {
+      type: resolveBackendType(profile, overrideBackend),
+      profile,
+      ...overrideBackend?.model ? { model: overrideBackend.model } : {},
+      ...overrideBackend?.server ? { server: overrideBackend.server } : {}
+    }
+  };
+}
+
+// src/runtime/sandbox-capabilities.ts
+var probeCache = /* @__PURE__ */ new WeakMap();
+function probeSandboxCapabilities(client) {
+  const key = client;
+  const cached = probeCache.get(key);
+  if (cached) return cached;
+  const probe = resolveCapabilities(client);
+  probeCache.set(key, probe);
+  return probe;
+}
+async function resolveCapabilities(client) {
+  const criuStatus = client.criuStatus;
+  if (typeof criuStatus !== "function") return { canFork: false };
+  try {
+    const status = await criuStatus.call(client);
+    return { canFork: status?.available === true };
+  } catch {
+    return { canFork: false };
+  }
+}
+
+// src/runtime/sandbox-lineage.ts
+var TEARDOWN_TIMEOUT_MS = 15e3;
+var DEFAULT_FORK_CONCURRENCY = 4;
+function createSandboxLineage(client, capabilities, options = {}) {
+  if (!client || typeof client.create !== "function") {
+    throw new ValidationError("createSandboxLineage: client.create is required");
+  }
+  const forkConcurrency = Math.max(
+    1,
+    Math.floor(options.maxConcurrency ?? DEFAULT_FORK_CONCURRENCY)
+  );
+  const owned = [];
+  const acquireFresh = async (spec, signal) => {
+    if (signal.aborted) throwAbort();
+    const opts = buildBackendOptions(spec.profile, spec.sandboxOverrides);
+    const box = await acquireSandbox(client, opts, { signal });
+    owned.push(box);
+    return box;
+  };
+  return {
+    async start(spec, prompt, signal) {
+      const box = await acquireFresh(spec, signal);
+      const sessionId = mintSessionId();
+      const events = box.streamPrompt(prompt, { sessionId, signal });
+      return { handle: { box, sessionId }, events };
+    },
+    async continue(handle, prompt, signal) {
+      if (signal.aborted) throwAbort();
+      await assertSessionLive(handle.box, handle.sessionId);
+      return handle.box.streamPrompt(prompt, { sessionId: handle.sessionId, signal });
+    },
+    async fork(parent, prompts, specs, signal) {
+      if (prompts.length === 0) {
+        throw new ValidationError("SandboxLineage.fork: prompts must be non-empty");
+      }
+      if (signal.aborted) throwAbort();
+      const checkpointId = capabilities.canFork ? await checkpointForFork(parent.box, signal) : void 0;
+      return mapWithConcurrency(prompts, forkConcurrency, async (prompt, i) => {
+        throwIfAborted(signal);
+        const spec = specs[i % specs.length];
+        if (!spec) throw new ValidationError("SandboxLineage.fork: no AgentRunSpec for branch");
+        if (checkpointId !== void 0) {
+          const box2 = await forkFromCheckpoint(parent.box, checkpointId, signal);
+          owned.push(box2);
+          const sessionId2 = mintSessionId();
+          return {
+            handle: { box: box2, sessionId: sessionId2 },
+            events: box2.streamPrompt(prompt, { sessionId: sessionId2, signal })
+          };
+        }
+        const box = await acquireFresh(spec, signal);
+        const sessionId = mintSessionId();
+        return {
+          handle: { box, sessionId },
+          events: box.streamPrompt(prompt, { sessionId, signal })
+        };
+      });
+    },
+    async prune(keep) {
+      const keepBoxes = /* @__PURE__ */ new Set();
+      for (const handle of keep) keepBoxes.add(handle.box);
+      const survivors = [];
+      const doomed = [];
+      for (const box of owned) (keepBoxes.has(box) ? survivors : doomed).push(box);
+      if (doomed.length === 0) return;
+      owned.length = 0;
+      owned.push(...survivors);
+      await Promise.allSettled(doomed.map((box) => destroyBounded(box)));
+    },
+    async teardown() {
+      const boxes = owned.splice(0, owned.length);
+      await Promise.allSettled(boxes.map((box) => destroyBounded(box)));
+    }
+  };
+}
+function mintSessionId() {
+  return `loop-sess-${randomUuid()}`;
+}
+async function checkpointForFork(box, signal) {
+  const checkpoint = box.checkpoint;
+  if (typeof checkpoint !== "function") return void 0;
+  if (signal.aborted) throwAbort();
+  const result = await checkpoint.call(box, { leaveRunning: true });
+  const id = result?.checkpointId;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+async function forkFromCheckpoint(box, checkpointId, signal) {
+  const fork = box.fork;
+  if (typeof fork !== "function") {
+    throw new ValidationError(
+      "SandboxLineage.fork: capabilities report canFork but the box has no fork() method"
+    );
+  }
+  if (signal.aborted) throwAbort();
+  return fork.call(box, checkpointId);
+}
+async function assertSessionLive(box, sessionId) {
+  const session = box.session;
+  if (typeof session !== "function") return;
+  const info = await session.call(box, sessionId).status();
+  if (info === null) {
+    throw new ValidationError(
+      `SandboxLineage.continue: session ${sessionId} is not known to the sandbox \u2014 the platform did not preserve the client-minted session id (or it was reaped). Continuing would run without prior context; refusing to silently lose conversation continuity.`
+    );
+  }
+}
+async function destroyBounded(box) {
+  await withTimeout(deleteBoxSafe(box), TEARDOWN_TIMEOUT_MS);
+}
+
+// src/runtime/run-loop.ts
+var DEFAULT_MAX_ITERATIONS = 10;
+var DEFAULT_MAX_CONCURRENCY = 4;
+async function runLoop(options) {
+  const specs = resolveAgentRuns(options);
+  const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  if (!Number.isFinite(maxIterations) || maxIterations <= 0) {
+    throw new ValidationError("runLoop: maxIterations must be > 0");
+  }
+  const maxConcurrency = options.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY;
+  if (!Number.isFinite(maxConcurrency) || maxConcurrency <= 0) {
+    throw new ValidationError("runLoop: maxConcurrency must be > 0");
+  }
+  if (!options.ctx?.sandboxClient || typeof options.ctx.sandboxClient.create !== "function") {
+    throw new ValidationError("runLoop: ctx.sandboxClient.create is required");
+  }
+  const now = options.now ?? Date.now;
+  const runId = options.runId ?? `loop-${randomSuffix()}`;
+  const loopStart = now();
+  const driverName = options.driver.name ?? "driver";
+  const iterations = [];
+  let round = 0;
+  const ownedBoxes = [];
+  const collectBox = options.onWorkerBox ? (box) => {
+    ownedBoxes.push(box);
+    options.onWorkerBox?.(box);
+  } : void 0;
+  const lineageState = await setUpLineage(options, maxConcurrency);
+  emitRunLoopHook(options, {
+    target: "agent.run",
+    phase: "before",
+    runId,
+    timestamp: now(),
+    payload: {
+      driver: driverName,
+      agentRunNames: specs.map((spec) => spec.name ?? spec.profile.name ?? "agent"),
+      maxIterations,
+      maxConcurrency
+    }
+  });
+  await emitTrace(options.ctx.traceEmitter, {
+    kind: "loop.started",
+    runId,
+    timestamp: now(),
+    payload: {
+      driver: driverName,
+      agentRunNames: specs.map((spec) => spec.name ?? spec.profile.name ?? "agent"),
+      maxIterations,
+      maxConcurrency
+    }
+  });
+  const controller = new AbortController();
+  const onOuterAbort = () => controller.abort();
+  if (options.ctx.signal) {
+    if (options.ctx.signal.aborted) controller.abort();
+    else options.ctx.signal.addEventListener("abort", onOuterAbort, { once: true });
+  }
+  try {
+    while (iterations.length < maxIterations) {
+      if (controller.signal.aborted) throwAbort();
+      emitRunLoopHook(options, {
+        target: "agent.plan",
+        phase: "before",
+        runId,
+        timestamp: now(),
+        stepIndex: round,
+        payload: { roundIndex: round, historyLength: iterations.length }
+      });
+      const planned = await options.driver.plan(options.task, iterations);
+      if (controller.signal.aborted) throwAbort();
+      const planDesc = options.driver.describePlan?.();
+      const roundIndex = round;
+      const baseIndex = iterations.length;
+      const remaining = maxIterations - iterations.length;
+      const slice = planned.slice(0, remaining);
+      const parentIndex = planDesc?.parentIndex ?? (roundIndex === 0 ? void 0 : branchPoint(iterations));
+      const childIndices = slice.map((_, i) => baseIndex + i);
+      const moveKind = planDesc?.kind ?? (planned.length === 0 ? "stop" : planned.length === 1 ? "refine" : "fanout");
+      emitRunLoopHook(options, {
+        target: "agent.plan",
+        phase: "after",
+        runId,
+        timestamp: now(),
+        stepIndex: roundIndex,
+        payload: {
+          roundIndex,
+          plannedCount: planned.length,
+          moveKind,
+          parentIndex,
+          childIndices
+        }
+      });
+      await emitTrace(options.ctx.traceEmitter, {
+        kind: "loop.plan",
+        runId,
+        timestamp: now(),
+        payload: {
+          roundIndex,
+          plannedCount: planned.length,
+          moveKind,
+          rationale: planDesc?.rationale,
+          parentIndex,
+          childIndices
+        }
+      });
+      round += 1;
+      if (planned.length === 0) break;
+      for (let i = 0; i < slice.length; i += 1) {
+        const spec = specs[(baseIndex + i) % specs.length];
+        iterations.push({
+          index: baseIndex + i,
+          task: slice[i],
+          agentRunName: spec.name ?? spec.profile.name ?? "agent",
+          events: [],
+          startedAt: now(),
+          endedAt: 0,
+          costUsd: 0,
+          tokenUsage: zeroTokenUsage()
+        });
+      }
+      const lineagePlan = lineageState ? planLineageRound(lineageState, specs, slice, parentIndex, controller.signal) : void 0;
+      await runBatch({
+        slice,
+        baseIndex,
+        iterations,
+        specs,
+        output: options.output,
+        validator: options.validator,
+        maxConcurrency,
+        signal: controller.signal,
+        ctx: options.ctx,
+        runId,
+        now,
+        roundIndex,
+        parentIndex,
+        collectBox,
+        lineagePlan,
+        lineageState
+      });
+      if (controller.signal.aborted) throwAbort();
+      emitRunLoopHook(options, {
+        target: "agent.decision",
+        phase: "before",
+        runId,
+        timestamp: now(),
+        stepIndex: roundIndex,
+        payload: { historyLength: iterations.length }
+      });
+      const decision = await options.driver.decide(iterations);
+      emitRunLoopHook(options, {
+        target: "agent.decision",
+        phase: "after",
+        runId,
+        timestamp: now(),
+        stepIndex: roundIndex,
+        payload: { decision: stringifySafe(decision), historyLength: iterations.length }
+      });
+      await emitTrace(options.ctx.traceEmitter, {
+        kind: "loop.decision",
+        runId,
+        timestamp: now(),
+        payload: { decision: stringifySafe(decision), historyLength: iterations.length }
+      });
+      if (isTerminalDecision(decision)) {
+        return await finalizeAndEmitEnded(options, decision, iterations, loopStart, now, runId);
+      }
+      if (lineageState) await pruneLineage(lineageState, iterations);
+    }
+    return await decideAndFinalize(options, iterations, loopStart, now, runId);
+  } finally {
+    if (options.ctx.signal) options.ctx.signal.removeEventListener("abort", onOuterAbort);
+    await Promise.allSettled(
+      ownedBoxes.map((b) => destroySandboxSafe(b, options.ctx.traceEmitter, runId, now))
+    );
+    if (options.onWorkerBox) options.onWorkerBox(void 0);
+    if (lineageState) await lineageState.lineage.teardown();
+  }
+}
+async function setUpLineage(options, maxConcurrency) {
+  const lineageOpts = options.lineage;
+  if (!lineageOpts || !lineageOpts.sessionContinuity && !lineageOpts.forkFanout) return void 0;
+  if (options.onWorkerBox) {
+    throw new ValidationError(
+      "runLoop: `lineage` and `onWorkerBox` both own worker boxes \u2014 pass only one"
+    );
+  }
+  const capabilities = await probeSandboxCapabilities(options.ctx.sandboxClient);
+  return {
+    lineage: createSandboxLineage(options.ctx.sandboxClient, capabilities, { maxConcurrency }),
+    options: lineageOpts,
+    handles: /* @__PURE__ */ new Map(),
+    canPrune: typeof options.driver.describePlan !== "function"
+  };
+}
+function planLineageRound(state, specs, slice, parentIndex, signal) {
+  const lineage = state.lineage;
+  const parent = parentIndex !== void 0 ? state.handles.get(parentIndex) : void 0;
+  const promptFor = (offset) => {
+    const spec = specs[offset % specs.length];
+    if (!spec) throw new ValidationError("runLoop: no AgentRunSpec available for lineage iteration");
+    return spec.taskToPrompt(slice[offset]);
+  };
+  const specAt = (offset) => {
+    const spec = specs[offset % specs.length];
+    if (!spec) throw new ValidationError("runLoop: no AgentRunSpec available for lineage iteration");
+    return spec;
+  };
+  if (slice.length === 1 && parent && state.options.sessionContinuity) {
+    return [
+      {
+        async acquire() {
+          const events = await lineage.continue(parent, promptFor(0), signal);
+          return { events, handle: parent };
+        }
+      }
+    ];
+  }
+  if (slice.length > 1 && parent && state.options.forkFanout) {
+    const prompts = slice.map((_, offset) => promptFor(offset));
+    const childSpecs = slice.map((_, offset) => specAt(offset));
+    let forked;
+    const ensureForked = () => {
+      forked ??= lineage.fork(parent, prompts, childSpecs, signal);
+      return forked;
+    };
+    return slice.map((_, offset) => ({
+      async acquire() {
+        const branches = await ensureForked();
+        const branch = branches[offset];
+        if (!branch)
+          throw new ValidationError("runLoop: lineage fork produced no branch for offset");
+        return branch;
+      }
+    }));
+  }
+  return slice.map((_, offset) => ({
+    async acquire() {
+      return lineage.start(specAt(offset), promptFor(offset), signal);
+    }
+  }));
+}
+async function pruneLineage(state, iterations) {
+  if (!state.canPrune) return;
+  const keepIndex = branchPoint(iterations);
+  if (keepIndex === void 0) return;
+  const keep = state.handles.get(keepIndex);
+  if (!keep) return;
+  await state.lineage.prune([keep]);
+  const stale = [];
+  for (const [index, handle] of state.handles) {
+    if (handle.box !== keep.box) stale.push(index);
+  }
+  for (const index of stale) state.handles.delete(index);
+}
+async function runBatch(args) {
+  const queue = args.slice.map((task, offset) => ({ task, index: args.baseIndex + offset }));
+  const inflight = /* @__PURE__ */ new Set();
+  const started = [];
+  let firstError;
+  try {
+    while (queue.length > 0 || inflight.size > 0) {
+      while (inflight.size < args.maxConcurrency && queue.length > 0) {
+        const item = queue.shift();
+        const p = executeIteration({ ...args, item }).finally(() => inflight.delete(p));
+        started.push(p);
+        inflight.add(p);
+      }
+      if (inflight.size === 0) break;
+      try {
+        await Promise.race(inflight);
+      } catch (err) {
+        if (firstError === void 0) firstError = err;
+        queue.length = 0;
+        break;
+      }
+    }
+  } finally {
+    const settled = await Promise.allSettled(started);
+    if (firstError === void 0) {
+      const rejected = settled.find((s) => s.status === "rejected");
+      if (rejected && rejected.status === "rejected") firstError = rejected.reason;
+    }
+  }
+  if (firstError !== void 0) throw firstError;
+}
+async function executeIteration(args) {
+  const slot = args.iterations[args.item.index];
+  if (!slot)
+    throw new ValidationError(`runLoop: missing iteration slot at index ${args.item.index}`);
+  const spec = args.specs[args.item.index % args.specs.length];
+  if (!spec) throw new ValidationError("runLoop: no AgentRunSpec available for iteration");
+  slot.startedAt = args.now();
+  slot.agentRunName = spec.name ?? spec.profile.name ?? "agent";
+  await emitTrace(args.ctx.traceEmitter, {
+    kind: "loop.iteration.started",
+    runId: args.runId,
+    timestamp: args.now(),
+    payload: {
+      iterationIndex: args.item.index,
+      agentRunName: slot.agentRunName,
+      taskHash: hashJson(args.item.task),
+      groupId: args.roundIndex,
+      parentIndex: args.parentIndex
+    }
+  });
+  let box;
+  let lineageOwned = false;
+  try {
+    let stream;
+    const source = args.lineagePlan?.[args.item.index - args.baseIndex];
+    if (source) {
+      const acquired = await source.acquire();
+      box = acquired.handle.box;
+      lineageOwned = true;
+      args.lineageState?.handles.set(args.item.index, acquired.handle);
+      stream = acquired.events;
+    } else {
+      box = await createSandboxForSpec(args.ctx.sandboxClient, spec, args.signal);
+      stream = box.streamPrompt(spec.taskToPrompt(args.item.task), { signal: args.signal });
+    }
+    const placement = describeSandboxPlacement(args.ctx.sandboxClient, box);
+    await emitTrace(args.ctx.traceEmitter, {
+      kind: "loop.iteration.dispatch",
+      runId: args.runId,
+      timestamp: args.now(),
+      payload: {
+        iterationIndex: args.item.index,
+        agentRunName: slot.agentRunName,
+        placement: placement.kind,
+        sandboxId: placement.sandboxId,
+        fleetId: placement.fleetId,
+        machineId: placement.machineId,
+        groupId: args.roundIndex,
+        parentIndex: args.parentIndex
+      }
+    });
+    const events = [];
+    for await (const event of stream) {
+      events.push(event);
+      const llmCall = extractLlmCallEvent(event, slot.agentRunName);
+      if (llmCall) {
+        slot.costUsd += llmCall.costUsd ?? 0;
+        addTokenUsage(slot.tokenUsage, { input: llmCall.tokensIn, output: llmCall.tokensOut });
+        args.ctx.runHandle?.observe(llmCall);
+      }
+    }
+    slot.events = events;
+    slot.output = args.output.parse(events);
+    if (args.validator) {
+      slot.verdict = await args.validator.validate(slot.output, {
+        iteration: args.item.index,
+        signal: args.signal,
+        traceEmitter: args.ctx.traceEmitter
+      });
+    }
+  } catch (err) {
+    slot.error = err instanceof Error ? err : new Error(String(err));
+  } finally {
+    slot.endedAt = args.now();
+    await emitTrace(args.ctx.traceEmitter, {
+      kind: "loop.iteration.ended",
+      runId: args.runId,
+      timestamp: args.now(),
+      payload: {
+        iterationIndex: args.item.index,
+        agentRunName: slot.agentRunName,
+        outputHash: slot.output !== void 0 ? hashJson(slot.output) : void 0,
+        verdict: slot.verdict,
+        error: slot.error?.message,
+        costUsd: slot.costUsd,
+        durationMs: slot.endedAt - slot.startedAt,
+        tokenUsage: slot.tokenUsage.input || slot.tokenUsage.output ? { ...slot.tokenUsage } : void 0,
+        groupId: args.roundIndex,
+        parentIndex: args.parentIndex,
+        outputPreview: slot.output !== void 0 ? stringifySafe(slot.output, { max: 280 }) : void 0
+      }
+    });
+    if (lineageOwned) {
+    } else if (args.collectBox && box) {
+      args.collectBox(box);
+    } else {
+      await destroySandboxSafe(box, args.ctx.traceEmitter, args.runId, args.now);
+    }
+  }
+  if (isAbortError(slot.error) || args.signal.aborted) {
+    if (slot.error) throw slot.error;
+    throwAbort();
+  }
+  if (slot.error instanceof ValidationError) throw slot.error;
+}
+function isAbortError(err) {
+  return err instanceof Error && err.name === "AbortError";
+}
+var TEARDOWN_TIMEOUT_MS2 = 15e3;
+async function destroySandboxSafe(box, trace, runId, now) {
+  if (!box || typeof box.delete !== "function") return;
+  const emitFailed = async (reason) => {
+    if (!trace || !runId) return;
+    await emitTrace(trace, {
+      kind: "loop.teardown.failed",
+      runId,
+      timestamp: (now ?? Date.now)(),
+      payload: { sandboxId: readSandboxId(box), reason }
+    });
+  };
+  const outcome = await withTimeout(deleteBoxSafe(box), TEARDOWN_TIMEOUT_MS2);
+  if (outcome === void 0) await emitFailed("timeout");
+  else if (outcome === false) await emitFailed("delete threw");
+}
+function branchPoint(iterations) {
+  if (iterations.length === 0) return void 0;
+  let best = iterations.length - 1;
+  let bestScore = -Infinity;
+  for (const iter of iterations) {
+    if (iter.verdict?.valid !== true) continue;
+    const score = iter.verdict.score ?? 0;
+    if (score > bestScore) {
+      bestScore = score;
+      best = iter.index;
+    }
+  }
+  return best;
+}
+function describeSandboxPlacement(client, box) {
+  if (typeof client.describePlacement === "function") {
+    try {
+      const result = client.describePlacement(box);
+      if (result && typeof result === "object" && (result.kind === "sibling" || result.kind === "fleet")) {
+        return {
+          kind: result.kind,
+          sandboxId: result.sandboxId ?? readSandboxId(box),
+          fleetId: result.fleetId,
+          machineId: result.machineId
+        };
+      }
+    } catch {
+    }
+  }
+  return { kind: "sibling", sandboxId: readSandboxId(box) };
+}
+function readSandboxId(box) {
+  const raw = box.id;
+  return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+async function createSandboxForSpec(client, spec, signal) {
+  const opts = buildBackendOptions(spec.profile, spec.sandboxOverrides);
+  if (signal.aborted) throwAbort();
+  return acquireSandbox(client, opts, { signal });
+}
+function finalize(args) {
+  const winner = args.options.selectWinner ? args.options.selectWinner(args.iterations) : args.options.driver.selectWinner?.(args.iterations) ?? defaultSelectWinner(args.iterations);
+  const costUsd = args.iterations.reduce((sum, iter) => sum + (iter.costUsd || 0), 0);
+  const tokenUsage = args.iterations.reduce((acc, iter) => {
+    addTokenUsage(acc, iter.tokenUsage);
+    return acc;
+  }, zeroTokenUsage());
+  const result = {
+    decision: args.decision,
+    iterations: args.iterations,
+    winner,
+    durationMs: args.now() - args.startMs,
+    costUsd,
+    tokenUsage
+  };
+  return result;
+}
+async function decideAndFinalize(options, iterations, startMs, now, runId) {
+  emitRunLoopHook(options, {
+    target: "agent.decision",
+    phase: "before",
+    runId,
+    timestamp: now(),
+    payload: { historyLength: iterations.length }
+  });
+  const decision = await options.driver.decide(iterations);
+  emitRunLoopHook(options, {
+    target: "agent.decision",
+    phase: "after",
+    runId,
+    timestamp: now(),
+    payload: { decision: stringifySafe(decision), historyLength: iterations.length }
+  });
+  await emitTrace(options.ctx.traceEmitter, {
+    kind: "loop.decision",
+    runId,
+    timestamp: now(),
+    payload: { decision: stringifySafe(decision), historyLength: iterations.length }
+  });
+  return finalizeAndEmitEnded(options, decision, iterations, startMs, now, runId);
+}
+async function finalizeAndEmitEnded(options, decision, iterations, startMs, now, runId) {
+  const result = finalize({ options, decision, iterations, startMs, now, runId });
+  emitRunLoopHook(options, {
+    target: "agent.run",
+    phase: "after",
+    runId,
+    timestamp: now(),
+    payload: {
+      decision: stringifySafe(decision),
+      winnerIterationIndex: result.winner?.iterationIndex,
+      totalCostUsd: result.costUsd,
+      durationMs: result.durationMs,
+      iterations: iterations.length
+    }
+  });
+  await emitTrace(options.ctx.traceEmitter, {
+    kind: "loop.ended",
+    runId,
+    timestamp: now(),
+    payload: {
+      winnerIterationIndex: result.winner?.iterationIndex,
+      totalCostUsd: result.costUsd,
+      durationMs: result.durationMs,
+      iterations: iterations.length
+    }
+  });
+  return result;
+}
+function defaultSelectWinner(iterations) {
+  const candidates = iterations.filter((iter) => iter.output !== void 0 && !iter.error);
+  if (candidates.length === 0) return void 0;
+  const valid = candidates.filter((iter) => iter.verdict?.valid === true);
+  const pool = valid.length > 0 ? valid : candidates;
+  const sorted = [...pool].sort(
+    (a, b) => (b.verdict?.score ?? 0) - (a.verdict?.score ?? 0) || a.index - b.index
+  );
+  const top = sorted[0];
+  if (!top || top.output === void 0) return void 0;
+  return {
+    task: top.task,
+    output: top.output,
+    verdict: top.verdict,
+    iterationIndex: top.index,
+    agentRunName: top.agentRunName
+  };
+}
+function resolveAgentRuns(options) {
+  if (options.agentRun && options.agentRuns) {
+    throw new ValidationError("runLoop: pass exactly one of `agentRun` or `agentRuns`");
+  }
+  if (options.agentRun) return [options.agentRun];
+  if (options.agentRuns && options.agentRuns.length > 0) return options.agentRuns;
+  throw new ValidationError("runLoop: `agentRun` or non-empty `agentRuns` is required");
+}
+function isTerminalDecision(decision) {
+  return decision === "stop" || decision === "pick-winner" || decision === "fail" || decision === "done";
+}
+function emitRunLoopHook(options, event) {
+  notifyRuntimeHookEvent(
+    options.ctx.hooks,
+    {
+      id: `${event.runId}:${event.target}:${event.phase}${event.stepIndex === void 0 ? "" : `:${event.stepIndex}`}`,
+      runId: event.runId,
+      target: event.target,
+      phase: event.phase,
+      timestamp: event.timestamp,
+      stepIndex: event.stepIndex,
+      payload: event.payload,
+      metadata: { producer: "run-loop" }
+    },
+    { signal: options.ctx.signal }
+  );
+}
+async function emitTrace(emitter, event) {
+  if (!emitter) return;
+  await emitter.emit(event);
+}
+function hashJson(value) {
+  let str;
+  try {
+    str = JSON.stringify(value) ?? String(value);
+  } catch {
+    str = String(value);
+  }
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i += 1) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+// src/runtime/loop-dispatch.ts
+function campaignTraceToLoopEmitter(trace) {
+  return {
+    emit(event) {
+      trace.span(event.kind, { runId: event.runId, timestamp: event.timestamp, ...event.payload }).end();
+    }
+  };
+}
+async function runLoopForCell(opts, scenario, profile, ctx) {
+  const loopOptions = opts.toLoopOptions(scenario, profile);
+  const result = await runLoop({
+    ...loopOptions,
+    ctx: {
+      sandboxClient: opts.sandboxClient,
+      signal: ctx.signal,
+      traceEmitter: opts.forwardTrace === false ? void 0 : campaignTraceToLoopEmitter(ctx.trace)
+    }
+  });
+  reportLoopUsage(ctx.cost, result, opts.costSource ?? "loop");
+  const toArtifact = opts.toArtifact ?? ((r) => r.winner?.output);
+  return toArtifact(result);
+}
+function loopDispatch(opts) {
+  return (profile, scenario, ctx) => runLoopForCell(opts, scenario, profile, ctx);
+}
+
+// src/runtime/personify/analyst.ts
+var judgeEvidenceUri = /^(verdict|judge|score)\b/i;
+var assertTraceDerivedFindings2 = (findings) => {
+  for (const f of findings) {
+    for (const ref of f.evidence_refs ?? []) {
+      if (ref.kind === "metric" && judgeEvidenceUri.test(ref.uri)) {
+        throw new PlannerError(
+          `steer-firewall: finding ${stringifySafe(f.finding_id)} cites judge-derived evidence (${stringifySafe(ref.uri)}); findings fed to a combinator's steer decision must be trace-derived, not judge-derived (selector \u2260 judge)`
+        );
+      }
+    }
+  }
+};
+function createScopeAnalyst(scope, options) {
+  if (!options.analyst || typeof options.analyst.act !== "function") {
+    throw new AnalystError("createScopeAnalyst: analyst must be an Agent with an act() method");
+  }
+  const label = options.label ?? "analyst";
+  return {
+    async analyze(input) {
+      const task = options.buildTask(input);
+      const spawned = scope.spawn(options.analyst, task, {
+        budget: options.budget,
+        label
+      });
+      if (!spawned.ok) {
+        throw new AnalystError(
+          `createScopeAnalyst: analyst spawn refused by the conserved pool (${spawned.reason}); cannot steer node ${stringifySafe(input.nodeId)} on an unrun analyst`
+        );
+      }
+      const settled = await drainAnalystSettlement(scope, spawned.handle.id);
+      const findings = readAnalystFindings(settled);
+      assertTraceDerivedFindings2(findings);
+      return findings;
+    }
+  };
+}
+async function drainAnalystSettlement(scope, analystId) {
+  for (; ; ) {
+    const settled = await scope.next();
+    if (settled === null) {
+      throw new AnalystError(
+        `createScopeAnalyst: scope drained before analyst ${stringifySafe(analystId)} settled`
+      );
+    }
+    if (settled.handle.id === analystId) return settled;
+  }
+}
+function readAnalystFindings(settled) {
+  if (settled.kind === "down") {
+    throw new AnalystError(
+      `createScopeAnalyst: analyst ${stringifySafe(settled.handle.id)} settled down (${settled.infra ? "infra" : "result"}): ${stringifySafe(settled.reason)}`
+    );
+  }
+  const out = settled.out;
+  if (!Array.isArray(out)) {
+    throw new PlannerError(
+      `createScopeAnalyst: analyst ${stringifySafe(settled.handle.id)} must return AnalystFinding[], got ${stringifySafe(out)}`
+    );
+  }
+  return out;
+}
+function buildSteerContext(findings, settledSoFar) {
+  assertTraceDerivedFindings2(findings);
+  const lastValidScore = observedBestScore(settledSoFar);
+  return {
+    findings,
+    settledSoFar,
+    ...lastValidScore !== void 0 ? { lastValidScore } : {}
+  };
+}
+function observedBestScore(settledSoFar) {
+  let best;
+  for (const s of settledSoFar) {
+    if (s.kind !== "done") continue;
+    const v = s.verdict;
+    if (!v || v.valid !== true || typeof v.score !== "number") continue;
+    if (best === void 0 || v.score > best) best = v.score;
+  }
+  return best;
+}
+
+// src/runtime/supervise/scope.ts
+function createScope(args) {
+  const children = /* @__PURE__ */ new Map();
+  let spawnOrdinal = 0;
+  let cursorSeq = 0;
+  const now = args.now ?? Date.now;
+  function spawn2(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 LeafExecutor`
+      );
+    }
+    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 };
+      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: zeroSpend2(),
+        settled: void 0,
+        delivered: 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(
+          `scope.next: child '${chosen.id}' won the settle race without a resolved value`
+        );
+      }
+      return finalizeSettlement(chosen, 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;
+  }
+  return {
+    spawn: spawn2,
+    next,
+    send,
+    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()
+    });
+    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()
+  });
+  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);
+    }
+    if (childAbort.signal.aborted) {
+      await teardownSafe(executor, opts.shutdown ?? "brutalKill");
+      return downRecord("aborted before settle", true);
+    }
+    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
+    };
+  } catch (err) {
+    reconcileOnce(live.spent);
+    await teardownSafe(executor, "brutalKill");
+    const aborted = childAbort.signal.aborted || isAbortError2(err);
+    return downRecord(errMessage(err), aborted || isInfraError(err));
+  }
+}
+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) {
+  return { kind: "down", reason, infra, restartCount: 0 };
+}
+function zeroSpend2() {
+  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/runtime/personify/combinators.ts
+function pipeline(stages) {
+  if (stages.length === 0) {
+    throw new ValidationError("pipeline: at least one stage is required");
+  }
+  return (ctx) => ({
+    name: `${ctx.persona.name}/pipeline`,
+    async act(task, scope) {
+      let carry = task;
+      for (const stage of stages) {
+        const child = ctx.spawnChild(stage.label, ctx.persona.root);
+        const res = scope.spawn(child, stage.feed(carry, ctx, task), {
+          budget: ctx.budget.perChild,
+          label: stage.label
+        });
+        if (!res.ok) {
+          return blocked([`${stage.label}: not admitted (${res.reason})`]);
+        }
+        const settled = await drainOne(scope, stage.label);
+        const out = stage.collect(settled);
+        if (out.kind === "blocked") return out;
+        carry = out.deliverable;
+      }
+      return { kind: "done", deliverable: carry };
+    }
+  });
+}
+function fanout(items, opts) {
+  return (ctx) => ({
+    name: `${ctx.persona.name}/fanout`,
+    async act(_task, scope) {
+      const rejected = [];
+      let opened = 0;
+      for (const [i, item] of items.entries()) {
+        const label = opts.label ? opts.label(item, i) : `item:${i}`;
+        const child = ctx.spawnChild(label, ctx.persona.root);
+        const res = scope.spawn(child, opts.itemTask(item, i, ctx), {
+          budget: ctx.budget.perChild,
+          label
+        });
+        if (res.ok) opened += 1;
+        else rejected.push(`${label}: not admitted (${res.reason})`);
+      }
+      if (opened === 0) {
+        return blocked(
+          rejected.length > 0 ? rejected : ["fanout: budget admitted no item (fanout fully rejected)"]
+        );
+      }
+      const drained = await drain(scope);
+      if (drained.done.length === 0) {
+        return blocked(
+          orderedBlockers(
+            drained.blockers,
+            rejected,
+            "fanout: every item settled without a usable result"
+          )
+        );
+      }
+      if (!opts.synthesize) {
+        const winner = defaultSelectWinner(drained.iterations);
+        if (!winner || winner.output === void 0) {
+          return blocked(
+            orderedBlockers(drained.blockers, rejected, "fanout: no item survived selection")
+          );
+        }
+        return { kind: "done", deliverable: winner.output };
+      }
+      const synthLabel = "synthesize";
+      const synthChild = ctx.spawnChild(synthLabel, ctx.persona.root);
+      const synthRes = scope.spawn(synthChild, opts.synthesize.synthesisTask(drained.done, ctx), {
+        budget: ctx.budget.perChild,
+        label: synthLabel
+      });
+      if (!synthRes.ok) {
+        return blocked([...drained.blockers, `${synthLabel}: not admitted (${synthRes.reason})`]);
+      }
+      const synthSettled = await drainOne(scope, synthLabel);
+      const out = opts.synthesize.collect(synthSettled);
+      if (out.kind === "blocked") return out;
+      return out;
+    }
+  });
+}
+function loopUntil(seed, spec) {
+  return (ctx) => ({
+    name: `${ctx.persona.name}/loopUntil`,
+    async act(task, scope) {
+      let state = { round: 0, value: seed };
+      const blockers = [];
+      for (; ; ) {
+        const label = spec.label ? spec.label(state.round) : `step:${state.round}`;
+        const child = ctx.spawnChild(label, ctx.persona.root);
+        const res = scope.spawn(child, spec.step(task, state, ctx), {
+          budget: ctx.budget.perChild,
+          label
+        });
+        if (!res.ok) {
+          if (state.round === 0) return blocked([`${label}: not admitted (${res.reason})`]);
+          break;
+        }
+        const settled = await drainOne(scope, label);
+        if (settled.kind === "down") blockers.push(blockerFromDown(settled));
+        state = spec.fold(state, settled);
+        const reached = spec.until(state, []);
+        if (reached) return reached;
+        state = { round: state.round + 1, value: state.value };
+      }
+      return blocked(
+        blockers.length > 0 ? blockers : ["loopUntil: budget exhausted before the satisfiability gate was reached"]
+      );
+    }
+  });
+}
+function panel(spec) {
+  if (spec.judges.length === 0) {
+    throw new ValidationError("panel: at least one judge is required");
+  }
+  return (ctx) => ({
+    name: `${ctx.persona.name}/panel`,
+    async act(task, scope) {
+      const artifact = task;
+      const byLabel = /* @__PURE__ */ new Map();
+      const rejected = [];
+      let opened = 0;
+      for (const judge of spec.judges) {
+        const child = ctx.spawnChild(judge.label, ctx.persona.root);
+        const res = scope.spawn(child, spec.judgeTask(artifact, judge, ctx), {
+          budget: ctx.budget.perChild,
+          label: judge.label
+        });
+        if (res.ok) {
+          byLabel.set(judge.label, judge);
+          opened += 1;
+        } else {
+          rejected.push(`${judge.label}: not admitted (${res.reason})`);
+        }
+      }
+      if (opened === 0) {
+        return blocked(rejected.length > 0 ? rejected : ["panel: budget admitted no judge"]);
+      }
+      const verdicts = [];
+      for (let s = await scope.next(); s !== null; s = await scope.next()) {
+        const judge = byLabel.get(s.handle.label);
+        if (!judge) {
+          throw new ValidationError(
+            `panel: settled child "${s.handle.label}" has no judge descriptor`
+          );
+        }
+        if (s.kind === "down") {
+          verdicts.push({ judge, down: true });
+          continue;
+        }
+        verdicts.push({
+          judge,
+          down: false,
+          ...s.verdict ? { verdict: s.verdict } : {},
+          output: s.out
+        });
+      }
+      return spec.merge(verdicts, artifact);
+    }
+  });
+}
+function verify(spec) {
+  return (ctx) => ({
+    name: `${ctx.persona.name}/verify`,
+    async act(task, scope) {
+      const implementLabel = spec.implementLabel ?? "implement";
+      const implChild = ctx.spawnChild(implementLabel, ctx.persona.root);
+      const implRes = scope.spawn(implChild, spec.implement(task, ctx), {
+        budget: ctx.budget.perChild,
+        label: implementLabel
+      });
+      if (!implRes.ok) return blocked([`${implementLabel}: not admitted (${implRes.reason})`]);
+      const candidate = await drainOne(scope, implementLabel);
+      if (candidate.kind === "down") return blocked([blockerFromDown(candidate)]);
+      const verifierLabel = spec.verifierLabel ?? "verify";
+      const verifierChild = ctx.spawnChild(verifierLabel, ctx.persona.root);
+      const verifierRes = scope.spawn(
+        verifierChild,
+        spec.verifier(candidate, ctx),
+        { budget: ctx.budget.perChild, label: verifierLabel }
+      );
+      if (!verifierRes.ok)
+        return blocked([`${verifierLabel}: not admitted (${verifierRes.reason})`]);
+      const gate = await drainOne(scope, verifierLabel);
+      if (gate.kind === "down") return blocked([blockerFromDown(gate)]);
+      if (!gate.verdict || gate.verdict.valid !== true) {
+        return blocked([`${verifierLabel}: gate rejected the candidate (${verdictDetail(gate)})`]);
+      }
+      return spec.collect(candidate, gate.verdict);
+    }
+  });
+}
+function widen(spec) {
+  return (ctx) => ({
+    name: `${ctx.persona.name}/widen`,
+    async act(_task, scope) {
+      let opened = 0;
+      for (const [i, seed] of spec.seeds.entries()) {
+        const label = `seed:${i}`;
+        const child = ctx.spawnChild(label, ctx.persona.root);
+        const res = scope.spawn(child, spec.seedTask(seed, i, ctx), {
+          budget: ctx.budget.perChild,
+          label
+        });
+        if (res.ok) opened += 1;
+      }
+      if (opened === 0) {
+        return blocked(["widen: budget admitted no seed lineage"]);
+      }
+      const gathered = [];
+      let widenIndex = 0;
+      for (let s = await scope.next(); s !== null; s = await scope.next()) {
+        gathered.push(s);
+        const decision = spec.gate.decide(s, [], scope.budget);
+        if (decision.kind !== "widen") continue;
+        const label = `widen:${widenIndex}`;
+        widenIndex += 1;
+        const child = ctx.spawnChild(label, ctx.persona.root);
+        scope.spawn(child, spec.widenTask(decision.toward, ctx), {
+          budget: ctx.budget.perChild,
+          label
+        });
+      }
+      const done = gathered.filter(isDone);
+      if (done.length === 0) {
+        return blocked(
+          orderedBlockers(
+            gathered.filter(isDown).map(blockerFromDown),
+            [],
+            "widen: every lineage settled without a usable result"
+          )
+        );
+      }
+      return spec.synthesize(done, ctx);
+    }
+  });
+}
+function flatWidenGate() {
+  return {
+    decide() {
+      return { kind: "stop" };
+    }
+  };
+}
+async function drain(scope) {
+  const iterations = [];
+  const done = [];
+  const blockers = [];
+  for (let s = await scope.next(); s !== null; s = await scope.next()) {
+    if (s.kind === "down") {
+      blockers.push(blockerFromDown(s));
+      continue;
+    }
+    iterations.push(settledToIteration(s));
+    done.push(s);
+  }
+  return { iterations, done, blockers };
+}
+async function drainOne(scope, label) {
+  const s = await scope.next();
+  if (s === null) {
+    throw new ValidationError(`combinator: child "${label}" was spawned but never settled`);
+  }
+  return s;
+}
+function isDone(s) {
+  return s.kind === "done";
+}
+function isDown(s) {
+  return s.kind === "down";
+}
+function blockerFromDown(s) {
+  return `${s.handle.label}: ${s.infra ? "infra" : "failed"} \u2014 ${s.reason}`;
+}
+function verdictDetail(s) {
+  if (!s.verdict) return "no verdict";
+  return s.verdict.notes ?? `score ${s.verdict.score}`;
+}
+function orderedBlockers(drained, rejected, fallback) {
+  const all = [...drained, ...rejected];
+  return all.length > 0 ? all : [fallback];
+}
+function blocked(blockers) {
+  if (blockers.length === 0) {
+    throw new ValidationError("combinator: a blocked outcome must name at least one blocker");
+  }
+  return { kind: "blocked", blockers };
+}
+
+// src/runtime/personify/corpus.ts
+var corpusSchemaVersion = "1.0.0";
+function assertCorpusRecord(value, where) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error(`${where}: corpus record is not an object`);
+  }
+  const r = value;
+  if (r.schemaVersion !== corpusSchemaVersion) {
+    throw new Error(
+      `${where}: corpus record schemaVersion '${String(r.schemaVersion)}' != '${corpusSchemaVersion}'`
+    );
+  }
+  requireNonEmptyString(r.id, `${where}.id`);
+  requireNonEmptyString(r.runId, `${where}.runId`);
+  requireNonEmptyString(r.producedAt, `${where}.producedAt`);
+  requireNonEmptyString(r.area, `${where}.area`);
+  requireNonEmptyString(r.claim, `${where}.claim`);
+  if (r.rationale !== void 0 && typeof r.rationale !== "string") {
+    throw new Error(`${where}.rationale: expected string, got ${typeof r.rationale}`);
+  }
+  if (!Array.isArray(r.tags) || r.tags.some((t) => typeof t !== "string")) {
+    throw new Error(`${where}.tags: expected string[]`);
+  }
+  if (typeof r.confidence !== "number" || !Number.isFinite(r.confidence)) {
+    throw new Error(`${where}.confidence: expected a finite number, got ${String(r.confidence)}`);
+  }
+  if (r.confidence < 0 || r.confidence > 1) {
+    throw new Error(`${where}.confidence: ${r.confidence} is outside the [0, 1] range`);
+  }
+  if (r.evidence !== void 0) {
+    if (!Array.isArray(r.evidence)) {
+      throw new Error(`${where}.evidence: expected an array`);
+    }
+    for (let i = 0; i < r.evidence.length; i++) {
+      const ev = r.evidence[i];
+      if (typeof ev !== "object" || ev === null) {
+        throw new Error(`${where}.evidence[${i}]: not an object`);
+      }
+      requireNonEmptyString(ev.kind, `${where}.evidence[${i}].kind`);
+      requireNonEmptyString(ev.uri, `${where}.evidence[${i}].uri`);
+    }
+  }
+}
+function requireNonEmptyString(value, where) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${where}: expected a non-empty string, got ${describe(value)}`);
+  }
+}
+function describe(value) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "string") return `'${value}'`;
+  return typeof value;
+}
+function recordsEqual(a, b) {
+  return stableStringify2(a) === stableStringify2(b);
+}
+function stableStringify2(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(stableStringify2).join(",")}]`;
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([x], [y]) => x < y ? -1 : x > y ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify2(v)}`).join(",")}}`;
+}
+function applyFilter(records, filter) {
+  const matched = records.filter((r) => {
+    if (filter.area !== void 0 && r.area !== filter.area) return false;
+    if (filter.runId !== void 0 && r.runId !== filter.runId) return false;
+    if (filter.minConfidence !== void 0 && r.confidence < filter.minConfidence) return false;
+    if (filter.tags !== void 0 && !filter.tags.every((t) => r.tags.includes(t))) return false;
+    return true;
+  });
+  const ordered = [...matched].sort(
+    (a, b) => b.confidence !== a.confidence ? b.confidence - a.confidence : b.producedAt < a.producedAt ? -1 : b.producedAt > a.producedAt ? 1 : 0
+  );
+  if (filter.limit !== void 0) {
+    if (!Number.isInteger(filter.limit) || filter.limit < 0) {
+      throw new Error(
+        `corpus query: filter.limit must be a non-negative integer, got ${filter.limit}`
+      );
+    }
+    return ordered.slice(0, filter.limit);
+  }
+  return ordered;
+}
+var InMemoryCorpus = class {
+  byId = /* @__PURE__ */ new Map();
+  async append(record) {
+    try {
+      assertCorpusRecord(record, "append: record");
+    } catch (err) {
+      return { succeeded: false, error: err instanceof Error ? err.message : String(err) };
+    }
+    const existing = this.byId.get(record.id);
+    if (existing) {
+      if (recordsEqual(existing, record)) return { succeeded: true };
+      return {
+        succeeded: false,
+        error: `corpus conflict: id '${record.id}' is already stored with a different record; a learned fact is append-only \u2014 re-mint the id or reconcile before re-appending`
+      };
+    }
+    this.byId.set(record.id, freeze(record));
+    return { succeeded: true };
+  }
+  async query(filter) {
+    return applyFilter([...this.byId.values()], filter);
+  }
+};
+var FileCorpus = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  async append(record) {
+    try {
+      assertCorpusRecord(record, "append: record");
+    } catch (err) {
+      return { succeeded: false, error: err instanceof Error ? err.message : String(err) };
+    }
+    let stored;
+    try {
+      stored = await this.load();
+    } catch (err) {
+      return { succeeded: false, error: err instanceof Error ? err.message : String(err) };
+    }
+    const existing = stored.get(record.id);
+    if (existing) {
+      if (recordsEqual(existing, record)) return { succeeded: true };
+      return {
+        succeeded: false,
+        error: `corpus conflict: id '${record.id}' is already stored in ${this.path} with a different record; a learned fact is append-only \u2014 re-mint the id or reconcile before re-appending`
+      };
+    }
+    await this.appendLine(record);
+    return { succeeded: true };
+  }
+  async query(filter) {
+    const stored = await this.load();
+    return applyFilter([...stored.values()], filter);
+  }
+  async load() {
+    const fs = await import("fs/promises");
+    let text;
+    try {
+      text = await fs.readFile(this.path, "utf8");
+    } catch (err) {
+      if (isNoEntError2(err)) return /* @__PURE__ */ new Map();
+      throw err;
+    }
+    const lines = text.split("\n").filter((line) => line.length > 0);
+    const byId = /* @__PURE__ */ new Map();
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch (err) {
+        throw new Error(
+          `corpus corrupted: ${this.path} line ${i + 1} is not valid JSON: ` + (err instanceof Error ? err.message : String(err))
+        );
+      }
+      assertCorpusRecord(parsed, `corpus ${this.path} line ${i + 1}`);
+      const existing = byId.get(parsed.id);
+      if (existing && !recordsEqual(existing, parsed)) {
+        throw new Error(
+          `corpus corrupted: ${this.path} has two different records for id '${parsed.id}'; an append-only corpus must never hold a conflicting re-append under one id`
+        );
+      }
+      byId.set(parsed.id, freeze(parsed));
+    }
+    return byId;
+  }
+  async appendLine(record) {
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    await fs.mkdir(path.dirname(this.path), { recursive: true });
+    const fh = await fs.open(this.path, "a");
+    try {
+      await fh.write(`${JSON.stringify(record)}
+`);
+      await fh.sync();
+    } finally {
+      await fh.close();
+    }
+  }
+};
+async function renderCorpusToInstructions(opts) {
+  const { corpus, filter, profile, target = "prompt", maxLines } = opts;
+  if (maxLines !== void 0 && (!Number.isInteger(maxLines) || maxLines < 0)) {
+    throw new Error(
+      `renderCorpusToInstructions: maxLines must be a non-negative integer, got ${maxLines}`
+    );
+  }
+  const matched = await corpus.query(filter);
+  const capped = maxLines !== void 0 ? matched.slice(0, maxLines) : matched;
+  const lines = capped.map(renderLine);
+  if (lines.length === 0) return structuredClone(profile);
+  const next = structuredClone(profile);
+  if (target === "resources") {
+    const resources = next.resources ?? {};
+    const prior = resources.instructions;
+    if (prior !== void 0 && typeof prior !== "string") {
+      throw new Error(
+        "renderCorpusToInstructions: resources.instructions is an AgentProfileResourceRef, not a string; cannot string-append corpus facts without dropping the ref (pass target: 'prompt' or pre-resolve the ref)"
+      );
+    }
+    const blob = [prior, ...lines].filter((s) => typeof s === "string" && s.length > 0);
+    next.resources = { ...resources, instructions: blob.join("\n") };
+    return next;
+  }
+  const prompt = next.prompt ?? {};
+  next.prompt = { ...prompt, instructions: [...prompt.instructions ?? [], ...lines] };
+  return next;
+}
+function renderLine(record) {
+  return record.rationale ? `${record.claim} (${record.rationale})` : record.claim;
+}
+function freeze(record) {
+  return Object.freeze({ ...record });
+}
+function isNoEntError2(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+
+// src/runtime/supervise/runtime.ts
+import { spawn } from "child_process";
+import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
+var routerSeamKey = "router";
+var sandboxSeamKey = "sandbox";
+var cliSeamKey = "cli";
+function contentRef(prefix, value) {
+  let str;
+  try {
+    str = JSON.stringify(value) ?? String(value);
+  } catch {
+    str = String(value);
+  }
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i += 1) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return `${prefix}:${(h >>> 0).toString(16).padStart(8, "0")}`;
+}
+function zeroSpend3() {
+  return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
+}
+var routerInlineExecutor = (spec, ctx) => {
+  const seam = readSeam(ctx, routerSeamKey, "router/inline");
+  const model = seam.model ?? spec.profile.model?.default;
+  if (!model) {
+    throw new ValidationError(
+      "routerInlineExecutor: no model \u2014 set RouterSeam.model or AgentProfile.model.default"
+    );
+  }
+  if (!seam.routerBaseUrl || !seam.routerKey) {
+    throw new ValidationError("routerInlineExecutor: RouterSeam.routerBaseUrl + routerKey required");
+  }
+  const controller = new AbortController();
+  const abortIfSignalled = () => {
+    if (ctx.signal.aborted) controller.abort();
+  };
+  abortIfSignalled();
+  if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+  let artifact;
+  return {
+    runtime: "router",
+    async execute(task, signal) {
+      const messages = taskToMessages(task, spec);
+      const started = Date.now();
+      const linked = linkSignals(signal, controller.signal);
+      const res = await fetch(`${seam.routerBaseUrl.replace(/\/$/, "")}/chat/completions`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${seam.routerKey}` },
+        body: JSON.stringify({ model, messages, temperature: 0.2 }),
+        ...linked ? { signal: linked } : {}
+      });
+      if (!res.ok) {
+        throw new ValidationError(
+          `routerInlineExecutor: router ${res.status}: ${(await res.text()).slice(0, 200)}`
+        );
+      }
+      const data = await res.json();
+      const u = data.usage;
+      const usage = u && typeof u.prompt_tokens === "number" && typeof u.completion_tokens === "number" ? { input: u.prompt_tokens, output: u.completion_tokens } : void 0;
+      const usd = usage && isModelPriced(model) ? estimateCost(usage.input, usage.output, model) : 0;
+      const content = data.choices?.[0]?.message?.content ?? "";
+      const spent = {
+        iterations: 1,
+        tokens: usage ? { input: usage.input, output: usage.output } : zeroTokenUsage(),
+        usd,
+        ms: Date.now() - started
+      };
+      const out = { content };
+      artifact = { outRef: contentRef("router", { model, content }), out, spent };
+      return artifact;
+    },
+    teardown(_grace) {
+      controller.abort();
+      return Promise.resolve({ destroyed: true });
+    },
+    resultArtifact() {
+      if (!artifact) {
+        throw new ValidationError("routerInlineExecutor: resultArtifact() read before execute()");
+      }
+      return { ...artifact, spent: artifact.spent };
+    }
+  };
+};
+var sandboxExecutor = (spec, ctx) => {
+  if (spec.harness === null) {
+    throw new ValidationError("sandboxExecutor: harness is null (router/inline) \u2014 wrong executor");
+  }
+  const harness = spec.harness;
+  const seam = readSeam(ctx, sandboxSeamKey, "sandbox");
+  if (!seam.sandboxClient || typeof seam.sandboxClient.create !== "function") {
+    throw new ValidationError("sandboxExecutor: SandboxSeam.sandboxClient.create required");
+  }
+  const maxIterations = seam.maxIterations ?? 1;
+  if (!Number.isFinite(maxIterations) || maxIterations <= 0) {
+    throw new ValidationError("sandboxExecutor: maxIterations must be > 0");
+  }
+  const controller = new AbortController();
+  const abortIfSignalled = () => {
+    if (ctx.signal.aborted) controller.abort();
+  };
+  abortIfSignalled();
+  if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+  let artifact;
+  const output = {
+    parse(events) {
+      return { events };
+    }
+  };
+  const driver = singleShotDriver(maxIterations);
+  return {
+    runtime: "sandbox",
+    execute(task, signal) {
+      return streamSandboxLeaf({
+        task,
+        signal,
+        harness,
+        spec,
+        seam,
+        output,
+        driver,
+        maxIterations,
+        controller,
+        loopCtx: seam.loopCtx,
+        onArtifact: (a) => {
+          artifact = a;
+        }
+      });
+    },
+    teardown(_grace) {
+      controller.abort();
+      return Promise.resolve({ destroyed: true });
+    },
+    resultArtifact() {
+      if (!artifact) {
+        throw new ValidationError("sandboxExecutor: resultArtifact() read before stream drained");
+      }
+      return artifact;
+    }
+  };
+};
+async function* streamSandboxLeaf(args) {
+  const linked = new AbortController();
+  const cascade = () => linked.abort();
+  if (args.signal.aborted || args.controller.signal.aborted) linked.abort();
+  else {
+    args.signal.addEventListener("abort", cascade, { once: true });
+    args.controller.signal.addEventListener("abort", cascade, { once: true });
+  }
+  const agentRun = {
+    profile: args.spec.profile,
+    taskToPrompt: (t) => taskToPrompt(t),
+    name: args.spec.profile.name ?? args.harness,
+    sandboxOverrides: { backend: { type: args.harness } }
+  };
+  const started = Date.now();
+  const loopOptions = {
+    driver: args.driver,
+    agentRun,
+    output: args.output,
+    task: args.task,
+    maxIterations: args.maxIterations,
+    maxConcurrency: 1,
+    ctx: {
+      ...args.loopCtx ?? {},
+      sandboxClient: args.seam.sandboxClient,
+      signal: linked.signal
+    },
+    ...args.seam.lineage !== void 0 ? { lineage: args.seam.lineage } : {}
+  };
+  try {
+    const result = await runLoop(loopOptions);
+    const out = result.winner?.output ?? { events: [] };
+    const verdict = result.winner?.verdict;
+    const spent = {
+      iterations: result.iterations.length,
+      tokens: { input: result.tokenUsage.input, output: result.tokenUsage.output },
+      usd: result.costUsd,
+      ms: Date.now() - started
+    };
+    args.onArtifact({
+      outRef: contentRef("sandbox", { harness: args.harness, out }),
+      out,
+      ...verdict ? { verdict } : {},
+      spent
+    });
+    for (let i = 0; i < result.iterations.length; i += 1) yield { kind: "iteration" };
+    if (result.tokenUsage.input || result.tokenUsage.output) {
+      yield { kind: "tokens", input: result.tokenUsage.input, output: result.tokenUsage.output };
+    }
+    if (result.costUsd) yield { kind: "cost", usd: result.costUsd };
+  } finally {
+    args.signal.removeEventListener("abort", cascade);
+    args.controller.signal.removeEventListener("abort", cascade);
+  }
+}
+var cliExecutor = (_spec, ctx) => {
+  const seam = readSeam(ctx, cliSeamKey, "cli");
+  if (!seam.bin) throw new ValidationError("cliExecutor: CliSeam.bin required");
+  const controller = new AbortController();
+  const abortIfSignalled = () => {
+    if (ctx.signal.aborted) controller.abort();
+  };
+  abortIfSignalled();
+  if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+  let proc;
+  let artifact;
+  return {
+    runtime: "cli",
+    budgetExempt: true,
+    execute(task, signal) {
+      return streamCliLeaf({
+        task,
+        signal,
+        seam,
+        controller,
+        onProc: (p) => {
+          proc = p;
+        },
+        onArtifact: (a) => {
+          artifact = a;
+        }
+      });
+    },
+    async teardown(grace) {
+      controller.abort();
+      if (!proc || proc.exitCode !== null || proc.killed) return { destroyed: true };
+      return killWithGrace(proc, grace);
+    },
+    resultArtifact() {
+      if (!artifact) {
+        throw new ValidationError("cliExecutor: resultArtifact() read before stream drained");
+      }
+      return artifact;
+    }
+  };
+};
+async function* streamCliLeaf(args) {
+  const prompt = taskToPrompt(args.task);
+  const proc = spawn(args.seam.bin, args.seam.args ?? [], {
+    ...args.seam.cwd ? { cwd: args.seam.cwd } : {},
+    env: { ...process.env, ...args.seam.env ?? {} },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  args.onProc(proc);
+  const onAbort = () => killWithGrace(proc, "brutalKill");
+  if (args.signal.aborted || args.controller.signal.aborted) onAbort();
+  else {
+    args.signal.addEventListener("abort", onAbort, { once: true });
+    args.controller.signal.addEventListener("abort", onAbort, { once: true });
+  }
+  if (proc.stdin) {
+    proc.stdin.write(prompt);
+    proc.stdin.end();
+  }
+  const chunks = [];
+  const errChunks = [];
+  if (proc.stdout) proc.stdout.on("data", (d) => chunks.push(d.toString("utf8")));
+  if (proc.stderr) proc.stderr.on("data", (d) => errChunks.push(d.toString("utf8")));
+  const exit = await new Promise((resolve) => {
+    proc.once("error", (err) => resolve({ code: null, error: err }));
+    proc.once("close", (code) => resolve({ code }));
+  });
+  args.signal.removeEventListener("abort", onAbort);
+  args.controller.signal.removeEventListener("abort", onAbort);
+  if (exit.error) {
+    throw new ValidationError(`cliExecutor: spawn failed: ${exit.error.message}`, {
+      cause: exit.error
+    });
+  }
+  if (exit.code !== 0) {
+    throw new ValidationError(
+      `cliExecutor: ${args.seam.bin} exited ${exit.code}: ${errChunks.join("").slice(0, 200)}`
+    );
+  }
+  const out = { content: chunks.join("") };
+  args.onArtifact({ outRef: contentRef("cli", out), out, spent: zeroSpend3() });
+  yield { kind: "iteration" };
+}
+function killWithGrace(proc, grace) {
+  if (proc.exitCode !== null || proc.killed) return Promise.resolve({ destroyed: true });
+  return new Promise((resolve) => {
+    let timer;
+    proc.once("close", () => {
+      if (timer) clearTimeout(timer);
+      resolve({ destroyed: true });
+    });
+    if (grace === "brutalKill") {
+      proc.kill("SIGKILL");
+      return;
+    }
+    proc.kill("SIGTERM");
+    if (grace === "infinity") return;
+    timer = setTimeout(() => {
+      if (proc.exitCode === null && !proc.killed) proc.kill("SIGKILL");
+    }, grace);
+  });
+}
+function createExecutorRegistry() {
+  const factories = /* @__PURE__ */ new Map();
+  factories.set("router", routerInlineExecutor);
+  factories.set("inline", routerInlineExecutor);
+  factories.set("sandbox", sandboxExecutor);
+  factories.set("cli", cliExecutor);
+  return {
+    register(runtime, factory) {
+      if (factories.has(runtime)) {
+        throw new ValidationError(`executor registry: runtime "${runtime}" already registered`);
+      }
+      factories.set(runtime, factory);
+    },
+    resolve(spec) {
+      if (spec.executor) {
+        const byo = spec.executor;
+        return { succeeded: true, value: (() => byo) };
+      }
+      if (spec.harness === null) {
+        const f2 = factories.get("router");
+        if (!f2) return { succeeded: false, error: 'executor registry: no "router" factory' };
+        return { succeeded: true, value: f2 };
+      }
+      const runtimeTag = "sandbox";
+      const f = factories.get(runtimeTag);
+      if (!f) {
+        return {
+          succeeded: false,
+          error: `executor registry: no factory for runtime "${runtimeTag}" (harness "${spec.harness}") and no BYO executor`
+        };
+      }
+      return { succeeded: true, value: f };
+    }
+  };
+}
+function readSeam(ctx, key, who) {
+  const seam = ctx.seams[key];
+  if (seam === void 0 || seam === null) {
+    throw new ValidationError(`${who} executor: missing required seam "${key}" on ExecutorContext`);
+  }
+  return seam;
+}
+function taskToPrompt(task) {
+  if (typeof task === "string") return task;
+  if (task && typeof task === "object") {
+    const obj = task;
+    for (const k of ["prompt", "content", "task", "message"]) {
+      if (typeof obj[k] === "string") return obj[k];
+    }
+  }
+  return JSON.stringify(task);
+}
+function taskToMessages(task, spec) {
+  const messages = [];
+  const system = spec.profile.prompt?.systemPrompt;
+  if (typeof system === "string" && system.length > 0) {
+    messages.push({ role: "system", content: system });
+  }
+  messages.push({ role: "user", content: taskToPrompt(task) });
+  return messages;
+}
+function singleShotDriver(maxIterations) {
+  return {
+    name: "leaf",
+    plan(task, history) {
+      return Promise.resolve(history.length >= maxIterations ? [] : [task]);
+    },
+    decide(history) {
+      return history.length >= maxIterations ? "stop" : "continue";
+    }
+  };
+}
+function linkSignals(a, b) {
+  if (a.aborted || b.aborted) {
+    const c2 = new AbortController();
+    c2.abort();
+    return c2.signal;
+  }
+  const c = new AbortController();
+  const onAbort = () => c.abort();
+  a.addEventListener("abort", onAbort, { once: true });
+  b.addEventListener("abort", onAbort, { once: true });
+  return c.signal;
+}
+
+// src/runtime/supervise/budget.ts
+function spendFromUsageEvents(events) {
+  const tokens = zeroTokenUsage();
+  let usd = 0;
+  let iterations = 0;
+  for (const ev of events) {
+    if (ev.kind === "tokens") {
+      addTokenUsage(tokens, { input: ev.input, output: ev.output });
+    } else if (ev.kind === "cost") {
+      usd += ev.usd;
+    } else {
+      iterations += 1;
+    }
+  }
+  return { iterations, tokens, usd, ms: 0 };
+}
+async function foldUsage(events) {
+  if (Array.isArray(events)) return spendFromUsageEvents(events);
+  const tokens = zeroTokenUsage();
+  let usd = 0;
+  let iterations = 0;
+  for await (const ev of events) {
+    if (ev.kind === "tokens") {
+      addTokenUsage(tokens, { input: ev.input, output: ev.output });
+    } else if (ev.kind === "cost") {
+      usd += ev.usd;
+    } else {
+      iterations += 1;
+    }
+  }
+  return { iterations, tokens, usd, ms: 0 };
+}
+function totalTokens(usage) {
+  return usage.input + usage.output;
+}
+function createBudgetPool(root, now = Date.now) {
+  let freeTokens = root.maxTokens;
+  let reservedTokens = 0;
+  let committedTokens = 0;
+  const usdCapped = root.maxUsd !== void 0;
+  let freeUsd = root.maxUsd ?? 0;
+  let reservedUsd = 0;
+  let committedUsd = 0;
+  let freeIterations = root.maxIterations;
+  let reservedIterations = 0;
+  let committedIterations = 0;
+  const absoluteDeadlineMs = root.deadlineMs !== void 0 ? now() + root.deadlineMs : 0;
+  let nextTicketId = 0;
+  const open = /* @__PURE__ */ new Set();
+  function reserve(b) {
+    const wantTokens = b.maxTokens;
+    const wantUsd = b.maxUsd ?? 0;
+    const wantIterations = b.maxIterations;
+    if (wantTokens > freeTokens) return { ok: false, reason: "budget-exhausted" };
+    if (wantIterations > freeIterations) return { ok: false, reason: "budget-exhausted" };
+    if (wantUsd > 0 && (!usdCapped || wantUsd > freeUsd)) {
+      return { ok: false, reason: "budget-exhausted" };
+    }
+    freeTokens -= wantTokens;
+    reservedTokens += wantTokens;
+    freeIterations -= wantIterations;
+    reservedIterations += wantIterations;
+    if (wantUsd > 0) {
+      freeUsd -= wantUsd;
+      reservedUsd += wantUsd;
+    }
+    const id = nextTicketId++;
+    open.add(id);
+    return {
+      ok: true,
+      ticket: { id, reserved: { tokens: wantTokens, usd: wantUsd, iterations: wantIterations } }
+    };
+  }
+  function reconcile(ticket, spent) {
+    if (!open.has(ticket.id)) {
+      throw new Error(`budget pool: reconcile of unknown or already-settled ticket ${ticket.id}`);
+    }
+    open.delete(ticket.id);
+    const { tokens: rTokens, usd: rUsd, iterations: rIterations } = ticket.reserved;
+    const spentTokens = totalTokens(spent.tokens);
+    if (spentTokens > rTokens) {
+      throw new Error(
+        `budget pool: ticket ${ticket.id} spent ${spentTokens} tokens > reserved ${rTokens}`
+      );
+    }
+    if (spent.iterations > rIterations) {
+      throw new Error(
+        `budget pool: ticket ${ticket.id} spent ${spent.iterations} iterations > reserved ${rIterations}`
+      );
+    }
+    if (usdCapped && spent.usd > rUsd) {
+      throw new Error(`budget pool: ticket ${ticket.id} spent $${spent.usd} > reserved $${rUsd}`);
+    }
+    reservedTokens -= rTokens;
+    committedTokens += spentTokens;
+    freeTokens += rTokens - spentTokens;
+    reservedIterations -= rIterations;
+    committedIterations += spent.iterations;
+    freeIterations += rIterations - spent.iterations;
+    if (usdCapped && rUsd > 0) {
+      reservedUsd -= rUsd;
+      committedUsd += spent.usd;
+      freeUsd += rUsd - spent.usd;
+    } else {
+      committedUsd += spent.usd;
+    }
+  }
+  function readout() {
+    return {
+      tokensLeft: freeTokens,
+      usdLeft: usdCapped ? freeUsd : 0,
+      deadlineMs: absoluteDeadlineMs,
+      reservedTokens
+    };
+  }
+  function assertNoOpenTickets() {
+    if (open.size > 0) {
+      throw new Error(
+        `budget pool: ${open.size} reservation(s) still open at join barrier (leaked ticket ids: ${[...open].join(", ")}) \u2014 conserved-pool invariant violated`
+      );
+    }
+  }
+  return {
+    reserve,
+    reconcile,
+    spendFrom: foldUsage,
+    readout,
+    assertNoOpenTickets
+  };
+}
+
+// src/runtime/supervise/supervisor.ts
+var defaultMaxDepth = 4;
+function createSupervisor() {
+  let attached;
+  async function run(root, task, opts) {
+    const now = opts.now ?? Date.now;
+    const pool = createBudgetPool(opts.budget, now);
+    await opts.journal.beginTree(opts.runId, new Date(now()).toISOString());
+    await opts.journal.appendEvent(opts.runId, {
+      kind: "spawned",
+      id: opts.runId,
+      label: "root",
+      budget: opts.budget,
+      runtime: "inline",
+      seq: 0,
+      at: new Date(now()).toISOString()
+    });
+    const controller = new AbortController();
+    const cascadeAbort = (reason) => {
+      if (controller.signal.aborted) return;
+      controller.abort(reason);
+    };
+    const onCallerAbort = () => cascadeAbort("caller signal aborted");
+    if (opts.signal) {
+      if (opts.signal.aborted) cascadeAbort("caller signal aborted");
+      else opts.signal.addEventListener("abort", onCallerAbort, { once: true });
+    }
+    const breaker = createIntensityBreaker(opts, () => cascadeAbort("intensity breaker tripped"));
+    const journal = wrapJournalForBreaker(opts.journal, breaker);
+    const scope = createScope({
+      parentId: opts.runId,
+      root: opts.runId,
+      pool,
+      journal,
+      blobs: opts.blobs,
+      executors: opts.executors,
+      seams: {},
+      depth: 0,
+      maxDepth: opts.maxDepth ?? defaultMaxDepth,
+      signal: controller.signal,
+      now,
+      hooks: opts.hooks
+    });
+    const openScope = scope;
+    if (attached) {
+      attached.bind({ scope: openScope, cascadeAbort, signal: pushRootSignal(cascadeAbort) });
+    }
+    let actOutcome;
+    try {
+      const out = await root.act(task, scope);
+      actOutcome = { ok: true, out };
+    } catch (error) {
+      actOutcome = { ok: false, error };
+    } finally {
+      await drainLiveChildren(openScope, controller);
+      if (opts.signal) opts.signal.removeEventListener("abort", onCallerAbort);
+      if (attached) attached.unbind();
+    }
+    const tree = scope.view;
+    if (actOutcome.ok) {
+      pool.assertNoOpenTickets();
+      const out = actOutcome.out;
+      const outRef = contentAddress(out);
+      await opts.blobs.put(outRef, out);
+      return {
+        kind: "winner",
+        out,
+        outRef,
+        tree,
+        spentTotal: await spentTotalFromJournal(journal, opts.runId)
+      };
+    }
+    return {
+      kind: "no-winner",
+      reason: classifyNoWinner(controller, pool, opts, breaker),
+      tree,
+      downCount: breaker.downCount()
+    };
+  }
+  function attach(h) {
+    const control = rootControls.get(h);
+    if (!control) {
+      throw new RuntimeRunStateError(
+        "supervisor.attach: handle was not minted by createRootHandle (no control channel)"
+      );
+    }
+    attached = control;
+  }
+  return { run, attach };
+}
+var rootControls = /* @__PURE__ */ new WeakMap();
+function createRootHandle() {
+  let binding;
+  const handle = {
+    view() {
+      if (!binding) {
+        throw new RuntimeRunStateError(
+          "RootHandle.view: handle is not bound to a live run (attach it before run, read after run starts)"
+        );
+      }
+      return binding.scope.view;
+    },
+    signal(msg) {
+      if (!binding) {
+        throw new RuntimeRunStateError("RootHandle.signal: handle is not bound to a live run");
+      }
+      binding.signal(msg);
+    },
+    abort(reason) {
+      if (!binding) {
+        throw new RuntimeRunStateError("RootHandle.abort: handle is not bound to a live run");
+      }
+      binding.cascadeAbort(reason ?? "root handle aborted");
+    }
+  };
+  rootControls.set(handle, {
+    bind(b) {
+      binding = b;
+    },
+    unbind() {
+      binding = void 0;
+    }
+  });
+  return handle;
+}
+function pushRootSignal(cascadeAbort) {
+  return (msg) => {
+    if (msg.kind === "cancel") cascadeAbort(msg.reason ?? "root signal: cancel");
+  };
+}
+function createIntensityBreaker(opts, trip) {
+  const max = opts.maxRestarts;
+  const within = opts.withinMs;
+  const armed = max !== void 0 && within !== void 0;
+  const recent = [];
+  let total = 0;
+  let isTripped = false;
+  return {
+    recordDown(at) {
+      total += 1;
+      if (!armed || isTripped) return;
+      recent.push(at);
+      const cutoff = at - within;
+      while (recent.length > 0 && recent[0] < cutoff) recent.shift();
+      if (recent.length > max) {
+        isTripped = true;
+        trip();
+      }
+    },
+    tripped() {
+      return isTripped;
+    },
+    downCount() {
+      return total;
+    }
+  };
+}
+function wrapJournalForBreaker(journal, breaker) {
+  return {
+    loadTree: (root) => journal.loadTree(root),
+    beginTree: (root, at) => journal.beginTree(root, at),
+    appendEvent: (root, ev) => {
+      if (ev.kind === "settled" && ev.status === "down") breaker.recordDown(Date.parse(ev.at));
+      return journal.appendEvent(root, ev);
+    }
+  };
+}
+async function drainLiveChildren(scope, controller) {
+  const hasLive = scope.view.inFlight > 0;
+  if (!hasLive) return;
+  if (!controller.signal.aborted) controller.abort();
+  await Promise.allSettled([drainCursor(scope)]);
+}
+async function drainCursor(scope) {
+  for (; ; ) {
+    const settled = await scope.next();
+    if (settled === null) return;
+  }
+}
+function classifyNoWinner(controller, pool, opts, breaker) {
+  if (breaker.tripped()) return "all-children-down";
+  if (controller.signal.aborted) return "aborted";
+  if (poolExhausted(pool, opts)) return "budget-exhausted";
+  return "all-children-down";
+}
+function poolExhausted(pool, opts) {
+  const r = pool.readout();
+  if (r.tokensLeft <= 0) return true;
+  if (opts.budget.maxUsd !== void 0 && r.usdLeft <= 0) return true;
+  if (opts.budget.deadlineMs !== void 0 && r.deadlineMs > 0 && (opts.now ?? Date.now)() >= r.deadlineMs) {
+    return true;
+  }
+  return false;
+}
+async function spentTotalFromJournal(journal, root) {
+  const events = await journal.loadTree(root);
+  if (events === void 0) {
+    throw new RuntimeRunStateError(
+      `supervisor: spawn tree '${root}' is missing from the journal after run (corrupted log)`
+    );
+  }
+  const total = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 };
+  for (const ev of events) {
+    if (ev.kind !== "settled") continue;
+    total.iterations += ev.spent.iterations;
+    total.tokens.input += ev.spent.tokens.input;
+    total.tokens.output += ev.spent.tokens.output;
+    total.usd += ev.spent.usd;
+    total.ms += ev.spent.ms;
+  }
+  return total;
+}
+
+// src/runtime/personify/registry.ts
+function createShapeRegistry() {
+  const shapes = /* @__PURE__ */ new Map();
+  return {
+    register(name, factory) {
+      if (shapes.has(name)) {
+        throw new ValidationError(`shape registry: shape "${name}" already registered`);
+      }
+      shapes.set(name, factory);
+    },
+    resolve(name) {
+      const factory = shapes.get(name);
+      if (!factory) {
+        return { succeeded: false, error: `shape registry: unknown shape "${name}"` };
+      }
+      return { succeeded: true, value: factory };
+    },
+    names() {
+      return [...shapes.keys()];
+    }
+  };
+}
+var builtinShapes = createShapeRegistry();
+function registerShape(name, factory) {
+  builtinShapes.register(name, factory);
+}
+
+// src/runtime/personify/persona.ts
+function definePersona(input) {
+  if (!input.executors.registry && !input.executors.seams) {
+    throw new ValidationError(
+      `definePersona("${input.name}"): executors must supply a registry or a seams bag (built-in runtimes read their seams off ExecutorContext; neither was provided)`
+    );
+  }
+  if (!input.root || typeof input.root !== "object" || !("harness" in input.root)) {
+    throw new ValidationError(`definePersona("${input.name}"): root must be an AgentSpec`);
+  }
+  return Object.freeze({
+    name: input.name,
+    root: input.root,
+    directive: input.directive,
+    context: input.context,
+    executors: input.executors,
+    ...input.extensions ? { extensions: input.extensions } : {}
+  });
+}
+function createShapeContext(persona, budget) {
+  return {
+    persona,
+    budget,
+    spawnChild(name, spec) {
+      const agent = {
+        name,
+        executorSpec: spec,
+        act() {
+          throw new ValidationError(
+            `personify: spawned child "${name}" was run as a driver; its executorSpec drives a leaf`
+          );
+        }
+      };
+      return agent;
+    },
+    childSpec(profile, harness) {
+      return {
+        profile,
+        harness: harness === void 0 ? persona.root.harness : harness,
+        ...persona.root.executor ? { executor: persona.root.executor } : {}
+      };
+    }
+  };
+}
+async function runPersonified(options) {
+  const { persona } = options;
+  const shape = resolveShape(options.shape);
+  const shapeBudget = resolveShapeBudget(options.budget, options.shapeBudget);
+  const ctx = createShapeContext(persona, shapeBudget);
+  const rootAgent = shape(ctx);
+  const executors = personaRegistry(persona);
+  const supervisor = createSupervisor();
+  if (options.handle) supervisor.attach(options.handle);
+  const supervisorOpts = {
+    budget: options.budget,
+    runId: options.runId ?? `${persona.name}:${shapeName(options.shape, shape)}`,
+    journal: options.journal ?? new InMemorySpawnJournal(),
+    blobs: options.blobs ?? new InMemoryResultBlobStore(),
+    executors,
+    ...options.maxDepth !== void 0 ? { maxDepth: options.maxDepth } : {},
+    ...options.maxRestarts !== void 0 ? { maxRestarts: options.maxRestarts } : {},
+    ...options.withinMs !== void 0 ? { withinMs: options.withinMs } : {},
+    ...options.now ? { now: options.now } : {},
+    ...options.signal ? { signal: options.signal } : {}
+  };
+  return supervisor.run(rootAgent, options.task, supervisorOpts);
+}
+function resolveShape(shape) {
+  if (typeof shape !== "string") return shape;
+  const resolved = builtinShapes.resolve(shape);
+  if (!resolved.succeeded) {
+    throw new ValidationError(
+      `runPersonified: ${resolved.error} (registered: ${builtinShapes.names().join(", ")})`
+    );
+  }
+  return resolved.value;
+}
+function shapeName(shape, _resolved) {
+  return typeof shape === "string" ? shape : shape.name || "shape";
+}
+function resolveShapeBudget(root, over) {
+  const fanout2 = over?.fanout ?? defaultFanout;
+  const perChild = over?.perChild ?? {
+    maxIterations: Math.max(1, Math.floor(root.maxIterations / fanout2)),
+    maxTokens: Math.max(1, Math.floor(root.maxTokens / fanout2)),
+    ...root.maxUsd !== void 0 ? { maxUsd: root.maxUsd / fanout2 } : {},
+    ...root.deadlineMs !== void 0 ? { deadlineMs: root.deadlineMs } : {}
+  };
+  return { perChild, fanout: fanout2 };
+}
+var defaultFanout = 3;
+function personaRegistry(persona) {
+  const { registry, seams } = persona.executors;
+  if (registry) return registry;
+  if (!seams) {
+    throw new ValidationError(
+      `personify: persona "${persona.name}" supplies neither a registry nor seams`
+    );
+  }
+  return withSeams(createExecutorRegistry(), seams);
+}
+function withSeams(base, seams) {
+  return {
+    register(runtime, factory) {
+      base.register(runtime, factory);
+    },
+    resolve(spec) {
+      const resolved = base.resolve(spec);
+      if (!resolved.succeeded) return resolved;
+      const inner = resolved.value;
+      const wrapped = (s, ctx) => inner(s, mergeSeams(ctx, seams));
+      return { succeeded: true, value: wrapped };
+    }
+  };
+}
+function mergeSeams(ctx, seams) {
+  return { signal: ctx.signal, seams: { ...seams, ...ctx.seams } };
+}
+
+// src/runtime/personify/trajectory.ts
+var defaultEqualKTolerance = 0.05;
+async function trajectoryReport(journal, blobs, root, options = {}) {
+  const events = await journal.loadTree(root);
+  if (events === void 0) {
+    throw new Error(`trajectoryReport: no journaled tree for root '${root}'`);
+  }
+  const spawns = events.filter(isSpawned).sort(bySeq);
+  const closes = events.filter((ev) => ev.kind !== "spawned").sort(bySeq);
+  const nodes = /* @__PURE__ */ new Map();
+  for (const ev of spawns) {
+    nodes.set(ev.id, {
+      id: ev.id,
+      parent: ev.parent,
+      label: ev.label,
+      runtime: ev.runtime,
+      status: "pending",
+      ownSpend: zeroSpend4(),
+      children: []
+    });
+  }
+  for (const ev of closes) {
+    const node = requireNode2(nodes, ev.id, root);
+    if (ev.kind === "cancelled") {
+      node.status = "cancelled";
+      continue;
+    }
+    node.status = ev.status === "done" ? "done" : "failed";
+    node.ownSpend = ev.spent;
+    node.verdict = ev.verdict;
+    node.outRef = ev.outRef;
+  }
+  if (!nodes.has(root)) {
+    throw new Error(
+      `trajectoryReport: root '${root}' has no spawned event in its journaled tree (corrupted log)`
+    );
+  }
+  for (const ev of spawns) {
+    if (ev.parent === void 0) continue;
+    requireNode2(nodes, ev.parent, root).children.push(ev.id);
+  }
+  const rolledUp = rollUpSpend(nodes, root);
+  if (options.withOutputs) {
+    await attachOutputs(nodes, blobs);
+  }
+  const ordered = spawns.map((ev) => nodes.get(ev.id)).filter(isNode);
+  const reported = ordered.map(
+    (node) => freezeNode(node, requireSpend(rolledUp, node.id, root))
+  );
+  return {
+    root,
+    nodes: reported,
+    total: requireSpend(rolledUp, root, root),
+    statusCounts: countStatuses(reported)
+  };
+}
+function equalKOnCost(arms, options = {}) {
+  if (arms.length === 0) {
+    throw new Error("equalKOnCost: no arms to compare");
+  }
+  const tolerance = options.tolerance ?? defaultEqualKTolerance;
+  const armCosts = arms.map((arm) => ({
+    label: arm.label,
+    tokens: arm.report.total.tokens.input + arm.report.total.tokens.output,
+    usd: arm.report.total.usd,
+    iterations: arm.report.total.iterations
+  }));
+  const tokenValues = armCosts.map((a) => a.tokens);
+  const usdValues = armCosts.map((a) => a.usd);
+  const spread = {
+    tokens: spreadOf(tokenValues),
+    usd: spreadOf(usdValues)
+  };
+  const withinTolerance = fractionalSpread(tokenValues) <= tolerance && fractionalSpread(usdValues) <= tolerance;
+  return {
+    withinTolerance,
+    arms: armCosts,
+    spread,
+    tolerance
+  };
+}
+function rollUpSpend(nodes, root) {
+  const rolled = /* @__PURE__ */ new Map();
+  const stack = [{ id: root, expanded: false }];
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    if (frame === void 0) continue;
+    const node = requireNode2(nodes, frame.id, root);
+    if (!frame.expanded) {
+      stack.push({ id: frame.id, expanded: true });
+      for (const child of node.children) stack.push({ id: child, expanded: false });
+      continue;
+    }
+    const sum = cloneSpend(node.ownSpend);
+    for (const child of node.children) addSpend(sum, requireSpend(rolled, child, root));
+    rolled.set(frame.id, sum);
+  }
+  return rolled;
+}
+async function attachOutputs(nodes, blobs) {
+  for (const node of nodes.values()) {
+    if (node.status !== "done" || node.outRef === void 0) continue;
+    const out = await blobs.get(node.outRef);
+    if (out === void 0) {
+      throw new Error(
+        `trajectoryReport: blob store has no artifact for outRef '${node.outRef}' (node '${node.id}')`
+      );
+    }
+    node.output = out;
+  }
+}
+function freezeNode(node, rolledUpSpend) {
+  return {
+    id: node.id,
+    parent: node.parent,
+    children: [...node.children],
+    label: node.label,
+    runtime: node.runtime,
+    status: node.status,
+    ownSpend: node.ownSpend,
+    rolledUpSpend,
+    verdict: node.verdict,
+    output: node.output,
+    outRef: node.outRef
+  };
+}
+function countStatuses(reported) {
+  const counts = {
+    done: 0,
+    failed: 0,
+    cancelled: 0,
+    pending: 0
+  };
+  for (const node of reported) counts[node.status] += 1;
+  return counts;
+}
+function zeroSpend4() {
+  return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 };
+}
+function cloneSpend(spend) {
+  return {
+    iterations: spend.iterations,
+    tokens: { input: spend.tokens.input, output: spend.tokens.output },
+    usd: spend.usd,
+    ms: spend.ms
+  };
+}
+function addSpend(acc, delta) {
+  acc.iterations += delta.iterations;
+  addTokenUsage(acc.tokens, delta.tokens);
+  acc.usd += delta.usd;
+  acc.ms += delta.ms;
+}
+function spreadOf(values) {
+  if (values.length === 0) return 0;
+  return Math.max(...values) - Math.min(...values);
+}
+function fractionalSpread(values) {
+  const spread = spreadOf(values);
+  if (spread === 0) return 0;
+  const median = medianOf(values);
+  if (median === 0) {
+    throw new Error(
+      "equalKOnCost: arms have a non-zero cost spread on a zero-median channel; cannot express it as a fraction"
+    );
+  }
+  return spread / median;
+}
+function medianOf(values) {
+  if (values.length === 0) {
+    throw new Error("equalKOnCost: cannot take the median of an empty channel");
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  const hi = sorted[mid];
+  if (sorted.length % 2 !== 0) return hi;
+  const lo = sorted[mid - 1];
+  return (lo + hi) / 2;
+}
+function isSpawned(ev) {
+  return ev.kind === "spawned";
+}
+function isNode(node) {
+  return node !== void 0;
+}
+function bySeq(a, b) {
+  return a.seq - b.seq;
+}
+function requireNode2(nodes, id, root) {
+  const node = nodes.get(id);
+  if (!node) {
+    throw new Error(
+      `trajectoryReport: tree '${root}' references node '${id}' with no prior spawn (corrupted log)`
+    );
+  }
+  return node;
+}
+function requireSpend(rolled, id, root) {
+  const spend = rolled.get(id);
+  if (!spend) {
+    throw new Error(
+      `trajectoryReport: node '${id}' was never rolled up in tree '${root}' (unreachable from root)`
+    );
+  }
+  return spend;
+}
+
+export {
+  contentAddress,
+  InMemoryResultBlobStore,
+  FileResultBlobStore,
+  InMemorySpawnJournal,
+  FileSpawnJournal,
+  replaySpawnTree,
+  materializeTreeView,
+  completionAuthorizes,
+  stopSentinel,
+  sentinelCompletion,
+  deterministicCompletion,
+  createDynamicDriver,
+  renderAnalyses,
+  reportLoopUsage,
+  defineRuntimeHooks,
+  composeRuntimeHooks,
+  notifyRuntimeHookEvent,
+  notifyRuntimeDecisionPoint,
+  acquireSandbox,
+  probeSandboxCapabilities,
+  createSandboxLineage,
+  runLoop,
+  describeSandboxPlacement,
+  createSandboxForSpec,
+  defaultSelectWinner,
+  loopDispatch,
+  assertTraceDerivedFindings2 as assertTraceDerivedFindings,
+  createScopeAnalyst,
+  buildSteerContext,
+  createScope,
+  settledToIteration,
+  pipeline,
+  fanout,
+  loopUntil,
+  panel,
+  verify,
+  widen,
+  flatWidenGate,
+  InMemoryCorpus,
+  FileCorpus,
+  renderCorpusToInstructions,
+  routerInlineExecutor,
+  sandboxExecutor,
+  cliExecutor,
+  createExecutorRegistry,
+  spendFromUsageEvents,
+  createBudgetPool,
+  createSupervisor,
+  createRootHandle,
+  createShapeRegistry,
+  builtinShapes,
+  registerShape,
+  definePersona,
+  runPersonified,
+  trajectoryReport,
+  equalKOnCost
+};
+//# sourceMappingURL=chunk-KEWO4KI6.js.map