@tangle-network/agent-runtime 0.50.0 → 0.51.0

package/dist/chunk-FQH33M5N.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/durable/spawn-journal.ts","../src/runtime/util.ts","../src/runtime/anytime.ts","../src/runtime/audit-intent.ts","../src/runtime/completion.ts","../src/runtime/personify/analyst.ts","../src/runtime/driver.ts","../src/runtime/observe.ts","../src/runtime/harvest-corpus.ts","../src/runtime/inline-sandbox-client.ts","../src/runtime/report-usage.ts","../src/runtime-hooks.ts","../src/runtime/sandbox-acquire.ts","../src/runtime/sandbox-backend.ts","../src/runtime/sandbox-capabilities.ts","../src/runtime/sandbox-lineage.ts","../src/runtime/run-loop.ts","../src/runtime/loop-dispatch.ts","../src/runtime/mcp-environment.ts","../src/runtime/supervise/scope.ts","../src/runtime/personify/combinators.ts","../src/runtime/personify/corpus.ts","../src/runtime/supervise/runtime.ts","../src/runtime/router-client.ts","../src/runtime/supervise/budget.ts","../src/runtime/supervise/supervisor.ts","../src/runtime/personify/registry.ts","../src/runtime/personify/persona.ts","../src/runtime/personify/trajectory.ts","../src/runtime/promotion-gate.ts","../src/runtime/run-benchmark.ts","../src/runtime/strategy.ts","../src/runtime/sandbox-run.ts","../src/runtime/strategy-author.ts","../src/runtime/strategy-evolution.ts","../src/runtime/verifier-environment.ts","../src/runtime/waterfall.ts","../src/runtime/workspace.ts"],"sourcesContent":["/**\n * @experimental\n *\n * Event-sourced spawn journal for the recursive execution atom (build steps 3 + 7).\n *\n * The supervision tree is journaled as an append-only event log: every `spawned`,\n * `settled`, and `cancelled` is recorded AFTER it is observed-committed (never\n * speculative), mirroring `ConversationJournal`'s begin/append/load shape. The log\n * holds only the THIN decision record — ids, parentage, budget, the spend a decision\n * consumed, and a content-addressed `outRef`. The payloads the driver branched on\n * (the `out` artifacts) live in a separate `ResultBlobStore`, keyed by `outRef`, so\n * the journal stays small (decisions) and replay rehydrates the exact `Settled` from\n * the blob store (evidence). This is the decision/payload split the replay argument\n * rests on (B1/B2).\n *\n * Replay determinism (B2): `seq` is the monotonic cursor order `scope.next()` yielded\n * each settlement — NOT wall-clock. `replaySpawnTree` sorts strictly by `seq` before\n * touching the blob store, so the order in which rehydration `get`s resolve can never\n * reorder the replayed `Settled[]`; the result is identical regardless of blob latency.\n */\n\nimport { createHash } from 'node:crypto'\nimport type {\n  NodeId,\n  NodeSnapshot,\n  NodeStatus,\n  ResultBlobStore,\n  Runtime,\n  Settled,\n  SpawnEvent,\n  SpawnJournal,\n  Spend,\n  TreeView,\n} from '../runtime/supervise/types'\nimport { zeroTokenUsage } from '../runtime/util'\n\n// ── Content addressing ──────────────────────────────────────────────────────\n\n/**\n * Mint the content-addressed `outRef` for a result artifact: `sha256:<hex>` over a\n * stable JSON encoding. Producers call this to derive the `outRef` they journal and\n * `put`; the FS/in-mem stores re-derive it on `put` to verify the supplied ref\n * matches (fail loud on a mismatch — a forged ref breaks the replay invariant).\n *\n * Stable encoding: object keys are sorted recursively so two structurally-equal\n * artifacts hash identically regardless of key insertion order.\n */\nexport function contentAddress(artifact: unknown): string {\n  const hex = createHash('sha256').update(stableStringify(artifact), 'utf-8').digest('hex')\n  return `sha256:${hex}`\n}\n\nfunction stableStringify(value: unknown): string {\n  if (value === null || typeof value !== 'object') return JSON.stringify(value) ?? 'null'\n  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`\n  const entries = Object.entries(value as Record<string, unknown>)\n    .filter(([, v]) => v !== undefined)\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(',')}}`\n}\n\n// ── Result blob store ─────────────────────────────────────────────────────────\n\n/**\n * In-memory `ResultBlobStore`. Content-addressed: `put` verifies the supplied\n * `outRef` matches the artifact's hash so a stale/forged ref fails loud rather than\n * silently rehydrating the wrong payload. Idempotent on an identical re-put.\n */\nexport class InMemoryResultBlobStore implements ResultBlobStore {\n  private readonly blobs = new Map<string, unknown>()\n\n  async put(outRef: string, artifact: unknown): Promise<void> {\n    assertContentAddress(outRef, artifact)\n    this.blobs.set(outRef, artifact)\n  }\n\n  async get(outRef: string): Promise<unknown | undefined> {\n    return this.blobs.has(outRef) ? this.blobs.get(outRef) : undefined\n  }\n}\n\n/**\n * FS `ResultBlobStore`. One JSON file per artifact under `dir`, named by a\n * filesystem-safe encoding of the `outRef` (`sha256:<hex>` → `sha256-<hex>.json`).\n * `put` fsyncs so a crash between writes never loses an acknowledged blob.\n */\nexport class FileResultBlobStore implements ResultBlobStore {\n  constructor(private readonly dir: string) {}\n\n  async put(outRef: string, artifact: unknown): Promise<void> {\n    assertContentAddress(outRef, artifact)\n    const fs = await import('node:fs/promises')\n    await fs.mkdir(this.dir, { recursive: true })\n    const fh = await fs.open(this.blobPath(outRef), 'w')\n    try {\n      await fh.write(JSON.stringify(artifact))\n      await fh.sync()\n    } finally {\n      await fh.close()\n    }\n  }\n\n  async get(outRef: string): Promise<unknown | undefined> {\n    const fs = await import('node:fs/promises')\n    let text: string\n    try {\n      text = await fs.readFile(this.blobPath(outRef), 'utf8')\n    } catch (err) {\n      if (isNoEntError(err)) return undefined\n      throw err\n    }\n    return JSON.parse(text)\n  }\n\n  private blobPath(outRef: string): string {\n    return `${this.dir}/${outRef.replace(/:/g, '-')}.json`\n  }\n}\n\nfunction assertContentAddress(outRef: string, artifact: unknown): void {\n  const expected = contentAddress(artifact)\n  if (outRef !== expected) {\n    throw new Error(\n      `blob outRef '${outRef}' does not match the artifact content hash '${expected}'; ` +\n        'a content-addressed store refuses a mismatched ref (breaks the replay invariant)',\n    )\n  }\n}\n\n// ── Spawn journal ──────────────────────────────────────────────────────────────\n\n/**\n * In-memory `SpawnJournal`. Appends are observed-committed only; the impl enforces\n * the corruption guards a durable replay rests on:\n *  - an event before `beginTree` is a corrupted tree (fail loud),\n *  - a duplicate `seq` within a tree is a corrupted cursor (fail loud) — two\n *    settlements cannot share the cursor position replay orders by.\n */\nexport class InMemorySpawnJournal implements SpawnJournal {\n  private readonly trees = new Map<NodeId, { begunAt: string; events: SpawnEvent[] }>()\n\n  async loadTree(root: NodeId): Promise<SpawnEvent[] | undefined> {\n    const tree = this.trees.get(root)\n    if (!tree) return undefined\n    return tree.events.map((ev) => ({ ...ev }))\n  }\n\n  async beginTree(root: NodeId, at: string): Promise<void> {\n    const existing = this.trees.get(root)\n    if (existing) {\n      if (existing.begunAt !== at) {\n        throw new Error(\n          `spawn tree '${root}' already begun at ${existing.begunAt}; refusing to overwrite with ${at}`,\n        )\n      }\n      return\n    }\n    this.trees.set(root, { begunAt: at, events: [] })\n  }\n\n  async appendEvent(root: NodeId, ev: SpawnEvent): Promise<void> {\n    const tree = this.trees.get(root)\n    if (!tree) {\n      throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`)\n    }\n    assertSeqUnique(root, tree.events, ev)\n    tree.events.push({ ...ev })\n  }\n}\n\n/**\n * JSONL on disk. One line per record: the first record is `begin`, subsequent records\n * are `event` envelopes wrapping a `SpawnEvent`. `loadTree` replays the whole file,\n * filtering by `root`, and applies the same begin-precedes-events + unique-seq\n * corruption guards as the in-memory impl. Each append fsyncs so a crash between\n * writes never loses an acknowledged event.\n */\nexport class FileSpawnJournal implements SpawnJournal {\n  constructor(private readonly path: string) {}\n\n  async loadTree(root: NodeId): Promise<SpawnEvent[] | undefined> {\n    const fs = await import('node:fs/promises')\n    let text: string\n    try {\n      text = await fs.readFile(this.path, 'utf8')\n    } catch (err) {\n      if (isNoEntError(err)) return undefined\n      throw err\n    }\n    const lines = text.split('\\n').filter((line) => line.length > 0)\n    let begun = false\n    const events: SpawnEvent[] = []\n    for (const line of lines) {\n      const record = JSON.parse(line) as SpawnJournalRecord\n      if (record.root !== root) continue\n      if (record.kind === 'begin') {\n        begun = true\n      } else {\n        if (!begun) {\n          throw new Error(\n            `spawn journal corrupted: event for tree '${root}' precedes its begin record`,\n          )\n        }\n        assertSeqUnique(root, events, record.event)\n        events.push(record.event)\n      }\n    }\n    return begun ? events : undefined\n  }\n\n  async beginTree(root: NodeId, at: string): Promise<void> {\n    const existing = await this.loadTreeBegin(root)\n    if (existing) {\n      if (existing !== at) {\n        throw new Error(\n          `spawn tree '${root}' already begun in ${this.path} at ${existing}; refusing to overwrite with ${at}`,\n        )\n      }\n      return\n    }\n    await this.appendRecord({ kind: 'begin', root, at })\n  }\n\n  async appendEvent(root: NodeId, ev: SpawnEvent): Promise<void> {\n    const events = await this.loadTree(root)\n    if (events === undefined) {\n      throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`)\n    }\n    assertSeqUnique(root, events, ev)\n    await this.appendRecord({ kind: 'event', root, event: ev })\n  }\n\n  private async loadTreeBegin(root: NodeId): Promise<string | undefined> {\n    const fs = await import('node:fs/promises')\n    let text: string\n    try {\n      text = await fs.readFile(this.path, 'utf8')\n    } catch (err) {\n      if (isNoEntError(err)) return undefined\n      throw err\n    }\n    const lines = text.split('\\n').filter((line) => line.length > 0)\n    for (const line of lines) {\n      const record = JSON.parse(line) as SpawnJournalRecord\n      if (record.root === root && record.kind === 'begin') return record.at\n    }\n    return undefined\n  }\n\n  private async appendRecord(record: SpawnJournalRecord): Promise<void> {\n    const fs = await import('node:fs/promises')\n    const path = await import('node:path')\n    await fs.mkdir(path.dirname(this.path), { recursive: true })\n    const fh = await fs.open(this.path, 'a')\n    try {\n      await fh.write(`${JSON.stringify(record)}\\n`)\n      await fh.sync()\n    } finally {\n      await fh.close()\n    }\n  }\n}\n\ntype SpawnJournalRecord =\n  | { kind: 'begin'; root: NodeId; at: string }\n  | { kind: 'event'; root: NodeId; event: SpawnEvent }\n\n/**\n * Two `seq` namespaces share the journal: a `spawned` event's `seq` is the spawn ordinal\n * (the order children were created), and a `settled`/`cancelled` event's `seq` is the\n * monotonic CURSOR order `scope.next()` yielded that settlement (B2). The uniqueness\n * replay rests on is the cursor namespace — two settlements cannot share the position\n * replay orders by — so the guard checks only settled/cancelled events. A `spawned`\n * ordinal legitimately equals a later `settled` cursor seq and is not a collision.\n */\nfunction assertSeqUnique(root: NodeId, events: SpawnEvent[], ev: SpawnEvent): void {\n  if (ev.kind === 'spawned') return\n  if (events.some((e) => e.kind !== 'spawned' && e.seq === ev.seq)) {\n    throw new Error(\n      `spawn journal corrupted: duplicate cursor seq ${ev.seq} in tree '${root}'; ` +\n        'the cursor order replay relies on is not unique',\n    )\n  }\n}\n\n// ── Replay executor (build step 7) ───────────────────────────────────────────────\n\n/**\n * Re-feed a journaled spawn tree in strict `seq` order, rehydrating each settled\n * child's `out` from the blob store by `outRef`, and return the `Settled[]` exactly\n * as `scope.next()` originally delivered them.\n *\n * Determinism (B2): the events are sorted by `seq` BEFORE any blob `get`, so the\n * replay order is the recorded cursor order regardless of how fast each rehydration\n * resolves. `at` (wall-clock) is never a replay input. Fail loud on a tree that was\n * never begun, a settled-done event missing its `outRef`, or a blob the store can't\n * rehydrate — a silent gap would let `act` branch on the wrong evidence.\n */\nexport async function replaySpawnTree(\n  journal: SpawnJournal,\n  blobs: ResultBlobStore,\n  root: NodeId,\n): Promise<Settled<unknown>[]> {\n  const events = await journal.loadTree(root)\n  if (events === undefined) {\n    throw new Error(`replaySpawnTree: no journaled tree for root '${root}'`)\n  }\n  const ordered = [...events].sort((a, b) => a.seq - b.seq)\n  const labels = new Map<NodeId, string>()\n  for (const ev of ordered) {\n    if (ev.kind === 'spawned') labels.set(ev.id, ev.label)\n  }\n  const settled: Settled<unknown>[] = []\n  for (const ev of ordered) {\n    if (ev.kind === 'spawned') continue\n    if (ev.kind === 'cancelled') {\n      settled.push({\n        kind: 'down',\n        handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, 'cancelled'),\n        reason: ev.reason,\n        infra: false,\n        restartCount: 0,\n        seq: ev.seq,\n      })\n      continue\n    }\n    if (ev.status === 'down') {\n      settled.push({\n        kind: 'down',\n        handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, 'failed'),\n        reason: ev.verdict?.notes ?? 'child down',\n        infra: ev.infra === true,\n        restartCount: 0,\n        seq: ev.seq,\n      })\n      continue\n    }\n    if (ev.outRef === undefined) {\n      throw new Error(\n        `replaySpawnTree: settled-done event for '${ev.id}' (seq ${ev.seq}) has no outRef; ` +\n          'cannot rehydrate the result the driver branched on',\n      )\n    }\n    const out = await blobs.get(ev.outRef)\n    if (out === undefined) {\n      throw new Error(\n        `replaySpawnTree: blob store has no artifact for outRef '${ev.outRef}' (node '${ev.id}', seq ${ev.seq})`,\n      )\n    }\n    settled.push({\n      kind: 'done',\n      handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, 'done'),\n      out,\n      outRef: ev.outRef,\n      verdict: ev.verdict,\n      spent: ev.spent,\n      seq: ev.seq,\n    })\n  }\n  return settled\n}\n\nfunction replayHandle(id: NodeId, label: string, status: NodeStatus) {\n  return {\n    id,\n    label,\n    status,\n    abort() {\n      throw new Error(`cannot abort node '${id}': replayed handles are terminal, not live`)\n    },\n  }\n}\n\n/**\n * Materialize the live tree (`TreeView`) from a journaled event list for resume. Folds\n * `spawned`/`settled`/`cancelled` into a per-node snapshot in `seq` order so the\n * resumed view matches what `scope.view` showed at the recorded cursor position.\n */\nexport function materializeTreeView(events: SpawnEvent[]): TreeView {\n  const nodes = new Map<NodeId, MutableSnapshot>()\n  let root: NodeId | undefined\n  // `spawned` (ordinal namespace) and `settled`/`cancelled` (cursor namespace) carry\n  // overlapping `seq` values, so create every node before any update — process spawns in\n  // ordinal order, then settlements/cancellations in cursor order. A settle/cancel for an\n  // un-spawned node is a corrupted log (fail loud via requireNode).\n  const spawns = events\n    .filter((ev): ev is Extract<SpawnEvent, { kind: 'spawned' }> => ev.kind === 'spawned')\n    .sort((a, b) => a.seq - b.seq)\n  const settlements = events.filter((ev) => ev.kind !== 'spawned').sort((a, b) => a.seq - b.seq)\n  for (const ev of spawns) {\n    if (ev.parent === undefined && root === undefined) root = ev.id\n    nodes.set(ev.id, {\n      id: ev.id,\n      parent: ev.parent,\n      label: ev.label,\n      status: 'pending',\n      runtime: ev.runtime,\n      budget: ev.budget,\n      spent: zeroSpend(),\n    })\n  }\n  for (const ev of settlements) {\n    if (ev.kind === 'settled') {\n      const node = requireNode(nodes, ev.id)\n      node.status = ev.status === 'done' ? 'done' : 'failed'\n      node.spent = ev.spent\n      node.outRef = ev.outRef\n    } else {\n      const node = requireNode(nodes, ev.id)\n      node.status = 'cancelled'\n    }\n  }\n  const snapshots = [...nodes.values()].map(freezeSnapshot)\n  return {\n    root: root ?? snapshots[0]?.id ?? '',\n    nodes: snapshots,\n    inFlight: snapshots.filter((n) => n.status === 'running' || n.status === 'acquiring').length,\n  }\n}\n\ninterface MutableSnapshot {\n  id: NodeId\n  parent?: NodeId\n  label: string\n  status: NodeStatus\n  runtime: Runtime\n  budget: NodeSnapshot['budget']\n  spent: Spend\n  outRef?: string\n}\n\nfunction zeroSpend(): Spend {\n  return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 }\n}\n\nfunction requireNode(nodes: Map<NodeId, MutableSnapshot>, id: NodeId): MutableSnapshot {\n  const node = nodes.get(id)\n  if (!node) {\n    throw new Error(`spawn journal corrupted: settle/cancel for node '${id}' with no prior spawn`)\n  }\n  return node\n}\n\nfunction freezeSnapshot(node: MutableSnapshot): NodeSnapshot {\n  return {\n    id: node.id,\n    parent: node.parent,\n    label: node.label,\n    status: node.status,\n    runtime: node.runtime,\n    budget: node.budget,\n    spent: node.spent,\n    outRef: node.outRef,\n  }\n}\n\nfunction isNoEntError(err: unknown): boolean {\n  return (\n    typeof err === 'object' &&\n    err !== null &&\n    'code' in err &&\n    (err as { code: unknown }).code === 'ENOENT'\n  )\n}\n","/**\n * @experimental\n *\n * Internal loop-kernel utilities shared across the kernel, drivers, and the\n * sandbox-acquire layer. Not part of the public barrel surface.\n */\n\nimport type { SandboxInstance } from '@tangle-network/sandbox'\nimport type { LoopTokenUsage } from './types'\n\n/**\n * Best-effort sandbox delete. Skips instances without a `delete` (test fakes);\n * swallows errors (the platform reaps on expiry). Returns `false` when delete\n * threw, `true` otherwise, so callers can surface a leak if they choose.\n */\nexport async function deleteBoxSafe(box: SandboxInstance | undefined): Promise<boolean> {\n  if (!box || typeof (box as { delete?: unknown }).delete !== 'function') return true\n  try {\n    await box.delete()\n    return true\n  } catch {\n    return false\n  }\n}\n\n/** Short base36 id for trace correlation. Not cryptographic, not collision-free. */\nexport function randomSuffix(len = 8): string {\n  return Math.random()\n    .toString(36)\n    .slice(2, 2 + len)\n}\n\n/** Collision-resistant id for sandbox naming (find-by-name recovery must be unique). */\nexport function randomUuid(): string {\n  return crypto.randomUUID()\n}\n\n/** Construct an AbortError. Downstream code pattern-matches on `err.name`. */\nexport function abortError(): Error {\n  const err = new Error('aborted')\n  err.name = 'AbortError'\n  return err\n}\n\n/** Throw an AbortError. */\nexport function throwAbort(): never {\n  throw abortError()\n}\n\n/** Throw if the signal is already aborted; otherwise no-op. */\nexport function throwIfAborted(signal: AbortSignal | undefined): void {\n  if (signal?.aborted) throw abortError()\n}\n\n/**\n * Sleep that resolves early on abort and always clears its timer so it never\n * keeps the event loop alive. Resolves (does not reject) on abort — callers\n * re-check the signal explicitly after the sleep.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise((resolve) => {\n    if (signal?.aborted) {\n      resolve()\n      return\n    }\n    let onAbort: (() => void) | undefined\n    const timer = setTimeout(() => {\n      if (onAbort && signal) signal.removeEventListener('abort', onAbort)\n      resolve()\n    }, ms)\n    if (signal) {\n      onAbort = () => {\n        clearTimeout(timer)\n        resolve()\n      }\n      signal.addEventListener('abort', onAbort, { once: true })\n    }\n  })\n}\n\n/**\n * Race a promise against a timeout. Resolves with the value if it settles in\n * time, otherwise resolves with `undefined`. Always clears the timer.\n */\nexport function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T | undefined> {\n  return new Promise<T | undefined>((resolve) => {\n    const timer = setTimeout(() => resolve(undefined), ms)\n    promise.then(\n      (value) => {\n        clearTimeout(timer)\n        resolve(value)\n      },\n      () => {\n        clearTimeout(timer)\n        resolve(undefined)\n      },\n    )\n  })\n}\n\ninterface StringifyOptions {\n  /** Pretty-print with 2-space indent. Default false (compact). */\n  pretty?: boolean\n  /** Truncate to this many chars, appending `…`. Default unbounded. */\n  max?: number\n}\n\n/**\n * `JSON.stringify` with a `String()` fallback on throw (cyclic / non-JSON).\n * Strings pass through unstringified so a preview of a string output is the\n * string itself, not a quoted re-encoding.\n */\nexport function stringifySafe(value: unknown, opts: StringifyOptions = {}): string {\n  let s: string\n  try {\n    if (typeof value === 'string') {\n      s = value\n    } else {\n      const json = opts.pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value)\n      s = json ?? String(value)\n    }\n  } catch {\n    s = String(value)\n  }\n  if (opts.max !== undefined && s.length > opts.max) return `${s.slice(0, opts.max)}…`\n  return s\n}\n\n/** A fresh zero token-usage accumulator. */\nexport function zeroTokenUsage(): LoopTokenUsage {\n  return { input: 0, output: 0 }\n}\n\n/** Add `delta` into `acc` in place. Missing fields count as zero. */\nexport function addTokenUsage(acc: LoopTokenUsage, delta: Partial<LoopTokenUsage>): void {\n  acc.input += delta.input ?? 0\n  acc.output += delta.output ?? 0\n}\n\n/**\n * Map `items` through `fn` with at most `limit` calls in flight at once,\n * preserving input order in the result. On the first `fn` rejection no NEW\n * items are picked up; already-in-flight calls are awaited, then the first\n * error is rethrown. `limit` is clamped to ≥ 1.\n *\n * Used where a burst of provisioning (e.g. forking N child boxes) must respect\n * the loop's concurrency bound instead of firing all N at once.\n */\nexport async function mapWithConcurrency<T, R>(\n  items: readonly T[],\n  limit: number,\n  fn: (item: T, index: number) => Promise<R>,\n): Promise<R[]> {\n  const bound = Math.max(1, Math.floor(limit))\n  const results = new Array<R>(items.length)\n  let next = 0\n  let failed = false\n  const worker = async (): Promise<void> => {\n    while (!failed) {\n      const i = next\n      next += 1\n      if (i >= items.length) return\n      try {\n        results[i] = await fn(items[i] as T, i)\n      } catch (err) {\n        failed = true\n        throw err\n      }\n    }\n  }\n  const workerCount = Math.min(bound, items.length)\n  await Promise.all(Array.from({ length: workerCount }, () => worker()))\n  return results\n}\n","/**\n * anytimeReport — time-to-satisfactory-output metrics, derived entirely from the\n * waterfall's spans (no new instrumentation): per task, the best-so-far score after each\n * shot with its elapsed wall-clock and cumulative spend; per strategy, the standard\n * anytime-optimization metrics:\n *\n *   TTT  time-to-target — elapsed ms until best-so-far ≥ the target (per task; median\n *        over tasks that reached it)\n *   STT  shots-to-target — attempts until best-so-far ≥ target\n *   ERT  expected running time (the COCO benchmarking convention): TOTAL time spent\n *        across all tasks — including failures' full budgets — divided by the number of\n *        tasks that reached the target. The honest \"how long per success, all-in\".\n *   AUC  the anytime curve's area (mean best-so-far score across the budget, per shot\n *        index) — higher = climbs earlier.\n *\n * The \"satisfactory\" bar follows the COCO/BBOB convention: a SET of satisficing targets\n * (e.g. [0.5, 0.8, 1.0] on the normalized check score), each measured independently —\n * runtime-to-target per (task, target) pair — optionally overridden per task\n * (`targetFor`) when satisfaction is task-specific. Spans come from\n * `createWaterfallCollector().report()`; tasks are grouped by the supervisor runId\n * (`agentic:<strategy>:<taskId>`); shot spans are `shot:N` labels.\n */\nimport type { WaterfallSpan } from './waterfall'\n\nexport interface AnytimeTaskCurve {\n  taskId: string\n  strategy: string\n  /** Best-so-far after each settled shot: elapsed ms from the task's first spawn,\n   *  cumulative usd, and the running max score. */\n  points: Array<{ elapsedMs: number; cumUsd: number; best: number }>\n  /** Per satisficing target (keyed by the target value as a string): the first point\n   *  where best ≥ target, or null when never reached within budget. */\n  hits: Record<string, { ms: number; shots: number; usd: number } | null>\n}\n\nexport interface AnytimeStrategySummary {\n  strategy: string\n  /** The satisficing target this row summarizes. */\n  target: number\n  tasks: number\n  reachedTarget: number\n  /** Median time-to-target over the tasks that reached it (null when none did). */\n  medianTttMs: number | null\n  medianShotsToTarget: number | null\n  /** COCO ERT: Σ all task wall-time (incl. failures) / #successes. Null when 0 succeed. */\n  ertMs: number | null\n  /** Same construction over dollars: Σ all spend / #successes. */\n  erUsd: number | null\n  /** Mean best-so-far score by shot index (the anytime curve, averaged over tasks). */\n  curveByShot: number[]\n  /** Area under the per-shot anytime curve, normalized to [0,1]. */\n  auc: number\n}\n\nexport interface AnytimeReport {\n  targets: number[]\n  perTask: AnytimeTaskCurve[]\n  /** One summary per (strategy, target) pair — the COCO-style multi-target view. */\n  perStrategy: AnytimeStrategySummary[]\n}\n\nconst median = (xs: number[]): number | null => {\n  if (xs.length === 0) return null\n  const s = [...xs].sort((a, b) => a - b)\n  const mid = Math.floor(s.length / 2)\n  return s.length % 2 === 1 ? (s[mid] as number) : ((s[mid - 1] as number) + (s[mid] as number)) / 2\n}\n\n/** Derive anytime metrics from waterfall spans. `targets` are the satisficing score\n *  bars (default [1] = fully resolved; COCO-style multi-target: [0.5, 0.8, 1]);\n *  `targetFor` overrides the bar per task (task-specific satisfaction) — when set, the\n *  per-task bar replaces every entry of `targets` for that task. */\nexport function anytimeReport(\n  spans: WaterfallSpan[],\n  opts?: { targets?: number[]; targetFor?: (taskId: string) => number },\n): AnytimeReport {\n  const targets = opts?.targets ?? [1]\n  const byRun = new Map<string, WaterfallSpan[]>()\n  for (const s of spans) {\n    if (!s.label.startsWith('shot:')) continue\n    const list = byRun.get(s.runId) ?? []\n    list.push(s)\n    byRun.set(s.runId, list)\n  }\n\n  const perTask: AnytimeTaskCurve[] = []\n  for (const [runId, shots] of byRun) {\n    const m = runId.match(/^agentic:(.+):(.+)$/)\n    const strategy = m?.[1] ?? runId\n    const taskId = m?.[2] ?? runId\n    const ordered = [...shots].sort((a, b) => (a.endMs ?? a.startMs) - (b.endMs ?? b.startMs))\n    const t0 = Math.min(...ordered.map((s) => s.startMs))\n    const taskTargets = opts?.targetFor ? [opts.targetFor(taskId)] : targets\n    let best = 0\n    let cumUsd = 0\n    const points: AnytimeTaskCurve['points'] = []\n    const hits: AnytimeTaskCurve['hits'] = {}\n    for (const t of taskTargets) hits[String(t)] = null\n    for (const s of ordered) {\n      cumUsd += s.usd\n      if (typeof s.score === 'number' && s.score > best) best = s.score\n      const elapsedMs = (s.endMs ?? s.startMs) - t0\n      points.push({ elapsedMs, cumUsd, best })\n      for (const t of taskTargets) {\n        if (hits[String(t)] === null && best >= t) {\n          hits[String(t)] = { ms: elapsedMs, shots: points.length, usd: cumUsd }\n        }\n      }\n    }\n    perTask.push({ taskId, strategy, points, hits })\n  }\n\n  const byStrategy = new Map<string, AnytimeTaskCurve[]>()\n  for (const t of perTask) {\n    const list = byStrategy.get(t.strategy) ?? []\n    list.push(t)\n    byStrategy.set(t.strategy, list)\n  }\n\n  const perStrategy: AnytimeStrategySummary[] = []\n  for (const [strategy, tasks] of byStrategy) {\n    const totalMs = tasks.reduce((s, t) => s + (t.points[t.points.length - 1]?.elapsedMs ?? 0), 0)\n    const totalUsd = tasks.reduce((s, t) => s + (t.points[t.points.length - 1]?.cumUsd ?? 0), 0)\n    const maxShots = Math.max(0, ...tasks.map((t) => t.points.length))\n    const curveByShot: number[] = []\n    for (let i = 0; i < maxShots; i += 1) {\n      // A task with fewer shots carries its final best forward (it stopped — its\n      // best-so-far is what an operator would have at that point).\n      const vals = tasks.map(\n        (t) => (t.points[Math.min(i, t.points.length - 1)] as { best: number }).best,\n      )\n      curveByShot.push(vals.reduce((s, v) => s + v, 0) / vals.length)\n    }\n    const auc =\n      curveByShot.length > 0 ? curveByShot.reduce((s, v) => s + v, 0) / curveByShot.length : 0\n    const summaryTargets = opts?.targetFor ? [Number.NaN] : targets\n    for (const t of summaryTargets) {\n      const key = (\n        taskCurve: AnytimeTaskCurve,\n      ): { ms: number; shots: number; usd: number } | null =>\n        opts?.targetFor\n          ? (Object.values(taskCurve.hits)[0] ?? null)\n          : (taskCurve.hits[String(t)] ?? null)\n      const reached = tasks.filter((x) => key(x) !== null)\n      perStrategy.push({\n        strategy,\n        target: t,\n        tasks: tasks.length,\n        reachedTarget: reached.length,\n        medianTttMs: median(reached.map((x) => (key(x) as { ms: number }).ms)),\n        medianShotsToTarget: median(reached.map((x) => (key(x) as { shots: number }).shots)),\n        ertMs: reached.length > 0 ? totalMs / reached.length : null,\n        erUsd: reached.length > 0 ? totalUsd / reached.length : null,\n        curveByShot,\n        auc,\n      })\n    }\n  }\n  perStrategy.sort((a, b) => a.strategy.localeCompare(b.strategy) || a.target - b.target)\n  return { targets, perTask, perStrategy }\n}\n\n/** One row per (strategy, satisficing target): the shareable time-to-satisfactory table. */\nexport function renderAnytimeTable(report: AnytimeReport): string {\n  const lines = [\n    `anytime metrics · satisficing targets [${report.targets.join(', ')}] · ERT = Σ all wall-time / #successes (COCO)`,\n    'strategy            ≥tgt   reach   med-TTT   med-shots   ERT(all-in)   $/success   AUC   curve',\n  ]\n  for (const s of report.perStrategy) {\n    const curve = s.curveByShot.map((v) => '▁▂▃▄▅▆▇█'[Math.min(7, Math.floor(v * 8))]).join('')\n    const tgt = Number.isNaN(s.target) ? 'task' : s.target.toFixed(2)\n    lines.push(\n      `${s.strategy.padEnd(19)} ${tgt.padStart(4)} ${String(s.reachedTarget).padStart(4)}/${String(s.tasks).padEnd(3)} ` +\n        `${s.medianTttMs === null ? '      —' : `${(s.medianTttMs / 1000).toFixed(1).padStart(6)}s`}   ` +\n        `${s.medianShotsToTarget === null ? '    —' : String(s.medianShotsToTarget).padStart(5)}   ` +\n        `${s.ertMs === null ? '         —' : `${(s.ertMs / 1000).toFixed(1).padStart(9)}s`}   ` +\n        `${s.erUsd === null ? '       —' : `$${s.erUsd.toFixed(4)}`}   ${s.auc.toFixed(2)}   ${curve}`,\n    )\n  }\n  return lines.join('\\n')\n}\n","/**\n * auditIntent — the route-rigor analyst: is this trajectory even going the RIGHT WAY?\n *\n * `observe()` critiques execution quality (\"what's unfinished\"). This audits ALIGNMENT —\n * a different failure class the score can't see until it's too late: an agent can be\n * executing flawlessly down the wrong route. The auditor reads the trajectory and\n * compares three intents:\n *\n *   declared  — what the task says to do (the prompt / acceptance criteria)\n *   revealed  — what the agent is ACTUALLY optimizing, inferred from its action pattern\n *               (the inverse-inference move: actions reveal objectives)\n *   user      — what the principal actually wants (the contract, when it differs from\n *               the literal task text), plus where the user's own trajectory is heading\n *\n * and returns a verdict (aligned / drifting / diverged) with evidence and ONE\n * recommended intervention. FIREWALLED like every analyst: input is the trajectory and\n * the intents — never the verifier or its data (zero check-leakage, so route auditing\n * is always Goodhart-safe to run online).\n *\n * Where it runs: between shots (steer the next one), as a watchdog over the lifecycle\n * stream (abort-and-refund a diverged rollout — the budget pool makes early abort\n * strictly valuable), or post-hoc over a whole BenchmarkReport (the meta-intent pass:\n * is the LOOP optimizing the right thing — degenerate submissions, check-gaming shapes,\n * objective drift across tasks).\n */\n\nimport type { ChatClient } from '@tangle-network/agent-eval'\n\nexport interface AuditIntentInput {\n  /** The declared intent: the task text / acceptance criteria the agent was given. */\n  declaredIntent: string\n  /** The trajectory so far — tool calls + results + assistant turns (any event shapes). */\n  trace: ReadonlyArray<unknown>\n  /** The principal's actual intent when it differs from the literal task (the contract). */\n  userIntent?: string\n  /** The loop-level purpose (meta-intent): what the WHOLE run is for — lets the auditor\n   *  flag locally-sensible work that serves the wrong larger objective. */\n  metaIntent?: string\n  runId?: string\n}\n\nexport interface AuditIntentOptions {\n  chat: ChatClient\n  model?: string\n  /** Override the auditor instruction (optimizable like any analyst prompt). */\n  auditorInstruction?: string\n  /** Cap trace lines fed to the auditor. Default 80. */\n  maxTraceLines?: number\n  signal?: AbortSignal\n}\n\nexport interface IntentAudit {\n  /** What the agent's actions reveal it is actually optimizing — one sentence. */\n  revealedIntent: string\n  verdict: 'aligned' | 'drifting' | 'diverged'\n  /** Trajectory-grounded evidence for the verdict (specific calls/patterns). */\n  evidence: string\n  /** The single recommended intervention. */\n  recommendation: 'continue' | 'steer' | 'abort'\n  /** When recommendation is 'steer': the corrective instruction to inject. */\n  steer?: string\n  confidence: number\n}\n\nexport const defaultAuditorInstruction =\n  'You audit whether an AI agent is on the RIGHT ROUTE — not whether it works hard, but whether its ' +\n  'actions serve the stated intents. Infer the REVEALED intent from the action pattern (what the ' +\n  'trajectory is actually optimizing). Compare against the declared task intent, the user intent when ' +\n  'given, and the meta-intent when given. Flawless execution down the wrong route is DIVERGED. ' +\n  'Busy-work that neither advances nor harms is DRIFTING. Judge only from the trajectory — be specific ' +\n  'about which actions ground your verdict. Recommend abort only when continuing cannot serve the intent.'\n\nfunction summarize(trace: ReadonlyArray<unknown>, maxLines: number): string {\n  const lines: string[] = []\n  for (const ev of trace) {\n    const e = ev as Record<string, unknown>\n    const role = e.role as string | undefined\n    if (role === 'tool') lines.push(`RESULT ${String(e.content).slice(0, 200)}`)\n    else if (role === 'assistant') {\n      const calls = (\n        e.tool_calls as Array<{ function?: { name?: string; arguments?: string } }> | undefined\n      )\n        ?.map((c) => `${c.function?.name}(${(c.function?.arguments ?? '').slice(0, 120)})`)\n        .join(', ')\n      lines.push(calls ? `CALL ${calls}` : `SAY ${String(e.content).slice(0, 160)}`)\n    } else if (role === 'user') lines.push(`USER ${String(e.content).slice(0, 160)}`)\n  }\n  return lines.slice(-maxLines).join('\\n')\n}\n\nconst auditSchema = {\n  name: 'intent_audit',\n  schema: {\n    type: 'object',\n    additionalProperties: false,\n    required: ['revealedIntent', 'verdict', 'evidence', 'recommendation', 'confidence'],\n    properties: {\n      revealedIntent: { type: 'string' },\n      verdict: { type: 'string', enum: ['aligned', 'drifting', 'diverged'] },\n      evidence: { type: 'string' },\n      recommendation: { type: 'string', enum: ['continue', 'steer', 'abort'] },\n      steer: { type: 'string' },\n      confidence: { type: 'number' },\n    },\n  },\n}\n\nexport async function auditIntent(\n  input: AuditIntentInput,\n  opts: AuditIntentOptions,\n): Promise<IntentAudit> {\n  const res = await opts.chat.chat(\n    {\n      ...(opts.model ? { model: opts.model } : {}),\n      jsonSchema: auditSchema as unknown as { name: string; schema: Record<string, unknown> },\n      messages: [\n        { role: 'system', content: opts.auditorInstruction ?? defaultAuditorInstruction },\n        {\n          role: 'user',\n          content:\n            `DECLARED INTENT (the task):\\n${input.declaredIntent}\\n\\n` +\n            (input.userIntent\n              ? `USER INTENT (the principal's actual goal):\\n${input.userIntent}\\n\\n`\n              : '') +\n            (input.metaIntent\n              ? `META-INTENT (what the whole run is for):\\n${input.metaIntent}\\n\\n`\n              : '') +\n            `TRAJECTORY (in order):\\n${summarize(input.trace, opts.maxTraceLines ?? 80)}\\n\\n` +\n            'Audit the route: revealed intent, verdict, evidence, one recommendation.',\n        },\n      ],\n    },\n    { ...(opts.signal ? { signal: opts.signal } : {}) },\n  )\n  let parsed: Partial<IntentAudit>\n  try {\n    parsed = JSON.parse(res.content) as Partial<IntentAudit>\n  } catch {\n    throw new Error(`auditIntent: auditor returned non-JSON: ${res.content.slice(0, 200)}`)\n  }\n  if (!parsed.verdict || !parsed.recommendation) {\n    throw new Error(`auditIntent: missing verdict/recommendation: ${res.content.slice(0, 200)}`)\n  }\n  return {\n    revealedIntent: parsed.revealedIntent ?? '',\n    verdict: parsed.verdict,\n    evidence: parsed.evidence ?? '',\n    recommendation: parsed.recommendation,\n    ...(parsed.steer ? { steer: parsed.steer } : {}),\n    confidence: typeof parsed.confidence === 'number' ? parsed.confidence : 0.5,\n  }\n}\n","/**\n * @experimental\n *\n * Completion / satisfiability — the OTHER output of the pluggable analyst (the steer output\n * is `AnalystFinding[]` via the `analyze` hook; this is the \"is it done?\" output via the\n * `complete` hook). A `CompletionAnalyst` reads a node's trace and returns a `CompletionVerdict`\n * the PARENT (driver) acts on: end the node, or keep going. It fits ANY node and composes to\n * any depth — a 1-deep loop has one; an N-deep tree has one per node.\n *\n * The verdict's authority scales with its DETERMINISM (the thing that varies by task):\n *   - `deterministic` — build/test/lint pass, a proof checks, every claim's citation resolves:\n *     ground truth, the driver TRUSTS it and ends. Not an opinion.\n *   - `probabilistic` — a quality/soundness judgment (marketing, \"the experiment is sound\"):\n *     ADVISORY. It passes to the driver with its reasons; the driver validates (here: a\n *     confidence threshold; a richer driver may re-examine the reasons) before ending.\n *\n * Two stop-signal mechanisms, by node mode, both → one `CompletionVerdict`:\n *   - sandbox-agent (text stream): a unique per-node STOP SENTINEL the agent emits when done\n *     (`stopSentinel` / `sentinelCompletion`) — ralph-loop style; the seed makes it\n *     unguessable + attributable, so it can't be spuriously emitted or confused with content.\n *   - deterministic check (compile/test/citation/proof): `deterministicCompletion(check)` —\n *     a verifier over the output, never the judge verdict (selector ≠ judge holds).\n */\n\nimport type { Iteration } from './types'\n\n/** Trace-derived evidence for a completion claim — an artifact (output) or a verifier metric,\n *  never the judge's own verdict. Mirrors the steer-firewall's provenance discipline. */\nexport interface CompletionEvidence {\n  kind: 'artifact' | 'metric'\n  uri: string\n}\n\n/** The \"is it done?\" verdict an analyst returns to the parent. */\nexport interface CompletionVerdict {\n  done: boolean\n  /** How verifiable the claim is — sets whether the driver trusts it or validates it. */\n  determinism: 'deterministic' | 'probabilistic'\n  /** Why the analyst believes it is (or isn't) done — what the driver validates. */\n  reasons?: string\n  /** 0..1, for probabilistic verdicts; the driver's validation threshold reads this. */\n  confidence?: number\n  evidence?: ReadonlyArray<CompletionEvidence>\n}\n\n/** Reads a node's trace → a completion verdict. Same input shape as the `analyze` hook, so\n *  ONE analyst node can back both channels (findings for steer, a verdict for stop). */\nexport interface CompletionAnalyst<Task, Output> {\n  assess(input: {\n    task: Task\n    history: ReadonlyArray<Iteration<Task, Output>>\n  }): CompletionVerdict | Promise<CompletionVerdict>\n}\n\n/** When a verdict authorizes the driver to END. Deterministic → trust (ground truth);\n *  probabilistic → validate by confidence threshold (the driver's check). */\nexport interface CompletionPolicy {\n  /** Minimum confidence a PROBABILISTIC verdict must clear to end. Default 0.8. */\n  minConfidence?: number\n}\n\nexport function completionAuthorizes(v: CompletionVerdict, policy?: CompletionPolicy): boolean {\n  if (!v?.done) return false\n  if (v.determinism === 'deterministic') return true\n  return (v.confidence ?? 0) >= (policy?.minConfidence ?? 0.8)\n}\n\n/**\n * A unique, attributable stop sentinel for a node (ralph-loop style). Deterministic from the\n * seed (no Math.random — reproducible + attributable to the node); the agent is instructed to\n * emit it VERBATIM when it judges itself done. Unguessable enough that content never trips it.\n */\nexport function stopSentinel(seed: string): string {\n  let h = 0x811c9dc5\n  for (let i = 0; i < seed.length; i += 1) {\n    h ^= seed.charCodeAt(i)\n    h = Math.imul(h, 0x01000193)\n  }\n  return `<<<{{STOP:${(h >>> 0).toString(16).padStart(8, '0')}}}>>>`\n}\n\n/**\n * Completion for a sandbox-agent node: done iff the latest output carries the node's stop\n * sentinel. PROBABILISTIC (the agent's own self-judgment) — the driver validates it.\n */\nexport function sentinelCompletion<Task>(\n  sentinel: string,\n  opts?: { confidence?: number },\n): CompletionAnalyst<Task, string> {\n  return {\n    assess({ history }) {\n      const last = history[history.length - 1]\n      const out = typeof last?.output === 'string' ? last.output : ''\n      const done = out.includes(sentinel)\n      return {\n        done,\n        determinism: 'probabilistic',\n        confidence: done ? (opts?.confidence ?? 0.9) : 0,\n        reasons: done ? 'agent emitted its assigned stop sentinel' : undefined,\n        evidence: done && last ? [{ kind: 'artifact', uri: `attempt:${last.index}` }] : [],\n      }\n    },\n  }\n}\n\n/**\n * Completion for a DETERMINISTIC check (build/test/lint/citation/proof): done iff the check\n * passes. Ground truth — the driver ends directly, no validation. The check reads the output\n * (a verifier), never the judge verdict — selector ≠ judge stays intact.\n */\nexport function deterministicCompletion<Task, Output>(\n  check: (\n    output: Output,\n    history: ReadonlyArray<Iteration<Task, Output>>,\n  ) => { passed: boolean; reasons?: string },\n): CompletionAnalyst<Task, Output> {\n  return {\n    assess({ history }) {\n      const last = history[history.length - 1]\n      if (last?.output === undefined) {\n        return { done: false, determinism: 'deterministic', reasons: 'no output yet' }\n      }\n      const r = check(last.output, history)\n      return {\n        done: r.passed,\n        determinism: 'deterministic',\n        reasons: r.reasons,\n        evidence: [{ kind: 'artifact', uri: `attempt:${last.index}` }],\n      }\n    },\n  }\n}\n","/**\n * @experimental\n *\n * Analyst-on-scope (G1) — the PORT of the round-synchronous driver's analyze→findings→steer\n * wire (`dynamic.ts`) onto the reactive `Scope`.\n *\n * The old dynamic driver wired the analyst at round boundaries: `plan` ran the analyst over\n * `history` BEFORE the planner and handed the findings forward via `PlannerContext.analyses`,\n * behind a provenance firewall (`assertTraceDerivedFindings`) that keeps the external write-only\n * judge out of the steer decision (selector ≠ judge). The reactive `Scope` has no rounds, so this\n * module carries the same wire across: a combinator's `act` asks a `ScopeAnalyst` to turn the\n * children it has drained off `scope.next()` SO FAR into `AnalystFinding[]`, and steers from THOSE\n * findings through a single `SteerContext`.\n *\n * The analyst itself is not a new type — it is \"just an `Agent<unknown, AnalystFinding[]>`\" the\n * combinator spawns over a child's trace (harness `null`/`cli`). `createScopeAnalyst` spawns that\n * agent through `Scope.spawn` (so its compute is metered by the conserved pool like any child),\n * drains its settlement, then enforces the firewall on the way out — a judge-derived finding\n * ABORTS, it is never filtered. Fail loud: a down analyst, a non-array result, or a tainted finding\n * throws; there is no silent empty-findings path that would let a combinator steer on nothing.\n */\n\nimport type { AnalystFinding } from '@tangle-network/agent-eval'\nimport { AnalystError, PlannerError } from '../../errors'\nimport type { Agent, Budget, DefaultVerdict, NodeId, Scope, Settled } from '../supervise/types'\nimport { stringifySafe } from '../util'\nimport type {\n  AssertTraceDerivedFindings,\n  Outcome,\n  ScopeAnalyst,\n  ScopeAnalyzeInput,\n  SteerContext,\n} from './wave-types'\n\n// ── The steer firewall (selector ≠ judge) — the single canonical impl ───────\n\n/**\n * The diagnosis a combinator steers from must be TRACE-derived, never JUDGE-derived. A finding\n * whose evidence is a judge/verdict score (an `EvidenceRef` of `kind:'metric'` with a\n * verdict/judge/score uri scheme) would smuggle the external write-only judge back into steering —\n * the one coupling the architecture forbids. This is a PROVENANCE check, not a content check:\n * span/event/artifact/finding refs and empty-evidence findings are allowed; only a judge-scheme\n * metric ref is rejected. Fail loud — a tainted finding aborts.\n */\nconst judgeEvidenceUri = /^(verdict|judge|score)\\b/i\n\nexport const assertTraceDerivedFindings: AssertTraceDerivedFindings = (findings) => {\n  for (const f of findings) {\n    for (const ref of f.evidence_refs ?? []) {\n      if (ref.kind === 'metric' && judgeEvidenceUri.test(ref.uri)) {\n        throw new PlannerError(\n          `steer-firewall: finding ${stringifySafe(f.finding_id)} cites judge-derived evidence ` +\n            `(${stringifySafe(ref.uri)}); findings fed to a combinator's steer decision must be ` +\n            'trace-derived, not judge-derived (selector ≠ judge)',\n        )\n      }\n    }\n  }\n}\n\n// ── The reactive analyst — an Agent the combinator spawns over the trace so far ───────\n\n/**\n * The analyst run an `Agent<unknown, AnalystFinding[]>` performs over the children settled so far.\n * The combinator supplies the analyst's task projection (how to frame the drained settlements as\n * the analyst's input) — the analyst's `act` reads the trace and returns its raw findings; the\n * firewall is enforced afterwards by `createScopeAnalyst`, not by the analyst itself.\n */\nexport interface CreateScopeAnalystOptions<D> {\n  /** The analyst agent the combinator spawns over the trace. `harness` is the persona's choice\n   *  (`null` for an inline router analyst, a `BackendType` for a sandboxed one). Its `act` returns\n   *  the RAW findings; this module asserts the firewall on them before returning. */\n  readonly analyst: Agent<unknown, ReadonlyArray<AnalystFinding>>\n  /** Build the analyst agent's task from the analyze input (the root-task framing + the children\n   *  drained so far). Pure projection — the analyst interprets it, this never reads it. */\n  buildTask(input: ScopeAnalyzeInput<D>): unknown\n  /** The conserved budget reserved for one analyst spawn. The pool reserves against it and fails\n   *  closed; an analyst that cannot be admitted is a fail-loud abort, never silent empty findings. */\n  readonly budget: Budget\n  /** Trace/journal label for the spawned analyst child. Default `'analyst'`. */\n  readonly label?: string\n}\n\n/**\n * Build a `ScopeAnalyst` that spawns the analyst agent through `Scope.spawn` (so its compute is\n * metered by the conserved pool), drains its single settlement, and enforces the trace-derived\n * firewall before returning. The `scope` is the SAME scope the combinator is draining its children\n * from — the analyst is spawned as a sibling and its result is read off `scope.next()` in cursor\n * order, replay-safe like any other child.\n *\n * Fail loud (no silent empty findings):\n *  - the pool refuses the analyst spawn → `AnalystError` (the steer would otherwise run on nothing)\n *  - the analyst settles `down` → `AnalystError` (a broken capture path, not a verdict)\n *  - the analyst returns a non-array → `PlannerError`\n *  - any finding cites judge-derived metric evidence → `PlannerError` via the firewall\n */\nexport function createScopeAnalyst<D>(\n  scope: Scope<Outcome<D>>,\n  options: CreateScopeAnalystOptions<D>,\n): ScopeAnalyst<D> {\n  if (!options.analyst || typeof options.analyst.act !== 'function') {\n    throw new AnalystError('createScopeAnalyst: analyst must be an Agent with an act() method')\n  }\n  const label = options.label ?? 'analyst'\n  return {\n    async analyze(input: ScopeAnalyzeInput<D>): Promise<ReadonlyArray<AnalystFinding>> {\n      const task = options.buildTask(input)\n      // The analyst is spawned into the combinator's own scope so its tokens are charged to the\n      // conserved pool. The pool fails closed; an analyst it cannot admit is a hard abort, not an\n      // excuse to steer on an empty diagnosis. The analyst's `Out` is `AnalystFinding[]`, not the\n      // scope's `Outcome<D>` — a genuinely heterogeneous child; the cast through `unknown` mirrors\n      // the keystone `spawnChild` seam, and the settlement is narrowed back by `readAnalystFindings`.\n      const spawned = scope.spawn(options.analyst as unknown as Agent<unknown, Outcome<D>>, task, {\n        budget: options.budget,\n        label,\n      })\n      if (!spawned.ok) {\n        throw new AnalystError(\n          `createScopeAnalyst: analyst spawn refused by the conserved pool (${spawned.reason}); ` +\n            `cannot steer node ${stringifySafe(input.nodeId)} on an unrun analyst`,\n        )\n      }\n      const settled = await drainAnalystSettlement(scope, spawned.handle.id)\n      const findings = readAnalystFindings(settled)\n      assertTraceDerivedFindings(findings)\n      return findings\n    },\n  }\n}\n\n/**\n * Drain `scope.next()` until the analyst child's own settlement is yielded, matching on its node\n * id so an unrelated sibling that settles first is skipped, not mistaken for the analyst. A\n * `ScopeAnalyst` is invoked AFTER a combinator has drained its workers, so in practice the analyst\n * is the only live child; the id match keeps it correct even when it is not. Fails loud if the\n * scope empties before the analyst settles (the steer would otherwise run on nothing).\n */\nasync function drainAnalystSettlement<D>(\n  scope: Scope<Outcome<D>>,\n  analystId: NodeId,\n): Promise<Settled<Outcome<D>>> {\n  for (;;) {\n    const settled = await scope.next()\n    if (settled === null) {\n      throw new AnalystError(\n        `createScopeAnalyst: scope drained before analyst ${stringifySafe(analystId)} settled`,\n      )\n    }\n    if (settled.handle.id === analystId) return settled\n  }\n}\n\n/**\n * Read the analyst child's settlement into its `AnalystFinding[]`. A `down` analyst is a broken\n * capture path (fail loud — not \"no findings\"); a `done` analyst whose `out` is not an array is a\n * malformed analyst (fail loud — the dynamic driver's `runAnalyze` contract, carried across).\n */\nfunction readAnalystFindings<D>(settled: Settled<Outcome<D>>): ReadonlyArray<AnalystFinding> {\n  if (settled.kind === 'down') {\n    throw new AnalystError(\n      `createScopeAnalyst: analyst ${stringifySafe(settled.handle.id)} settled down ` +\n        `(${settled.infra ? 'infra' : 'result'}): ${stringifySafe(settled.reason)}`,\n    )\n  }\n  const out = settled.out as unknown\n  if (!Array.isArray(out)) {\n    throw new PlannerError(\n      `createScopeAnalyst: analyst ${stringifySafe(settled.handle.id)} must return ` +\n        `AnalystFinding[], got ${stringifySafe(out)}`,\n    )\n  }\n  return out as ReadonlyArray<AnalystFinding>\n}\n\n// ── The single firewalled steer surface every combinator funnels through ──────────────\n\n/**\n * Build the `SteerContext` a combinator reads to steer (its `loopUntil.until`, `widen` gate, any\n * future steer). One place enforces the firewall: `findings` is asserted trace-derived before it is\n * surfaced, and `lastValidScore` is provided for OBSERVABILITY only — a combinator that steers off\n * it re-introduces selector = judge, the coupling the architecture forbids.\n *\n * `findings` is re-asserted here even when it came from `createScopeAnalyst` (which already asserted\n * it): the assertion is cheap and idempotent, and a `SteerContext` may be built from findings that\n * arrived by another path (a caller-supplied diagnosis). Belt-and-suspenders on the one coupling\n * that must never leak.\n */\nexport function buildSteerContext<D>(\n  findings: ReadonlyArray<AnalystFinding>,\n  settledSoFar: ReadonlyArray<Settled<Outcome<D>>>,\n): SteerContext<D> {\n  assertTraceDerivedFindings(findings)\n  const lastValidScore = observedBestScore(settledSoFar)\n  return {\n    findings,\n    settledSoFar,\n    ...(lastValidScore !== undefined ? { lastValidScore } : {}),\n  }\n}\n\n/**\n * The best valid score among the drained children — OBSERVABILITY ONLY. Read for rendering/traces,\n * never to make a steer decision (that is the selector = judge coupling). Reads `verdict.score` off\n * `done` settlements whose verdict is `valid`; a `down` child carries no verdict and contributes\n * nothing.\n */\nfunction observedBestScore<D>(\n  settledSoFar: ReadonlyArray<Settled<Outcome<D>>>,\n): number | undefined {\n  let best: number | undefined\n  for (const s of settledSoFar) {\n    if (s.kind !== 'done') continue\n    const v: DefaultVerdict | undefined = s.verdict\n    if (!v || v.valid !== true || typeof v.score !== 'number') continue\n    if (best === undefined || v.score > best) best = v.score\n  }\n  return best\n}\n","/**\n * @experimental\n *\n * Dynamic driver — the agent authors the loop topology at runtime.\n *\n * Where a fixed-shape driver encodes one topology as a pure function of\n * history, this driver delegates the per-round shape to an injected\n * `TopologyPlanner`. Each round the planner inspects the task + iteration\n * history and emits one `TopologyMove`:\n *   - `refine` → one task next round (optionally rewritten from the prior attempt)\n *   - `fanout` → N tasks next round (the kernel round-robins `agentRuns`, so a\n *     2-harness fanout dispatches branch 0 to harness A and branch 1 to harness B)\n *   - `stop`   → terminate; the kernel selects the winner across all iterations\n *\n * The planner is the brain; this driver is the structure. It maps moves onto\n * the kernel's `plan`/`decide` contract, enforces the iteration + fanout caps,\n * and fails loud on a malformed move. The planner is injected — so a test can\n * drive a deterministic policy through the real kernel, and production can wire\n * it to an LLM-backed, agent-authored planner.\n *\n * Topology is orthogonal to harness: the planner never names a backend. Which\n * harness runs a branch is decided by the `AgentRunSpec` the kernel round-robins\n * to, so one dynamic driver works across claude-code, codex, opencode, pi —\n * including fanning a single round across several at once.\n */\n\nimport type { AnalystFinding } from '@tangle-network/agent-eval'\nimport { PlannerError, ValidationError } from '../errors'\nimport {\n  type CompletionAnalyst,\n  type CompletionPolicy,\n  type CompletionVerdict,\n  completionAuthorizes,\n} from './completion'\n// The steer-firewall (selector ≠ judge) is single-sourced in `personify/analyst`; the dynamic\n// driver and the reactive combinators assert the SAME provenance check on findings.\nimport { assertTraceDerivedFindings } from './personify/analyst'\nimport type { Driver, Iteration, LoopPlanDescription } from './types'\nimport { stringifySafe } from './util'\n\n/** Terminal once `decide` returns `'done'` (a kernel terminal decision). */\nexport type DriverDecision = 'continue' | 'done'\n\n/**\n * One topology decision for the next round. `fanout` carries explicit tasks\n * rather than a count so the planner can issue heterogeneous branches (a\n * different sub-task per harness); pass N copies of one task for a homogeneous\n * fanout that relies on `agentRuns` diversity instead.\n *\n * @experimental\n */\nexport type TopologyMove<Task> =\n  | { kind: 'refine'; task: Task; rationale?: string; parentIndex?: number }\n  | { kind: 'fanout'; tasks: Task[]; rationale?: string; parentIndex?: number }\n  // `stop` carries no parentIndex — it never produces an edge, so the\n  // describePlan guard below reads parentIndex only on refine/fanout.\n  | { kind: 'stop'; rationale?: string }\n  // `select` — the planner AUTHORS the winner: terminal like stop, but the kernel\n  // uses iteration `index` as the winner instead of its argmax. The selector role\n  // made emittable. No edge → no parentIndex.\n  | { kind: 'select'; index: number; rationale?: string }\n\n/** @experimental */\nexport interface PlannerContext<Task, Output> {\n  /** The root task the loop was invoked with — stable across rounds. */\n  task: Task\n  /** Every iteration so far, in dispatch order, with outputs + verdicts. */\n  history: ReadonlyArray<Iteration<Task, Output>>\n  /** `history.length` — iterations already spent. */\n  iterationsSpent: number\n  /** Iterations left before the driver's `maxIterations` cap forces a stop. */\n  iterationsRemaining: number\n  /**\n   * Trace-analyst findings about the attempts so far — populated only when an\n   * `analyze` hook is wired into the driver (see CreateDriverOptions).\n   * This is the channel that lets the planner steer from the DIAGNOSIS\n   * (`f(trace, findings)`), not the verdict score alone. Undefined = no analyst\n   * wired (the planner runs exactly as before). @experimental\n   */\n  analyses?: ReadonlyArray<AnalystFinding>\n}\n\n/**\n * Chooses the next topology move from the task + history. Sync or async; an\n * async planner is where an LLM call goes (an agent-authored topology planner).\n *\n * @experimental\n */\nexport type TopologyPlanner<Task, Output> = (\n  ctx: PlannerContext<Task, Output>,\n) => TopologyMove<Task> | Promise<TopologyMove<Task>>\n\n/**\n * Input to the optional `analyze` hook: the root task + the trace so far. The\n * hook turns this into `AnalystFinding[]` — the caller's seam to `runAnalystLoop`.\n * @experimental\n */\nexport interface AnalyzeInput<Task, Output> {\n  task: Task\n  history: ReadonlyArray<Iteration<Task, Output>>\n}\n\n/** @experimental */\nexport interface CreateDriverOptions<Task, Output> {\n  /** The agent-authored topology policy. Invoked once per round in `plan`. */\n  planner: TopologyPlanner<Task, Output>\n  /**\n   * Optional trace-analyst hook. When set, the driver calls it each round AFTER\n   * the first (a trace must exist) and BEFORE the planner, then passes the\n   * findings to the planner via `PlannerContext.analyses` — so the planner\n   * decides from the diagnosis, not the verdict score alone. This is the seam to\n   * `runAnalystLoop`; it lives on the driver so `run-loop` stays analyst-free\n   * (the layering rule). Fail-loud: a throwing or non-array hook aborts the round\n   * (no silent empty findings).\n   */\n  analyze?: (\n    input: AnalyzeInput<Task, Output>,\n  ) => ReadonlyArray<AnalystFinding> | Promise<ReadonlyArray<AnalystFinding>>\n  /**\n   * Optional completion analyst — the DEPLOYABLE, non-oracle stop. Each round (after a\n   * trace exists) the driver asks \"is it done?\"; if the verdict AUTHORIZES ending\n   * (deterministic = trust ground truth; probabilistic = clears `completionPolicy`'s\n   * confidence), the driver stops BEFORE consulting the planner. This is the satisfiability\n   * primitive — usable at 1 deep, composing to any depth (one per node). Fail-loud: a\n   * throwing or non-verdict assess aborts the round. Distinct from `analyze` (the steer\n   * channel) though one analyst node may back both.\n   */\n  complete?: CompletionAnalyst<Task, Output>\n  /** Validation policy for a probabilistic completion verdict (the driver's check). */\n  completionPolicy?: CompletionPolicy\n  /**\n   * Hard safety cap on total iterations. When reached, the driver stops before\n   * consulting the planner. Default 8. Set the kernel's `runLoop`\n   * `maxIterations >= ` this so the driver's cap governs and the loop closes on\n   * a clean `'done'` rather than a truncated `'continue'`.\n   */\n  maxIterations?: number\n  /** Max branches a single `fanout` move may dispatch. Default 4. */\n  maxFanout?: number\n  /** Stable identifier surfaced in trace events. Default `'dynamic'`. */\n  name?: string\n}\n\n/** @experimental */\nexport function createDriver<Task, Output>(\n  options: CreateDriverOptions<Task, Output>,\n): Driver<Task, Output, DriverDecision> {\n  if (typeof options.planner !== 'function') {\n    throw new ValidationError('createDriver: planner must be a function')\n  }\n  const maxIterations = options.maxIterations ?? 8\n  if (!Number.isFinite(maxIterations) || maxIterations <= 0) {\n    throw new ValidationError('createDriver: maxIterations must be > 0')\n  }\n  const maxFanout = options.maxFanout ?? 4\n  if (!Number.isFinite(maxFanout) || maxFanout < 1) {\n    throw new ValidationError('createDriver: maxFanout must be >= 1')\n  }\n\n  // The kernel calls plan(), runs the batch, then calls decide() — strictly\n  // sequential, one driver instance per loop. Caching the move the planner\n  // chose this round lets decide() report terminality without re-invoking the\n  // planner (which would double every LLM call).\n  let pending: TopologyMove<Task> | undefined\n\n  return {\n    name: options.name ?? 'dynamic',\n    async plan(task, history) {\n      if (history.length >= maxIterations) {\n        pending = { kind: 'stop', rationale: `maxIterations (${maxIterations}) reached` }\n        return []\n      }\n      // The wire: turn the trace into a diagnosis BEFORE the planner decides, so\n      // the move is f(trace, findings), not f(verdict-score). Skipped on round 0\n      // (no trace to analyze). Fail-loud — a broken analyst aborts the round.\n      const analyses =\n        options.analyze && history.length > 0\n          ? await runAnalyze(options.analyze, task, history)\n          : undefined\n      // Deployable, non-oracle stop: ask the completion analyst \"is it done?\" BEFORE the\n      // planner. If the verdict authorizes ending (deterministic trust / probabilistic\n      // threshold), terminate now. This is the satisfiability primitive at this node.\n      if (options.complete && history.length > 0) {\n        const verdict = await runComplete(options.complete, task, history)\n        if (completionAuthorizes(verdict, options.completionPolicy)) {\n          pending = {\n            kind: 'stop',\n            rationale: `complete (${verdict.determinism}): ${verdict.reasons ?? 'satisfied'}`,\n          }\n          return []\n        }\n      }\n      const move = await options.planner({\n        task,\n        history,\n        iterationsSpent: history.length,\n        iterationsRemaining: maxIterations - history.length,\n        ...(analyses ? { analyses } : {}),\n      })\n      pending = validateMove(move, maxFanout)\n      if (pending.kind === 'select') {\n        // The planner may override the kernel's argmax, but not invent a winner:\n        // the selected iteration must be a completed attempt that produced output.\n        // Range + output are checked here, where history is in scope. Fail loud.\n        const iter = history[pending.index]\n        if (!iter || iter.output === undefined) {\n          throw new PlannerError(\n            `dynamic planner select.index ${pending.index} is not a completed iteration with output (history length ${history.length})`,\n          )\n        }\n      }\n      switch (pending.kind) {\n        case 'refine':\n          return [pending.task]\n        case 'fanout':\n          return pending.tasks\n        case 'stop':\n        case 'select':\n          return []\n      }\n    },\n    decide() {\n      // pending is set by the plan() call that immediately precedes every\n      // decide(). `stop` and `select` terminate; refine/fanout keep looping so\n      // plan() — and thus the planner — runs again next round.\n      return pending?.kind === 'stop' || pending?.kind === 'select' ? 'done' : 'continue'\n    },\n    describePlan() {\n      // Surface the move the planner just chose (kind + rationale + an optional\n      // DECLARED branch source) so the kernel's loop.plan trace carries the\n      // agent's intent — including faithful edge lineage when the planner\n      // branched off a specific (non-winner) iteration. `pending` is the move\n      // set by the preceding plan().\n      if (!pending) return undefined\n      const out: LoopPlanDescription = { kind: pending.kind }\n      if (pending.rationale !== undefined) out.rationale = pending.rationale\n      if (\n        (pending.kind === 'refine' || pending.kind === 'fanout') &&\n        pending.parentIndex !== undefined\n      ) {\n        out.parentIndex = pending.parentIndex\n      }\n      return out\n    },\n    selectWinner(history) {\n      // Authored winner: only when the last move was `select`. The kernel calls\n      // this at finalize (absent a caller-supplied selectWinner); returning\n      // undefined for every other move falls through to the default argmax. The\n      // selected iteration's output presence was enforced in plan().\n      if (pending?.kind !== 'select') return undefined\n      const iter = history[pending.index]\n      if (!iter || iter.output === undefined) return undefined\n      return {\n        task: iter.task,\n        output: iter.output,\n        verdict: iter.verdict,\n        iterationIndex: iter.index,\n        agentRunName: iter.agentRunName,\n      }\n    },\n  }\n}\n\nfunction validateMove<Task>(move: TopologyMove<Task>, maxFanout: number): TopologyMove<Task> {\n  if (!move || typeof move !== 'object' || typeof (move as { kind?: unknown }).kind !== 'string') {\n    throw new PlannerError(`dynamic planner returned a non-move value: ${stringifySafe(move)}`)\n  }\n  switch (move.kind) {\n    case 'refine':\n      return move\n    case 'stop':\n      return move\n    case 'select': {\n      if (!Number.isInteger(move.index) || move.index < 0) {\n        throw new PlannerError(\n          `dynamic planner select move must carry a non-negative integer index, got ${stringifySafe(move.index)}`,\n        )\n      }\n      return move\n    }\n    case 'fanout': {\n      if (!Array.isArray(move.tasks) || move.tasks.length === 0) {\n        throw new PlannerError('dynamic planner fanout move must carry a non-empty tasks[]')\n      }\n      if (move.tasks.length <= maxFanout) return move\n      // Clamp rather than reject — over-fanning is a budget concern, not a\n      // structural error. The clamp is recorded in the rationale for traces.\n      return {\n        kind: 'fanout',\n        tasks: move.tasks.slice(0, maxFanout),\n        rationale: `${move.rationale ?? ''} [clamped ${move.tasks.length}→${maxFanout}]`.trim(),\n      }\n    }\n    default:\n      throw new PlannerError(\n        `dynamic planner returned unknown move kind: ${stringifySafe((move as { kind: unknown }).kind)}`,\n      )\n  }\n}\n\n/** Call the analyze hook and fail loud on a non-array return (no silent empty). */\nasync function runAnalyze<Task, Output>(\n  analyze: NonNullable<CreateDriverOptions<Task, Output>['analyze']>,\n  task: Task,\n  history: ReadonlyArray<Iteration<Task, Output>>,\n): Promise<ReadonlyArray<AnalystFinding>> {\n  const findings = await analyze({ task, history })\n  if (!Array.isArray(findings)) {\n    throw new PlannerError(\n      `createDriver: analyze hook must return AnalystFinding[], got ${stringifySafe(findings)}`,\n    )\n  }\n  assertTraceDerivedFindings(findings)\n  return findings\n}\n\n/** Call the completion analyst and fail loud on a non-verdict return (no silent \"not done\"). */\nasync function runComplete<Task, Output>(\n  complete: CompletionAnalyst<Task, Output>,\n  task: Task,\n  history: ReadonlyArray<Iteration<Task, Output>>,\n): Promise<CompletionVerdict> {\n  const verdict = await complete.assess({ task, history })\n  if (\n    !verdict ||\n    typeof verdict.done !== 'boolean' ||\n    (verdict.determinism !== 'deterministic' && verdict.determinism !== 'probabilistic')\n  ) {\n    throw new PlannerError(\n      `createDriver: complete.assess must return a CompletionVerdict {done, determinism}, got ${stringifySafe(verdict)}`,\n    )\n  }\n  return verdict\n}\n\n/**\n * Compact, planner-facing rendering of trace-analyst findings — the diagnosis the\n * planner steers from. Empty input renders to '' (callers omit the section). Shows\n * severity·area·claim·recommended_action·confidence; raw evidence_refs/metadata are\n * for renderers that know the analyst, not the topology decision.\n * @experimental\n */\nexport function renderAnalyses(findings: ReadonlyArray<AnalystFinding>): string {\n  if (findings.length === 0) return ''\n  const rows = findings.map((f) => {\n    const action = f.recommended_action ? ` → ${f.recommended_action}` : ''\n    return `  - [${f.severity}/${f.area}] ${f.claim}${action} (conf ${f.confidence.toFixed(2)})`\n  })\n  return `Trace-analyst findings (diagnosis of the attempts so far — steer from these, not the verdict score alone):\\n${rows.join('\\n')}`\n}\n","/**\n * The third-person observer — the connective tissue that closes the loop.\n *\n * A driver spawns a worker; the worker can't see itself. `observe` reads the\n * worker's TRACE (what it actually did — every tool call, cost, failure) and\n * produces two streams:\n *   - `findings` / `report` — fed back DOWN (a steer for the next attempt) and\n *     OUT (the operator-facing \"what I noticed + what to change\").\n *   - `learned` — durable facts written to the cross-run `Corpus` so the NEXT\n *     run starts smarter (the continuous half of \"continuous self-improvement\").\n *\n * Findings are TRACE-derived, never JUDGE-derived (`derived_from_judge:false`):\n * the observer reads behavior, never the acceptance verdict — the selector≠judge\n * firewall (docs/learning-flywheel.md). The observer is harness-agnostic: it\n * reads a trace + an output, so it watches opencode, codex, hermes, or a BYO\n * agent identically.\n */\nimport { type AnalystFinding, type ChatClient, makeFinding } from '@tangle-network/agent-eval'\nimport type { Corpus, CorpusRecord } from './personify/wave-types'\n\nconst observerId = 'observe/trace'\n\nexport interface ObserveInput {\n  /** What the worker was asked to do. */\n  task: string\n  /** What it produced (its final answer / artifact summary). */\n  output: string\n  /** The worker's trace — any event array (sandbox events, tool-call records). */\n  trace: ReadonlyArray<unknown>\n  /** Terminal status only (passed/failed/unknown) — NOT a judge score; the\n   *  observer never reads the verdict, it reads behavior. */\n  outcome?: 'passed' | 'failed' | 'unknown'\n  /** Provenance back to the run. */\n  runId?: string\n}\n\nexport interface ObserveOptions {\n  /** The model-call seam (agent-eval `createChatClient`: router / cli-bridge / …). */\n  chat: ChatClient\n  model?: string\n  /** When set, learned facts are appended (idempotent) for the next run to read. */\n  corpus?: Corpus\n  /** Tags written onto learned facts + used by the next run's corpus query. */\n  tags?: ReadonlyArray<string>\n  signal?: AbortSignal\n  /** Cap the trace lines fed to the observer (keeps the call cheap). Default 80. */\n  maxTraceLines?: number\n  /** Override the analyst's system instruction — the prompt that turns a trace into\n   *  findings + recommended_actions. The analyst IS the steerer, so this is the knob a\n   *  prompt optimizer (GEPA) tunes. Omitted ⇒ the default observer instruction. The\n   *  firewall (trace-only, never the verdict) is structural (input has no score), so a\n   *  custom instruction cannot break it. */\n  analystInstruction?: string\n}\n\n/** The default observer instruction — exported so an optimizer can seed its population. */\nexport const defaultAnalystInstruction =\n  'You are a third-person OBSERVER watching an AI agent work. You see its TRACE (what it did), not its grader. ' +\n  'From the trace, name SPECIFIC, behavior-grounded findings: wasted/duplicated tool calls, thrash/retries, ' +\n  'token/cost waste, missing verification, failure patterns. For each, a concrete recommended_action, and ' +\n  'whether the AGENT (fix its skills/prompt/tools) or the OPERATOR (fix framing/decomposition/config) should act. ' +\n  'Only claim what the trace shows. No findings if the run was clean.'\n\nexport interface Observation {\n  findings: AnalystFinding[]\n  /** Facts persisted to the corpus (empty when no corpus was supplied). */\n  learned: CorpusRecord[]\n  /** Operator-facing markdown: what the observer noticed + what to change. */\n  report: string\n}\n\n/** Compact the trace into the lines the observer reasons over — tool calls,\n *  errors, and statuses, in order. Keeps the model call bounded + grounded. */\nfunction summarizeTrace(trace: ReadonlyArray<unknown>, maxLines: number): string {\n  const lines: string[] = []\n  for (const ev of trace) {\n    const e = ev as { type?: string; data?: Record<string, unknown> }\n    const t = (e.type ?? '').toLowerCase()\n    const d = e.data ?? {}\n    const part = (d.part ?? {}) as { type?: string; tool?: string; state?: { status?: string } }\n    if (part.type === 'tool')\n      lines.push(`tool:${part.tool}${part.state?.status ? `(${part.state.status})` : ''}`)\n    else if (t.includes('error'))\n      lines.push(`ERROR: ${String(d.message ?? d.detail ?? '').slice(0, 200)}`)\n    else if (t === 'status' && typeof d.status === 'string') lines.push(`status:${d.status}`)\n    else if (t.includes('tool')) lines.push(`tool-event:${t}`)\n  }\n  // Collapse runs of identical lines into \"xN\" so repeated thrash is visible + short.\n  const out: string[] = []\n  for (const ln of lines) {\n    const prev = out[out.length - 1]\n    const m = prev?.match(/^(.*?)(?: x(\\d+))?$/)\n    if (m && m[1] === ln) out[out.length - 1] = `${ln} x${(Number(m[2]) || 1) + 1}`\n    else out.push(ln)\n  }\n  return out.slice(0, maxLines).join('\\n') || '(no tool/error events in trace)'\n}\n\nconst findingsSchema = {\n  name: 'observer_findings',\n  schema: {\n    type: 'object',\n    additionalProperties: false,\n    properties: {\n      findings: {\n        type: 'array',\n        items: {\n          type: 'object',\n          additionalProperties: false,\n          properties: {\n            area: {\n              type: 'string',\n              description: 'tool-use | cost | verification | process | failure | latency',\n            },\n            severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'] },\n            claim: {\n              type: 'string',\n              description: 'what you OBSERVED in the trace (a fact, with the evidence)',\n            },\n            recommended_action: {\n              type: 'string',\n              description: 'the concrete change for the agent or operator',\n            },\n            audience: {\n              type: 'string',\n              enum: ['agent', 'operator'],\n              description: 'who should act on this',\n            },\n            confidence: { type: 'number' },\n          },\n          required: ['area', 'severity', 'claim', 'recommended_action', 'audience', 'confidence'],\n        },\n      },\n    },\n    required: ['findings'],\n  },\n} as const\n\nexport async function observe(input: ObserveInput, opts: ObserveOptions): Promise<Observation> {\n  const traceSummary = summarizeTrace(input.trace, opts.maxTraceLines ?? 80)\n  const res = await opts.chat.chat(\n    {\n      ...(opts.model ? { model: opts.model } : {}),\n      jsonSchema: findingsSchema as unknown as { name: string; schema: Record<string, unknown> },\n      messages: [\n        {\n          role: 'system',\n          content: opts.analystInstruction ?? defaultAnalystInstruction,\n        },\n        {\n          role: 'user',\n          content:\n            `TASK: ${input.task}\\n\\nOUTCOME: ${input.outcome ?? 'unknown'}\\n\\n` +\n            `FINAL OUTPUT (truncated):\\n${input.output.slice(0, 1200)}\\n\\n` +\n            `TRACE (in order; \"xN\" = repeated):\\n${traceSummary}`,\n        },\n      ],\n    },\n    { ...(opts.signal ? { signal: opts.signal } : {}) },\n  )\n\n  const parsed = parseFindings(res.content)\n  const producedAt = input.runId ? `${input.runId}` : observerId\n  const findings: AnalystFinding[] = parsed.map((f) =>\n    makeFinding({\n      analyst_id: observerId,\n      area: `${f.area}`,\n      severity: f.severity,\n      claim: f.claim,\n      recommended_action: f.recommended_action,\n      confidence: typeof f.confidence === 'number' ? f.confidence : 0.5,\n      evidence_refs: [],\n      // The observer reads BEHAVIOR, never the judge verdict — firewall provenance.\n      derived_from_judge: false,\n      metadata: { audience: f.audience },\n      ...(input.runId ? { subject: input.runId } : {}),\n    }),\n  )\n\n  const learned: CorpusRecord[] = []\n  if (opts.corpus) {\n    for (const f of findings) {\n      const record: CorpusRecord = {\n        schemaVersion: '1.0.0',\n        id: f.finding_id,\n        runId: input.runId ?? observerId,\n        producedAt: f.produced_at ?? producedAt,\n        area: f.area,\n        claim: f.recommended_action ?? f.claim,\n        ...(f.claim ? { rationale: f.claim } : {}),\n        tags: [...(opts.tags ?? []), `audience:${(f.metadata?.audience as string) ?? 'agent'}`],\n        confidence: f.confidence,\n        evidence: [{ kind: 'finding', uri: f.finding_id }],\n      }\n      const r = await opts.corpus.append(record)\n      if (r.succeeded) learned.push(record)\n    }\n  }\n\n  return { findings, learned, report: renderReport(findings) }\n}\n\ninterface RawFinding {\n  area: string\n  severity: AnalystFinding['severity']\n  claim: string\n  recommended_action: string\n  audience: 'agent' | 'operator'\n  confidence: number\n}\n\nfunction parseFindings(content: string): RawFinding[] {\n  let obj: unknown\n  try {\n    obj = JSON.parse(content)\n  } catch {\n    const m = content.match(/\\{[\\s\\S]*\\}/)\n    obj = m ? JSON.parse(m[0]) : { findings: [] }\n  }\n  const arr = (obj as { findings?: unknown }).findings\n  return Array.isArray(arr) ? (arr as RawFinding[]) : []\n}\n\n/** Operator-facing report, split by who should act. The agent block is the\n *  steer; the operator block is the advice. */\nexport function renderReport(findings: ReadonlyArray<AnalystFinding>): string {\n  if (findings.length === 0) return '✓ clean run — the observer found nothing to change.'\n  const audience = (f: AnalystFinding): string => (f.metadata?.audience as string) ?? 'agent'\n  const forAgent = findings.filter((f) => audience(f) === 'agent')\n  const forOperator = findings.filter((f) => audience(f) === 'operator')\n  const block = (title: string, fs: ReadonlyArray<AnalystFinding>): string =>\n    fs.length === 0\n      ? ''\n      : `**${title}**\\n${fs\n          .map((f) => `- [${f.severity}] ${f.claim}\\n  → ${f.recommended_action ?? ''}`)\n          .join('\\n')}\\n`\n  return [\n    block('For the agent (fix skills / prompt / tools)', forAgent),\n    block('For you (the operator)', forOperator),\n  ]\n    .filter(Boolean)\n    .join('\\n')\n}\n","/**\n * harvestCorpus — production traces → corpus, the G2 bridge (the playbook's step 6).\n * The flywheel's write side, batched: run the firewalled `observe()` analyst over a\n * stream of completed runs (yesterday's production traces, a benchmark's rollouts, a\n * fleet's day) and accrete the trace-derived facts into the durable corpus.\n *\n * Store-agnostic by design: the caller maps its trace store's rows (a\n * `ProductionTraceSink` ndjson, OTLP spans, RunRecords) to `ObserveInput` — task text,\n * final output, the event trace, terminal outcome. The analyst reads BEHAVIOR only\n * (the firewall is structural: the input carries no judge verdict), and corpus appends\n * are idempotent on (claim + tags), so re-harvesting the same window is safe.\n *\n * The nightly product job is then three lines:\n *   const runs = mapSinkRowsToObserveInputs(await readSink(yesterday))\n *   const report = await harvestCorpus({ runs, chat, corpus, tags: ['gtm-agent'] })\n *   log(report)   // runsObserved / findings / learned / failures\n *\n * NOTE on the read side: harvesting is safe and cheap; *injecting* facts back into runs\n * is the measured danger zone — naive unconditional priming tested NEGATIVE (−11.6pp,\n * context pollution; docs/research/layer-across-run.md). Gate any priming design on its\n * own A/B; the corpus's first consumers are operators and optimizers, not prompts.\n */\n\nimport type { ChatClient } from '@tangle-network/agent-eval'\nimport { type Observation, type ObserveInput, observe } from './observe'\nimport type { Corpus } from './personify/wave-types'\n\nexport interface HarvestCorpusOptions {\n  /** The completed runs to analyze — map your store's rows to `ObserveInput`. */\n  runs: AsyncIterable<ObserveInput> | Iterable<ObserveInput>\n  /** The model-call seam (agent-eval `createChatClient`). */\n  chat: ChatClient\n  model?: string\n  /** The durable corpus the facts accrete into. */\n  corpus: Corpus\n  /** Tags written onto learned facts (the product/domain key the read side queries by). */\n  tags?: ReadonlyArray<string>\n  /** Override the analyst instruction (the GEPA-tunable knob). */\n  analystInstruction?: string\n  /** Runs analyzed in parallel. Default 4. */\n  concurrency?: number\n  /** Hard cap on runs consumed from the stream (a cost guard for unbounded stores). */\n  maxRuns?: number\n  signal?: AbortSignal\n}\n\nexport interface HarvestFailure {\n  runId: string\n  error: string\n}\n\nexport interface HarvestReport {\n  runsObserved: number\n  /** Total findings the analyst produced (including ones already known). */\n  findings: number\n  /** NEW facts actually appended (idempotent dedup excludes re-learned ones). */\n  learned: number\n  /** Per-run analysis failures — reported, never silently dropped. */\n  failures: HarvestFailure[]\n}\n\nexport async function harvestCorpus(opts: HarvestCorpusOptions): Promise<HarvestReport> {\n  const concurrency = Math.max(1, opts.concurrency ?? 4)\n  const report: HarvestReport = { runsObserved: 0, findings: 0, learned: 0, failures: [] }\n\n  // Normalize to an async iterator and pull cooperatively from N workers.\n  const iterator = (\n    Symbol.asyncIterator in Object(opts.runs)\n      ? (opts.runs as AsyncIterable<ObserveInput>)[Symbol.asyncIterator]()\n      : (async function* () {\n          yield* opts.runs as Iterable<ObserveInput>\n        })()\n  ) as AsyncIterator<ObserveInput>\n\n  let consumed = 0\n  let done = false\n  const next = async (): Promise<ObserveInput | null> => {\n    if (done || (opts.maxRuns !== undefined && consumed >= opts.maxRuns)) return null\n    const r = await iterator.next()\n    if (r.done) {\n      done = true\n      return null\n    }\n    consumed += 1\n    return r.value\n  }\n\n  const workers = Array.from({ length: concurrency }, async () => {\n    for (let input = await next(); input !== null; input = await next()) {\n      if (opts.signal?.aborted) return\n      try {\n        const obs: Observation = await observe(input, {\n          chat: opts.chat,\n          ...(opts.model ? { model: opts.model } : {}),\n          corpus: opts.corpus,\n          tags: opts.tags ?? [],\n          ...(opts.analystInstruction ? { analystInstruction: opts.analystInstruction } : {}),\n          ...(opts.signal ? { signal: opts.signal } : {}),\n        })\n        report.runsObserved += 1\n        report.findings += obs.findings.length\n        report.learned += obs.learned.length\n      } catch (e) {\n        report.failures.push({\n          runId: input.runId ?? `run-${consumed}`,\n          error: e instanceof Error ? e.message.slice(0, 300) : String(e),\n        })\n      }\n    }\n  })\n  await Promise.all(workers)\n\n  // Fail loud when the whole batch failed — that's an infra problem, not a quiet no-op.\n  if (report.runsObserved === 0 && report.failures.length > 0) {\n    throw new Error(\n      `harvestCorpus: every run failed analysis (${report.failures.length}) — first: ${report.failures[0]?.error}`,\n    )\n  }\n  return report\n}\n","/**\n * The ONE pseudo-box adapter: present any one-shot `Executor` (router / bridge /\n * BYO) as a `SandboxClient` so the round-synchronous `runLoop` can drive it\n * without each call site re-faking a box. This is the single shell that\n * `bench/src/router-executor.ts`, generate-eval's old `bridgeSandboxClient`, and\n * the search-bench bridge transport were each re-implementing.\n *\n * It is deliberately for NON-box executors only — a real sandbox harness already\n * IS a `SandboxClient` (boxes, sessions, fs, fork are real there). Here each\n * `streamPrompt` runs the executor once and emits the terminal\n * `{type:'result', data:{finalText, tokenUsage, costUsd}}` event that\n * `answerOutput`/the kernel's cost ledger already parse — no sessions, no fs,\n * no fork (those degrade gracefully via the optional `SandboxClient` methods).\n */\nimport type { CreateSandboxOptions, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox'\nimport type { AgentSpec, Executor, ExecutorFactory, ExecutorResult } from './supervise/types'\nimport type { SandboxClient } from './types'\n\nfunction isAsyncIterable(v: unknown): v is AsyncIterable<unknown> {\n  return typeof v === 'object' && v !== null && Symbol.asyncIterator in v\n}\n\n/** Drive a (possibly streaming) executor to its terminal artifact. */\nasync function settle(\n  exec: Executor<unknown>,\n  task: unknown,\n  signal: AbortSignal,\n): Promise<ExecutorResult<unknown>> {\n  const r = exec.execute(task, signal)\n  if (isAsyncIterable(r)) {\n    for await (const _ of r) {\n      // streaming executors meter as they run; the artifact is read after drain.\n    }\n    return exec.resultArtifact()\n  }\n  return r\n}\n\n/**\n * Adapt an `ExecutorFactory` into a `SandboxClient` for `runLoop`. The factory is\n * instantiated fresh per `streamPrompt` (mirrors the per-spawn executor lifecycle):\n * run once on the prompt, emit the terminal result event, tear down.\n */\nexport function inlineSandboxClient(factory: ExecutorFactory<unknown>): SandboxClient {\n  let seq = 0\n  return {\n    async create(_options?: CreateSandboxOptions): Promise<SandboxInstance> {\n      const id = `inline-${seq++}`\n      return {\n        id,\n        async *streamPrompt(message: string): AsyncGenerator<SandboxEvent> {\n          const controller = new AbortController()\n          const spec: AgentSpec = { profile: { name: id }, harness: null }\n          const exec = factory(spec, { signal: controller.signal, seams: {} })\n          try {\n            const artifact = await settle(exec, message, controller.signal)\n            const out = artifact.out as { content?: string } | undefined\n            // Speak the runtime's metering protocol: `extractLlmCallEvent` reads\n            // flat `llm_call` events, not the nested result payload — without\n            // this the kernel meters the iteration as a fabricated $0 / 0 tokens.\n            const tokensIn = artifact.spent.tokens.input\n            const tokensOut = artifact.spent.tokens.output\n            const costUsd = artifact.spent.usd\n            if (tokensIn || tokensOut || costUsd) {\n              yield {\n                type: 'llm_call',\n                data: { tokensIn, tokensOut, costUsd },\n              } as unknown as SandboxEvent\n            }\n            yield {\n              type: 'result',\n              data: {\n                finalText: out?.content ?? '',\n                tokenUsage: {\n                  inputTokens: tokensIn,\n                  outputTokens: tokensOut,\n                },\n                costUsd,\n              },\n            } as unknown as SandboxEvent\n          } finally {\n            await exec.teardown('brutalKill').catch(() => {})\n          }\n        },\n        async delete(): Promise<void> {},\n      } as unknown as SandboxInstance\n    },\n  }\n}\n","/**\n * Bridge a finished `runLoop` into an agent-eval campaign / profile-matrix\n * dispatch.\n *\n * `runProfileMatrix` (and `runCampaign`) run the backend-integrity guard over\n * the token usage a dispatch reports through `ctx.cost`. A dispatch that wraps\n * `runLoop` must forward the loop's cost AND token usage, or the guard reads\n * the run as a stub and throws. `reportLoopUsage` is that one line:\n *\n *   const dispatch: ProfileDispatchFn<S, A> = async (profile, scenario, ctx) => {\n *     const result = await runLoop({ ...optsFor(profile, scenario), ctx: loopCtx })\n *     reportLoopUsage(ctx, result)\n *     return result.winner?.output as A\n *   }\n *\n * Typed structurally against the campaign `DispatchContext.cost` so this module\n * stays free of an agent-eval import — it works with any cost meter exposing\n * `observe` + `observeTokens`.\n */\n\nimport type { LoopResult, LoopTokenUsage } from './types'\n\n/** The slice of an agent-eval campaign `DispatchContext.cost` this needs. */\nexport interface UsageSink {\n  observe(amountUsd: number, source: string): void\n  observeTokens(usage: LoopTokenUsage): void\n}\n\n/**\n * Forward a `LoopResult`'s aggregated cost + token usage into a campaign cost\n * meter so the backend-integrity guard sees real LLM activity. `source`\n * defaults to `'loop'`.\n */\nexport function reportLoopUsage<Task, Output, Decision>(\n  cost: UsageSink,\n  result: Pick<LoopResult<Task, Output, Decision>, 'costUsd' | 'tokenUsage'>,\n  source = 'loop',\n): void {\n  cost.observe(result.costUsd, source)\n  cost.observeTokens(result.tokenUsage)\n}\n","/**\n * @experimental\n *\n * Runtime hook contracts. Hooks are execution-scoped observers, not part of an\n * `AgentProfile`: profiles stay portable agent recipes; hooks attach to the\n * loop or product harness that is running the profile.\n */\n\nexport type RuntimeHookPhase = 'before' | 'after' | 'error' | 'event'\n\nexport type RuntimeHookTarget =\n  | 'agent.run'\n  | 'agent.turn'\n  | 'agent.tool_call'\n  | 'agent.spawn'\n  | 'agent.child'\n  | 'agent.plan'\n  | 'agent.decision'\n  | (string & {})\n\nexport type RuntimeDecisionKind =\n  | 'continue'\n  | 'verify'\n  | 'ask'\n  | 'retry'\n  | 'stop'\n  | 'memory-write'\n  | 'memory-read'\n  | 'tool-select'\n  | 'skill-select'\n  | 'workflow-select'\n  | 'surface-promote'\n  | (string & {})\n\nexport interface RuntimeHookEvent<Payload = unknown> {\n  id: string\n  runId: string\n  scenarioId?: string\n  target: RuntimeHookTarget\n  phase: RuntimeHookPhase\n  timestamp: number\n  stepIndex?: number\n  parentId?: string\n  payload?: Payload\n  metadata?: Record<string, unknown>\n}\n\nexport interface RuntimeHookContext {\n  signal?: AbortSignal\n}\n\nexport interface RuntimeDecisionEvidenceRef {\n  source: string\n  id: string\n  detail?: string\n  metadata?: Record<string, unknown>\n}\n\nexport interface RuntimeDecisionPoint {\n  id: string\n  runId: string\n  scenarioId?: string\n  stepIndex: number\n  kind: RuntimeDecisionKind\n  candidateActions: string[]\n  context?: string\n  evidence: RuntimeDecisionEvidenceRef[]\n  metadata?: Record<string, unknown>\n}\n\nexport interface RuntimeHookErrorContext {\n  hook: 'onEvent' | 'onDecisionPoint'\n  eventId?: string\n  target?: RuntimeHookTarget\n  phase?: RuntimeHookPhase\n  decisionId?: string\n  decisionKind?: RuntimeDecisionKind\n}\n\nexport interface RuntimeHooks {\n  /**\n   * General before/after/event hook. Use this for telemetry, memory capture,\n   * policy wrapping, child lifecycle observers, or product-specific extension\n   * points.\n   */\n  onEvent?: (event: RuntimeHookEvent, context: RuntimeHookContext) => void | Promise<void>\n  /**\n   * Semantic decision hook. Belief-state evaluation consumes this, but runtime\n   * code should keep emitting ordinary lifecycle events as the base layer.\n   */\n  onDecisionPoint?: (\n    point: RuntimeDecisionPoint,\n    context: RuntimeHookContext,\n  ) => void | Promise<void>\n  onHookError?: (error: Error, context: RuntimeHookErrorContext) => void | Promise<void>\n}\n\nexport function defineRuntimeHooks(hooks: RuntimeHooks): RuntimeHooks {\n  return hooks\n}\n\nexport function composeRuntimeHooks(\n  ...entries: Array<RuntimeHooks | undefined | null | false>\n): RuntimeHooks {\n  const hooks = entries.filter((entry): entry is RuntimeHooks => !!entry)\n  return {\n    onEvent: hooks.some((hook) => hook.onEvent)\n      ? (event, context) => {\n          const pending: Promise<unknown>[] = []\n          for (const hook of hooks) {\n            const result = hook.onEvent?.(event, context)\n            if (isThenable(result)) pending.push(Promise.resolve(result))\n          }\n          if (pending.length > 0) return Promise.all(pending).then(() => undefined)\n          return undefined\n        }\n      : undefined,\n    onDecisionPoint: hooks.some((hook) => hook.onDecisionPoint)\n      ? (point, context) => {\n          const pending: Promise<unknown>[] = []\n          for (const hook of hooks) {\n            const result = hook.onDecisionPoint?.(point, context)\n            if (isThenable(result)) pending.push(Promise.resolve(result))\n          }\n          if (pending.length > 0) return Promise.all(pending).then(() => undefined)\n          return undefined\n        }\n      : undefined,\n    onHookError: hooks.some((hook) => hook.onHookError)\n      ? (error, context) => {\n          const pending: Promise<unknown>[] = []\n          for (const hook of hooks) {\n            const result = hook.onHookError?.(error, context)\n            if (isThenable(result)) pending.push(Promise.resolve(result))\n          }\n          if (pending.length > 0) return Promise.all(pending).then(() => undefined)\n          return undefined\n        }\n      : undefined,\n  }\n}\n\nexport function notifyRuntimeHookEvent(\n  hooks: RuntimeHooks | undefined,\n  event: RuntimeHookEvent,\n  context: RuntimeHookContext = {},\n): void {\n  const onEvent = hooks?.onEvent\n  if (!onEvent) return\n\n  try {\n    const result = onEvent(event, context)\n    if (isThenable(result)) {\n      void result.catch((error) => {\n        notifyRuntimeHookError(hooks, toError(error), {\n          hook: 'onEvent',\n          eventId: event.id,\n          target: event.target,\n          phase: event.phase,\n        })\n      })\n    }\n  } catch (error) {\n    notifyRuntimeHookError(hooks, toError(error), {\n      hook: 'onEvent',\n      eventId: event.id,\n      target: event.target,\n      phase: event.phase,\n    })\n  }\n}\n\nexport function notifyRuntimeDecisionPoint(\n  hooks: RuntimeHooks | undefined,\n  point: RuntimeDecisionPoint,\n  context: RuntimeHookContext = {},\n): void {\n  const onDecisionPoint = hooks?.onDecisionPoint\n  if (!onDecisionPoint) return\n\n  try {\n    const result = onDecisionPoint(point, context)\n    if (isThenable(result)) {\n      void result.catch((error) => {\n        notifyRuntimeHookError(hooks, toError(error), {\n          hook: 'onDecisionPoint',\n          decisionId: point.id,\n          decisionKind: point.kind,\n        })\n      })\n    }\n  } catch (error) {\n    notifyRuntimeHookError(hooks, toError(error), {\n      hook: 'onDecisionPoint',\n      decisionId: point.id,\n      decisionKind: point.kind,\n    })\n  }\n}\n\nfunction notifyRuntimeHookError(\n  hooks: RuntimeHooks | undefined,\n  error: Error,\n  context: RuntimeHookErrorContext,\n): void {\n  try {\n    const result = hooks?.onHookError?.(error, context)\n    if (isThenable(result)) void result.catch(() => undefined)\n  } catch {\n    // Hook errors must never become agent-loop errors.\n  }\n}\n\nfunction isThenable(value: unknown): value is PromiseLike<unknown> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'then' in value &&\n    typeof (value as { then?: unknown }).then === 'function'\n  )\n}\n\nfunction toError(error: unknown): Error {\n  return error instanceof Error ? error : new Error(String(error))\n}\n","/**\n * @experimental\n *\n * `acquireSandbox` — cold-start-resilient sandbox acquisition. Eliminates the\n * \"create timed out at the proxy\" failure mode conceptually by DECOUPLING \"the\n * create HTTP call returned\" from \"the sandbox is ready\":\n *\n *   - Create is initiated with a known `name`.\n *   - Readiness is observed from the sandbox's own `status` (`refresh()` polls\n *     true state), NOT from whether the create call returned in time.\n *   - If the create call itself times out at a gateway (502/503/504/522/524 or\n *     a transport timeout), provisioning is still running server-side — so we\n *     find the named sandbox via `list()` and wait for it to reach `running`.\n *\n * Result: a scale-from-zero cold start (node boot + host-agent registration,\n * minutes) can no longer surface as a create failure behind a ~100s proxy\n * limit. The loop becomes indifferent to whether the host pool is warm or cold.\n *\n * Invariant: an instance reporting no `status` (the minimal test fakes) is\n * treated as ready; only an explicit `pending`/`provisioning` status triggers\n * waiting, and only a retryable THROW triggers the find-by-name path. Real\n * errors (auth, validation, budget) fail loud. A box that is created (or found)\n * but never reaches `running` (abort, terminal status, budget) is torn down\n * before the failure propagates, so an abort storm during cold start does not\n * leak live sandboxes.\n */\n\nimport type { CreateSandboxOptions, SandboxInstance } from '@tangle-network/sandbox'\nimport { ValidationError } from '../errors'\nimport type { SandboxClient } from './types'\nimport { sleep as abortableSleep, deleteBoxSafe, randomUuid, throwIfAborted } from './util'\n\n/**\n * HTTP statuses where create should be retried — gateway timeouts\n * (502/503/504/522/524) where provisioning may continue server-side, plus\n * request-level retryables (408/425/429).\n */\nconst RETRYABLE_HTTP = new Set([502, 503, 504, 522, 524, 408, 425, 429])\nconst TERMINAL_STATUS = new Set(['failed', 'expired', 'stopped'])\n\n/** @experimental */\nexport interface AcquireOptions {\n  /**\n   * Total budget for the sandbox to reach `running`, covering on-demand node\n   * cold-start. Default 600_000ms — matches the orchestrator's pending-host\n   * registration window so we never give up before the platform itself would.\n   */\n  readyTimeoutMs?: number\n  /** Poll interval while waiting for `running` / for the named sandbox to appear. */\n  pollIntervalMs?: number\n  /** Cancellation (user abort). Distinct from create-call timeouts. */\n  signal?: AbortSignal\n  /** Stamp a name so a timed-out create is recoverable by lookup. Auto-generated if absent. */\n  name?: string\n  /** Clock override for deterministic tests. */\n  now?: () => number\n  /** Sleep override for deterministic tests. */\n  sleep?: (ms: number) => Promise<void>\n}\n\n/** Minimal client surface acquire needs beyond `create` (the real SDK satisfies it). */\ninterface PollableClient extends SandboxClient {\n  list?: (options?: unknown) => Promise<SandboxInstance[]>\n  get?: (id: string) => Promise<SandboxInstance | null>\n}\n\n/** @experimental */\nexport async function acquireSandbox(\n  client: SandboxClient,\n  options: CreateSandboxOptions,\n  acquire: AcquireOptions = {},\n): Promise<SandboxInstance> {\n  if (!client || typeof client.create !== 'function') {\n    throw new ValidationError('acquireSandbox: client.create is required')\n  }\n  const now = acquire.now ?? Date.now\n  const sleep = acquire.sleep ?? ((ms: number) => abortableSleep(ms, acquire.signal))\n  const pollMs = acquire.pollIntervalMs ?? 3000\n  const deadline = now() + (acquire.readyTimeoutMs ?? 600_000)\n  // After a retryable create error (commonly a gateway/request timeout on a cold\n  // scale-from-zero), the orchestrator has usually ACCEPTED the request and is\n  // still provisioning the NAMED box — which appears in list() a few seconds\n  // AFTER the create call gave up. Scan list() this many windows for it to\n  // appear before re-POSTing: re-creating immediately restarts a fresh cold\n  // provision and hits the same wall — that thrash is why a cold acquire never\n  // converges within the budget; attaching to the in-flight box does.\n  const appearScans = 5\n  // crypto.randomUUID is collision-resistant — find-by-name recovery scans\n  // list() for this exact name, so two concurrent acquires must never collide.\n  const name = options.name ?? acquire.name ?? `loop-sbx-${randomUuid()}`\n  const createOpts: CreateSandboxOptions = { ...options, name }\n  const c = client as PollableClient\n\n  let lastErr: unknown\n  let attempt = 0\n  while (now() < deadline) {\n    throwIfAborted(acquire.signal)\n    try {\n      const box = await client.create(createOpts)\n      // Tear the just-created box down if it never reaches `running` (abort,\n      // terminal status, budget) so a failed wait never leaks a live sandbox.\n      return await waitReadyOrDestroy(box, deadline, pollMs, acquire.signal, now, sleep)\n    } catch (err) {\n      throwIfAborted(acquire.signal)\n      // Non-retryable (auth/validation/budget) fails loud immediately.\n      if (!isRetryable(err)) throw err\n      lastErr = err\n      // Recovery for a gateway-timed-out create, in order:\n      //  (a) the orchestrator usually ACCEPTED the create and is provisioning\n      //      the named box — it appears in list() a few seconds later, so poll\n      //      for it across `appearScans` windows and attach (this is the cold-\n      //      start fix: a single scan misses a row not yet written and the loop\n      //      would otherwise re-POST a fresh cold provision every backoff);\n      //  (b) only if it never appears did the create truly roll back — retry\n      //      create with backoff (lands once a warm host exists / autoscaler\n      //      caught up).\n      if (typeof c.list === 'function') {\n        for (let scan = 0; scan < appearScans && now() < deadline; scan += 1) {\n          const found = (await c.list().catch(() => []))?.find((b) => b.name === name)\n          if (found)\n            return await waitReadyOrDestroy(found, deadline, pollMs, acquire.signal, now, sleep)\n          if (scan < appearScans - 1) await sleep(pollMs)\n        }\n      }\n      attempt += 1\n      await sleep(Math.min(pollMs * attempt, 15_000))\n    }\n  }\n  throw new ValidationError(\n    `acquireSandbox: could not acquire a running sandbox \"${name}\" within budget`,\n    { cause: lastErr instanceof Error ? lastErr : undefined },\n  )\n}\n\n/** `waitUntilReady`, tearing the box down (best-effort) on any throw so a box\n *  that never reaches `running` (abort, terminal status, budget) does not leak. */\nasync function waitReadyOrDestroy(\n  box: SandboxInstance,\n  deadline: number,\n  pollMs: number,\n  signal: AbortSignal | undefined,\n  now: () => number,\n  sleep: (ms: number) => Promise<void>,\n): Promise<SandboxInstance> {\n  try {\n    return await waitUntilReady(box, deadline, pollMs, signal, now, sleep)\n  } catch (err) {\n    await deleteBoxSafe(box)\n    throw err\n  }\n}\n\n/** Wait for `running`. No status (minimal fakes) = ready. Terminal status throws. */\nasync function waitUntilReady(\n  box: SandboxInstance,\n  deadline: number,\n  pollMs: number,\n  signal: AbortSignal | undefined,\n  now: () => number,\n  sleep: (ms: number) => Promise<void>,\n): Promise<SandboxInstance> {\n  for (;;) {\n    throwIfAborted(signal)\n    const status = readStatus(box)\n    if (status === undefined || status === 'running') return box\n    if (TERMINAL_STATUS.has(status)) {\n      throw new ValidationError(\n        `acquireSandbox: sandbox ${box.id ?? '(unknown)'} is ${status}${box.error ? `: ${box.error}` : ''}`,\n      )\n    }\n    if (now() >= deadline) {\n      throw new ValidationError(\n        `acquireSandbox: sandbox ${box.id ?? '(unknown)'} not running within budget (last status: ${status})`,\n      )\n    }\n    await sleep(pollMs)\n    if (typeof box.refresh === 'function') await box.refresh()\n  }\n}\n\nfunction readStatus(box: SandboxInstance): string | undefined {\n  const s = (box as { status?: unknown }).status\n  return typeof s === 'string' ? s : undefined\n}\n\nfunction isRetryable(err: unknown): boolean {\n  if (!err || typeof err !== 'object') return false\n  const e = err as { status?: number; statusCode?: number; name?: string; message?: string }\n  const status = e.status ?? e.statusCode\n  if (typeof status === 'number' && RETRYABLE_HTTP.has(status)) return true\n  const name = e.name ?? ''\n  if (name === 'TimeoutError' || name === 'ServerError' || name === 'NetworkError') return true\n  const msg = e.message ?? ''\n  // Transient TRANSPORT failures.\n  if (\n    /\\b(timed out|timeout|gateway|temporarily unavailable|too many requests|ECONNRESET|ETIMEDOUT|EAI_AGAIN)\\b/i.test(\n      msg,\n    )\n  ) {\n    return true\n  }\n  // Transient PLATFORM provisioning failures thrown by `create` itself — edge data\n  // plane unreachable, container-phase provision failure, or a rolled-back create.\n  // Retry create onto a FRESH host rather than failing the whole rollout; the loop\n  // stays bounded by the ready deadline. A box that booted and then reached a\n  // terminal `failed` status with a real error is NOT retried here — that's a genuine\n  // fault surfaced by `waitUntilReady`, not a host blip.\n  return /provision failed|edge data plane|not reachable|failed to create sandbox/i.test(msg)\n}\n","/**\n * @experimental\n *\n * Backend-options assembly shared by the loop kernel's `createSandboxForSpec`\n * and the sandbox planner's box creation, so the worker box and the planner box\n * boot identically. Builds the options only — the acquire path (cold-start\n * recovery) lives in the kernel, the planner calls `client.create` directly.\n */\n\nimport type { AgentProfile, CreateSandboxOptions } from '@tangle-network/sandbox'\n\ntype BackendType = NonNullable<CreateSandboxOptions['backend']>['type']\ntype BackendOverride = NonNullable<CreateSandboxOptions['backend']>\n\n/**\n * Resolve the backend `type`: an explicit override wins, then the profile's\n * `metadata.backendType` hint, else the SDK's profile-driven default\n * (`'opencode'` on the platform side). A profile with no hint falls through to\n * the default rather than asserting provenance the profile never declared.\n */\nfunction resolveBackendType(\n  profile: AgentProfile,\n  override: Partial<BackendOverride> | undefined,\n): BackendType {\n  if (override?.type) return override.type\n  const explicit = profile.metadata?.backendType\n  if (typeof explicit === 'string') return explicit as BackendType\n  return 'opencode' as BackendType\n}\n\n/**\n * Build `CreateSandboxOptions` for `profile`, merging `overrides` and setting\n * `backend.profile`. `model`/`server` from an override backend pass through.\n */\nexport function buildBackendOptions(\n  profile: AgentProfile,\n  overrides: Partial<CreateSandboxOptions> | undefined,\n): CreateSandboxOptions {\n  const base = overrides ?? {}\n  const overrideBackend = base.backend\n  return {\n    ...base,\n    backend: {\n      type: resolveBackendType(profile, overrideBackend),\n      profile,\n      ...(overrideBackend?.model ? { model: overrideBackend.model } : {}),\n      ...(overrideBackend?.server ? { server: overrideBackend.server } : {}),\n    },\n  }\n}\n","/**\n * @experimental\n *\n * Capability probe for the loop kernel's backend-blind lineage seams. The\n * kernel must NEVER ask \"is this Docker or Firecracker?\"; it asks \"can this\n * platform fork a checkpoint?\" via `client.criuStatus()` and degrades to fresh\n * boxes when the answer is no. CRIU availability is a per-platform fact, so the\n * probe is memoized per client — one network round-trip, reused across every\n * fanout in the run.\n *\n * Invariant: a client with no `criuStatus` method (the loop's test fakes, the\n * raw SDK before it grew the probe) reports `canFork = false`. The seam is\n * fail-CLOSED — never assume forking works, only enable it on a positive probe.\n */\n\nimport type { SandboxClient } from './types'\n\n/**\n * What the loop kernel is allowed to know about a sandbox backend: a single\n * capability bit, never the backend's identity. `canFork` gates the\n * checkpoint+fork fanout path; everything else (session continuation) is a\n * universal SDK feature that needs no probe.\n *\n * @experimental\n */\nexport interface SandboxCapabilities {\n  /**\n   * True only when `client.criuStatus()` returned `{ available: true }`. When\n   * false, a fork-enabled fanout degrades to independent fresh boxes — same\n   * result, no shared context prefix.\n   */\n  canFork: boolean\n}\n\nconst probeCache = new WeakMap<object, Promise<SandboxCapabilities>>()\n\n/**\n * Probe (and memoize per client) what the loop may rely on. A client without a\n * `criuStatus` method, or whose probe rejects, yields `canFork = false` — a\n * failed probe must never claim a capability the platform may not have. The\n * promise is cached so concurrent fanout branches share one round-trip.\n *\n * @experimental\n */\nexport function probeSandboxCapabilities(client: SandboxClient): Promise<SandboxCapabilities> {\n  const key = client as unknown as object\n  const cached = probeCache.get(key)\n  if (cached) return cached\n  const probe = resolveCapabilities(client)\n  probeCache.set(key, probe)\n  return probe\n}\n\nasync function resolveCapabilities(client: SandboxClient): Promise<SandboxCapabilities> {\n  const criuStatus = (client as CriuCapableClient).criuStatus\n  if (typeof criuStatus !== 'function') return { canFork: false }\n  try {\n    const status = await criuStatus.call(client)\n    return { canFork: status?.available === true }\n  } catch {\n    // A probe that throws (transport error, unsupported endpoint) is treated as\n    // \"no fork\" — fail closed so a flaky probe degrades to fresh boxes rather\n    // than attempting a checkpoint the platform can't honor.\n    return { canFork: false }\n  }\n}\n\n/**\n * Narrowed view of the optional CRIU probe. The loop-side `SandboxClient`\n * does not require `criuStatus`; this widens it optionally so the probe can be\n * read without importing sandbox-backend specifics. @experimental\n */\nexport interface CriuCapableClient {\n  criuStatus?: () => Promise<{ available: boolean; criuVersion?: string; reason?: string }>\n}\n","/**\n * @experimental\n *\n * `SandboxLineage` — the backend-blind owner of box + session handles for a\n * single `runLoop` invocation. It exists so `run-loop.ts` never references a\n * backend (Docker / Firecracker): the lineage turns \"continue this session\" and\n * \"fork this branch\" into capability-gated sandbox-SDK calls and degrades to\n * fresh boxes when a capability is absent.\n *\n * Three operations, mirroring the kernel's per-iteration choices:\n *   - `start(spec, prompt)`  → a fresh box; the FIRST `streamPrompt` carries a\n *      minted `sessionId` so later `continue` calls reuse the same server-side\n *      conversation instead of re-injecting prior context as prompt text.\n *   - `continue(handle, prompt)` → the SAME box, `streamPrompt({ sessionId })`.\n *      The context lives in the sandbox; the prompt is only the new turn. Before\n *      streaming it ASSERTS the session is still live server-side (via\n *      `box.session(id).status()`): if the platform never honored the\n *      client-minted id (or reaped it), `status()` is `null` and `continue`\n *      fails loud rather than silently re-running the turn without prior context.\n *   - `fork(handle, n, ...)` → when `canFork`, `checkpoint({ leaveRunning })` on\n *      the parent then `fork(checkpointId)` × n so N branches inherit a shared\n *      context prefix; otherwise N independent fresh boxes (same result, no\n *      prefix). Either way each branch streams its own turn. Child-box creation\n *      is bounded by the lineage's `maxConcurrency` — a 20-way fanout under a\n *      concurrency cap of 2 provisions boxes in bounded waves, not all at once.\n *\n * Invariant: the lineage OWNS every box it starts or forks and tears them all\n * down on `teardown()` (or earlier via `prune`). It never tears down a box\n * mid-flight — the kernel decides when a handle is done. Streaming itself stays\n * in `run-loop.ts`; the lineage only hands back the live `streamPrompt` iterable\n * so the kernel keeps ownership of event collection, cost accounting, and trace\n * emission.\n */\n\nimport type { CreateSandboxOptions, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox'\nimport { ValidationError } from '../errors'\nimport { acquireSandbox } from './sandbox-acquire'\nimport { buildBackendOptions } from './sandbox-backend'\nimport type { SandboxCapabilities } from './sandbox-capabilities'\nimport type { AgentRunSpec, SandboxClient } from './types'\nimport {\n  deleteBoxSafe,\n  mapWithConcurrency,\n  randomUuid,\n  throwAbort,\n  throwIfAborted,\n  withTimeout,\n} from './util'\n\nconst TEARDOWN_TIMEOUT_MS = 15_000\nconst DEFAULT_FORK_CONCURRENCY = 4\n\n/**\n * One turn's event stream, in the lineage's chosen streaming mode.\n *\n * - `'sse'` (default): live `streamPrompt` — low latency, full per-token trace.\n *   Best for interactive chat.\n * - `'poll'`: fire-and-detach via `dispatchPrompt`, await the terminal result by\n *   status-polling (NOT a held SSE), then yield the answer as one synthesized\n *   event. A long, quiet in-box turn (clone + build + test) never holds a live\n *   stream a proxy idle-timeout can drop mid-execution — the failure mode that\n *   made batch eval runs lose their stream on both prod and staging. Lower trace\n *   fidelity (one terminal event, not per-token), so it is opt-in for batch.\n *\n * Both yield the same `SandboxEvent` vocabulary, so callers are agnostic.\n */\nasync function* pollPromptEvents(\n  box: SandboxInstance,\n  prompt: string,\n  sessionId: string,\n  signal: AbortSignal,\n): AsyncIterable<SandboxEvent> {\n  if (signal.aborted) throwAbort()\n  // dispatchPrompt returns the session id the platform actually assigned, which\n  // may be one it MINTED rather than the supplied `sessionId`. Polling the\n  // supplied id when the platform minted a different one 404s the session-events\n  // endpoint (\"Resource not found\"). Always follow the assigned id.\n  const dispatched = await box.dispatchPrompt(prompt, { sessionId, signal })\n  const activeSessionId = dispatched.sessionId\n  const result = await box.session(activeSessionId).result()\n  if (signal.aborted) throwAbort()\n  yield {\n    type: 'result',\n    id: activeSessionId,\n    data: {\n      finalText: result.response ?? '',\n      success: result.success,\n      ...(result.error ? { error: result.error } : {}),\n      ...(result.usage ? { usage: result.usage } : {}),\n    },\n  }\n}\n\nexport function promptEvents(\n  streaming: 'sse' | 'poll',\n  box: SandboxInstance,\n  prompt: string,\n  sessionId: string,\n  signal: AbortSignal,\n): AsyncIterable<SandboxEvent> {\n  return streaming === 'poll'\n    ? pollPromptEvents(box, prompt, sessionId, signal)\n    : box.streamPrompt(prompt, { sessionId, signal })\n}\n\n/**\n * A live box plus the session that threads its iterations together. Handed back\n * by `start`/`fork`, passed into `continue`/`fork` to descend from. Opaque to\n * the kernel beyond `box` (for placement/teardown) and `sessionId` (trace).\n *\n * @experimental\n */\nexport interface SandboxLineageHandle {\n  /** The owned, running sandbox this handle drives. */\n  box: SandboxInstance\n  /**\n   * Stable session id threaded through this box's `streamPrompt` calls. Minted\n   * by the lineage on `start`; reused on `continue` so the server continues the\n   * same conversation. A forked handle starts a fresh session on its new box —\n   * the shared context comes from the checkpoint, not a shared session id.\n   */\n  sessionId: string\n}\n\n/**\n * Owns box + session handles for one loop run and offers the three\n * capability-gated lifecycle moves. Construct via `createSandboxLineage`.\n *\n * @experimental\n */\nexport interface SandboxLineage {\n  /**\n   * Acquire a fresh box and begin a new session on it. Returns the handle and\n   * the live `streamPrompt` iterable for the first turn (caller drains it).\n   */\n  start(\n    spec: AgentRunSpec<unknown>,\n    prompt: string,\n    signal: AbortSignal,\n  ): Promise<{ handle: SandboxLineageHandle; events: AsyncIterable<SandboxEvent> }>\n  /**\n   * Continue an existing handle's session with one more turn on the SAME box.\n   * The prior context is server-side; `prompt` is only the new turn. Asserts the\n   * session is still known to the sandbox first (fail-loud) so a platform that\n   * silently dropped the client-minted session id surfaces as an error instead\n   * of a contextless turn the caller mistakes for a real continuation.\n   */\n  continue(\n    handle: SandboxLineageHandle,\n    prompt: string,\n    signal: AbortSignal,\n  ): Promise<AsyncIterable<SandboxEvent>>\n  /**\n   * Branch `count` children from `parent`. When the platform can fork, each\n   * child inherits `parent`'s checkpoint — and therefore the parent's IMAGE and\n   * PROFILE: under a real fork `specs[i]` does NOT re-select a per-branch\n   * profile (the SDK forks the running box, it can't swap the image). `specs[i]`\n   * picks the per-branch profile ONLY on the degraded fresh-box path (no CRIU).\n   * A heterogeneous-profile fanout therefore homogenizes to the parent's profile\n   * when fork is available — pass a single shared spec for forked fanouts, or\n   * use `random@k` (no fork) when branches must differ. Each child's first turn\n   * streams `prompts[i]`. Child-box creation is bounded by `maxConcurrency`.\n   */\n  fork(\n    parent: SandboxLineageHandle,\n    prompts: string[],\n    specs: AgentRunSpec<unknown>[],\n    signal: AbortSignal,\n  ): Promise<{ handle: SandboxLineageHandle; events: AsyncIterable<SandboxEvent> }[]>\n  /**\n   * Destroy every owned box whose handle is NOT in `keep`, freeing it before\n   * loop end. The kernel calls this after a round when it can prove no future\n   * round will descend from the pruned boxes (deterministic, monotonic branch\n   * selection); boxes still reachable as a future branch source are retained.\n   * Best-effort, bounded, parallel — a failed delete never throws.\n   */\n  prune(keep: Iterable<SandboxLineageHandle>): Promise<void>\n  /** Destroy every box this lineage owns. Best-effort, bounded, parallel. */\n  teardown(): Promise<void>\n}\n\n/**\n * Build a lineage bound to one client + its probed capabilities. The\n * capabilities are passed in (not re-probed) so the kernel probes once per run\n * and the lineage stays a pure function of \"what this platform can do\".\n *\n * @experimental\n */\nexport function createSandboxLineage(\n  client: SandboxClient,\n  capabilities: SandboxCapabilities,\n  options: { maxConcurrency?: number; streaming?: 'sse' | 'poll' } = {},\n): SandboxLineage {\n  if (!client || typeof client.create !== 'function') {\n    throw new ValidationError('createSandboxLineage: client.create is required')\n  }\n  // 'sse' (default) preserves the byte-identical live-stream behavior; 'poll' is\n  // the drop-resilient fire-and-detach path for long, quiet batch turns.\n  const streaming = options.streaming ?? 'sse'\n  // Bounds the burst of box creation inside `fork` so an N-way fanout doesn't\n  // provision N boxes simultaneously regardless of the loop's concurrency cap.\n  const forkConcurrency = Math.max(\n    1,\n    Math.floor(options.maxConcurrency ?? DEFAULT_FORK_CONCURRENCY),\n  )\n  const owned: SandboxInstance[] = []\n\n  const acquireFresh = async (\n    spec: AgentRunSpec<unknown>,\n    signal: AbortSignal,\n  ): Promise<SandboxInstance> => {\n    if (signal.aborted) throwAbort()\n    const opts: CreateSandboxOptions = buildBackendOptions(spec.profile, spec.sandboxOverrides)\n    const box = await acquireSandbox(client, opts, { signal })\n    await spec.prepareBox?.(box, { signal })\n    owned.push(box)\n    return box\n  }\n\n  return {\n    async start(spec, prompt, signal) {\n      const box = await acquireFresh(spec, signal)\n      const sessionId = mintSessionId()\n      const events = promptEvents(streaming, box, prompt, sessionId, signal)\n      return { handle: { box, sessionId }, events }\n    },\n\n    async continue(handle, prompt, signal) {\n      if (signal.aborted) throwAbort()\n      // Fail loud if the platform did not preserve the client-minted session:\n      // continuing a dead/unknown session would silently lose all prior context.\n      await assertSessionLive(handle.box, handle.sessionId)\n      // Same box, same session id — the server continues the conversation; we do\n      // NOT re-acquire and do NOT re-inject prior context as prompt text.\n      return promptEvents(streaming, handle.box, prompt, handle.sessionId, signal)\n    },\n\n    async fork(parent, prompts, specs, signal) {\n      if (prompts.length === 0) {\n        throw new ValidationError('SandboxLineage.fork: prompts must be non-empty')\n      }\n      if (signal.aborted) throwAbort()\n      const checkpointId = capabilities.canFork\n        ? await checkpointForFork(parent.box, signal)\n        : undefined\n      // checkpointId === undefined ⇒ either the platform can't fork or the\n      // checkpoint call yielded nothing usable: degrade to independent fresh\n      // boxes. Never silently reuse the parent box for a branch.\n      //\n      // Bounded by `forkConcurrency`: an N-way fanout creates child boxes in\n      // waves of at most `forkConcurrency`, not all N at once. Abort is checked\n      // per branch (between waves), since the SDK's `fork`/`create` calls take no\n      // signal and cannot be interrupted once in flight.\n      return mapWithConcurrency(prompts, forkConcurrency, async (prompt, i) => {\n        throwIfAborted(signal)\n        const spec = specs[i % specs.length]\n        if (!spec) throw new ValidationError('SandboxLineage.fork: no AgentRunSpec for branch')\n        if (checkpointId !== undefined) {\n          const box = await forkFromCheckpoint(parent.box, checkpointId, signal)\n          owned.push(box)\n          await spec.prepareBox?.(box, { signal })\n          const sessionId = mintSessionId()\n          return {\n            handle: { box, sessionId },\n            events: promptEvents(streaming, box, prompt, sessionId, signal),\n          }\n        }\n        const box = await acquireFresh(spec, signal)\n        const sessionId = mintSessionId()\n        return {\n          handle: { box, sessionId },\n          events: promptEvents(streaming, box, prompt, sessionId, signal),\n        }\n      })\n    },\n\n    async prune(keep) {\n      const keepBoxes = new Set<SandboxInstance>()\n      for (const handle of keep) keepBoxes.add(handle.box)\n      const survivors: SandboxInstance[] = []\n      const doomed: SandboxInstance[] = []\n      for (const box of owned) (keepBoxes.has(box) ? survivors : doomed).push(box)\n      if (doomed.length === 0) return\n      owned.length = 0\n      owned.push(...survivors)\n      await Promise.allSettled(doomed.map((box) => destroyBounded(box)))\n    },\n\n    async teardown() {\n      const boxes = owned.splice(0, owned.length)\n      await Promise.allSettled(boxes.map((box) => destroyBounded(box)))\n    },\n  }\n}\n\n/** Stable, collision-resistant session id minted per box (the caller owns the id). */\nfunction mintSessionId(): string {\n  return `loop-sess-${randomUuid()}`\n}\n\n/**\n * Checkpoint the parent leaving it running, returning the checkpoint id to fork\n * from, or `undefined` when the box exposes no `checkpoint` (the loop's fakes)\n * or the call produced no id. `undefined` makes the caller degrade to fresh\n * boxes — a fork that can't checkpoint must not pretend to share context.\n */\nasync function checkpointForFork(\n  box: SandboxInstance,\n  signal: AbortSignal,\n): Promise<string | undefined> {\n  const checkpoint = (box as CheckpointCapableBox).checkpoint\n  if (typeof checkpoint !== 'function') return undefined\n  if (signal.aborted) throwAbort()\n  const result = await checkpoint.call(box, { leaveRunning: true })\n  const id = result?.checkpointId\n  return typeof id === 'string' && id.length > 0 ? id : undefined\n}\n\n/**\n * Fork a child box from `checkpointId`. The box exposes `fork` whenever the\n * platform advertised `canFork`; a missing `fork` here is a contract violation\n * (probe said yes, box says no) and fails loud rather than silently degrading.\n *\n * `signal` gates entry only: the SDK's `fork(checkpointId, options)` takes no\n * abort signal (`ForkOptions` is name/env/resources/metadata), so an in-flight\n * fork cannot be interrupted. The caller (`fork`) checks abort per branch, so\n * cancellation is responsive at branch boundaries, not mid-fork.\n */\nasync function forkFromCheckpoint(\n  box: SandboxInstance,\n  checkpointId: string,\n  signal: AbortSignal,\n): Promise<SandboxInstance> {\n  const fork = (box as ForkCapableBox).fork\n  if (typeof fork !== 'function') {\n    throw new ValidationError(\n      'SandboxLineage.fork: capabilities report canFork but the box has no fork() method',\n    )\n  }\n  if (signal.aborted) throwAbort()\n  return fork.call(box, checkpointId)\n}\n\n/**\n * Fail loud when a handle's session is no longer known to the sandbox. The real\n * SDK box exposes `session(id).status()` which resolves `null` for an unknown /\n * reaped id; a `null` here means a `continue` would run WITHOUT the prior\n * context the caller believes is threaded — so refuse it. Boxes that expose no\n * `session` method (the loop's test fakes, or an SDK without the session API)\n * cannot be verified and are allowed through unchecked.\n */\nasync function assertSessionLive(box: SandboxInstance, sessionId: string): Promise<void> {\n  const session = (box as SessionCapableBox).session\n  if (typeof session !== 'function') return\n  const info = await session.call(box, sessionId).status()\n  if (info === null) {\n    throw new ValidationError(\n      `SandboxLineage.continue: session ${sessionId} is not known to the sandbox — the platform ` +\n        'did not preserve the client-minted session id (or it was reaped). Continuing would run ' +\n        'without prior context; refusing to silently lose conversation continuity.',\n    )\n  }\n}\n\nasync function destroyBounded(box: SandboxInstance): Promise<void> {\n  await withTimeout(deleteBoxSafe(box), TEARDOWN_TIMEOUT_MS)\n}\n\n/**\n * Loop-side widening of the box's optional checkpoint method. The\n * `SandboxClient`/`SandboxInstance` surface the kernel relies on does not\n * require checkpointing; this reads it optionally so the lineage can probe-gate\n * without importing sandbox-backend specifics. @experimental\n */\nexport interface CheckpointCapableBox {\n  checkpoint?: (options?: { leaveRunning?: boolean; tags?: string[] }) => Promise<{\n    checkpointId: string\n  }>\n}\n\n/** Loop-side widening of the box's optional fork method. @experimental */\nexport interface ForkCapableBox {\n  fork?: (checkpointId: string, options?: { name?: string }) => Promise<SandboxInstance>\n}\n\n/**\n * Loop-side widening of the box's optional session accessor. The real\n * `SandboxInstance` exposes `session(id).status()`; the loop reads it optionally\n * so `continue` can assert session liveness without requiring it of the test\n * fakes. `status()` resolves `null` when the id is unknown to the sandbox.\n * @experimental\n */\nexport interface SessionCapableBox {\n  session?: (id: string) => { status: () => Promise<unknown | null> }\n}\n","/**\n * @experimental\n *\n * `runLoop` — the topology-agnostic kernel built atop the sandbox SDK.\n *\n * Each iteration:\n *   1. `driver.plan(task, history)` → N tasks (1 = refine, N = fanout, 0 = stop)\n *   2. For each task (parallel, bounded by `maxConcurrency`):\n *        a. round-robin an `AgentRunSpec` from `agentRuns`\n *        b. `sandboxClient.create({ backend: { profile }, ...overrides })`\n *        c. emit `loop.iteration.dispatch` with the placement\n *           (`{ sibling, sandboxId }` or `{ fleet, fleetId, machineId, sandboxId }`)\n *        d. iterate `box.streamPrompt(taskToPrompt(task))` and collect events\n *   3. `output.parse(events)` → typed `Output`\n *   4. `validator?.validate(output)` → `DefaultVerdict`\n *   5. Append `Iteration` to history; emit `loop.iteration.ended`\n *   6. `driver.decide(history)` → if terminal, return result + winner\n *\n * The kernel owns: iteration accounting, per-iteration timing, error\n * capture, abort propagation, concurrency cap, cost aggregation, and trace\n * emission. The kernel does NOT own: what the agent runs (sandbox SDK +\n * profile), how outputs are decoded (output adapter), how outputs are\n * scored (validator), or topology (driver).\n */\n\nimport type { SandboxEvent, SandboxInstance } from '@tangle-network/sandbox'\nimport { ValidationError } from '../errors'\nimport { notifyRuntimeHookEvent } from '../runtime-hooks'\nimport { acquireSandbox } from './sandbox-acquire'\nimport { buildBackendOptions } from './sandbox-backend'\nimport { probeSandboxCapabilities } from './sandbox-capabilities'\nimport { extractLlmCallEvent } from './sandbox-events'\nimport {\n  createSandboxLineage,\n  promptEvents,\n  type SandboxLineage,\n  type SandboxLineageHandle,\n} from './sandbox-lineage'\nimport type {\n  AgentRunSpec,\n  Driver,\n  ExecCtx,\n  Iteration,\n  LoopLineageOptions,\n  LoopResult,\n  LoopSandboxPlacement,\n  LoopTokenUsage,\n  LoopTraceEmitter,\n  LoopTraceEvent,\n  LoopWinner,\n  OutputAdapter,\n  SandboxClient,\n  Validator,\n} from './types'\nimport {\n  addTokenUsage,\n  deleteBoxSafe,\n  randomSuffix,\n  stringifySafe,\n  throwAbort,\n  withTimeout,\n  zeroTokenUsage,\n} from './util'\n\nconst DEFAULT_MAX_ITERATIONS = 10\nconst DEFAULT_MAX_CONCURRENCY = 4\n\n/** @experimental */\nexport interface RunLoopOptions<Task, Output, Decision> {\n  driver: Driver<Task, Output, Decision>\n  /**\n   * Single agent spec — every iteration uses this profile. Mutually\n   * exclusive with `agentRuns`.\n   */\n  agentRun?: AgentRunSpec<Task>\n  /**\n   * Multiple specs for heterogeneous fanout. The kernel round-robins\n   * through them when the driver plans N tasks. Mutually exclusive with\n   * `agentRun`.\n   */\n  agentRuns?: AgentRunSpec<Task>[]\n  output: OutputAdapter<Output>\n  validator?: Validator<Output>\n  task: Task\n  ctx: ExecCtx\n  /** Default 10. Hard cap on total iterations across all `plan()` rounds. */\n  maxIterations?: number\n  /** Default 4. In-flight worker cap within a single `plan()` batch. */\n  maxConcurrency?: number\n  /**\n   * Pre-allocated id for trace correlation. Default = `loop-${random}`.\n   * Surfaces as `runId` on every emitted `LoopTraceEvent`.\n   */\n  runId?: string\n  /**\n   * Clock override; default `Date.now`. Deterministic tests pass a\n   * monotonic counter to stabilize iteration timing fields.\n   */\n  now?: () => number\n  /**\n   * Override the default winner selector (highest-valid-score, ties broken\n   * by earliest iteration).\n   */\n  selectWinner?: (iterations: Iteration<Task, Output>[]) => LoopWinner<Task, Output> | undefined\n  /**\n   * Same-sandbox driver mode — a kernel→caller out-channel, not a value handed\n   * in. When set, the kernel keeps each finished worker box alive across the\n   * `plan()` boundary and hands it here, so a same-sandbox planner\n   * (one that reuses the worker's box) can stream its move INTO the\n   * worker's live box — steering from the worker's real filesystem and state,\n   * not just a history summary. The kernel owns teardown: every box kept alive\n   * this way is destroyed at loop end (and the callback is invoked with\n   * `undefined` then as a teardown sentinel). Without it, worker boxes are torn\n   * down per-iteration (default) and a same-sandbox planner has nothing to\n   * reuse. Intended for single-worker (refine) loops: under fanout every box is\n   * still kept for teardown, but only the last-finishing box is handed here, so\n   * a planner sees an arbitrary branch's filesystem — pair it with refine.\n   */\n  onWorkerBox?: (box: SandboxInstance | undefined) => void\n  /**\n   * Opt-in box-lineage controls. Default OFF — unset means every iteration\n   * acquires a fresh box, streams once, and tears it down (today's behavior,\n   * byte-identical). With `sessionContinuity` on, a refine round continues the\n   * parent iteration's session on its live box; with `forkFanout` on (and a\n   * fork-capable platform), a fanout round forks the parent's checkpoint so the\n   * branches share a context prefix. The lineage owns every box it starts or\n   * forks and tears them all down at loop end — so these paths are mutually\n   * exclusive with `onWorkerBox`, which claims the same box-ownership channel.\n   * @experimental\n   */\n  lineage?: LoopLineageOptions\n}\n\n/** @experimental */\nexport async function runLoop<Task, Output, Decision>(\n  options: RunLoopOptions<Task, Output, Decision>,\n): Promise<LoopResult<Task, Output, Decision>> {\n  const specs = resolveAgentRuns(options)\n  const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS\n  if (!Number.isFinite(maxIterations) || maxIterations <= 0) {\n    throw new ValidationError('runLoop: maxIterations must be > 0')\n  }\n  const maxConcurrency = options.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY\n  if (!Number.isFinite(maxConcurrency) || maxConcurrency <= 0) {\n    throw new ValidationError('runLoop: maxConcurrency must be > 0')\n  }\n  // Default fresh-box path streaming mode (read regardless of lineage activation,\n  // which gates on sessionContinuity/forkFanout — the bench uses neither).\n  const sandboxStreaming = options.lineage?.streaming ?? 'sse'\n  if (!options.ctx?.sandboxClient || typeof options.ctx.sandboxClient.create !== 'function') {\n    throw new ValidationError('runLoop: ctx.sandboxClient.create is required')\n  }\n  const now = options.now ?? Date.now\n  const runId = options.runId ?? `loop-${randomSuffix()}`\n  const loopStart = now()\n  const driverName = options.driver.name ?? 'driver'\n  const iterations: Iteration<Task, Output>[] = []\n  let round = 0\n  // Same-sandbox mode: worker boxes are kept alive (not torn down per-iteration)\n  // so the planner can stream into the latest; the kernel destroys them at loop end.\n  const ownedBoxes: SandboxInstance[] = []\n  const collectBox = options.onWorkerBox\n    ? (box: SandboxInstance) => {\n        ownedBoxes.push(box)\n        options.onWorkerBox?.(box)\n      }\n    : undefined\n\n  // Opt-in box lineage: when either flag is set, a backend-blind lineage owns\n  // box+session handles so a refine continues the parent session and a fanout\n  // forks the parent checkpoint. Both flags off ⇒ lineage stays undefined and\n  // the per-iteration acquire/stream/teardown path is byte-identical to today.\n  const lineageState = await setUpLineage(options, maxConcurrency)\n\n  emitRunLoopHook(options, {\n    target: 'agent.run',\n    phase: 'before',\n    runId,\n    timestamp: now(),\n    payload: {\n      driver: driverName,\n      agentRunNames: specs.map((spec) => spec.name ?? spec.profile.name ?? 'agent'),\n      maxIterations,\n      maxConcurrency,\n    },\n  })\n\n  await emitTrace(options.ctx.traceEmitter, {\n    kind: 'loop.started',\n    runId,\n    timestamp: now(),\n    payload: {\n      driver: driverName,\n      agentRunNames: specs.map((spec) => spec.name ?? spec.profile.name ?? 'agent'),\n      maxIterations,\n      maxConcurrency,\n    },\n  })\n\n  const controller = new AbortController()\n  const onOuterAbort = () => controller.abort()\n  if (options.ctx.signal) {\n    if (options.ctx.signal.aborted) controller.abort()\n    else options.ctx.signal.addEventListener('abort', onOuterAbort, { once: true })\n  }\n\n  try {\n    while (iterations.length < maxIterations) {\n      if (controller.signal.aborted) throwAbort()\n      emitRunLoopHook(options, {\n        target: 'agent.plan',\n        phase: 'before',\n        runId,\n        timestamp: now(),\n        stepIndex: round,\n        payload: { roundIndex: round, historyLength: iterations.length },\n      })\n      const planned = await options.driver.plan(options.task, iterations)\n      // plan() may be a long LLM call (sandbox planner); an abort during it must\n      // not launch a fresh batch of workers on an already-cancelled loop.\n      if (controller.signal.aborted) throwAbort()\n      const planDesc = options.driver.describePlan?.()\n      const roundIndex = round\n      const baseIndex = iterations.length\n      const remaining = maxIterations - iterations.length\n      const slice = planned.slice(0, remaining)\n      // Edge lineage: a driver may DECLARE the branch source (planner-authored\n      // topology); otherwise the kernel infers it — round 0 branches from root\n      // (undefined), later rounds from the best-valid (else latest) iteration so\n      // far. Either way it's emitted, not guessed by the viewer.\n      const parentIndex =\n        planDesc?.parentIndex ?? (roundIndex === 0 ? undefined : branchPoint(iterations))\n      const childIndices = slice.map((_, i) => baseIndex + i)\n      const moveKind =\n        planDesc?.kind ??\n        (planned.length === 0 ? 'stop' : planned.length === 1 ? 'refine' : 'fanout')\n      emitRunLoopHook(options, {\n        target: 'agent.plan',\n        phase: 'after',\n        runId,\n        timestamp: now(),\n        stepIndex: roundIndex,\n        payload: {\n          roundIndex,\n          plannedCount: planned.length,\n          moveKind,\n          parentIndex,\n          childIndices,\n        },\n      })\n      await emitTrace(options.ctx.traceEmitter, {\n        kind: 'loop.plan',\n        runId,\n        timestamp: now(),\n        payload: {\n          roundIndex,\n          plannedCount: planned.length,\n          moveKind,\n          rationale: planDesc?.rationale,\n          parentIndex,\n          childIndices,\n        },\n      })\n      round += 1\n      if (planned.length === 0) break\n\n      // Reserve slots up front so concurrent workers may mutate by index.\n      for (let i = 0; i < slice.length; i += 1) {\n        const spec = specs[(baseIndex + i) % specs.length]!\n        iterations.push({\n          index: baseIndex + i,\n          task: slice[i] as Task,\n          agentRunName: spec.name ?? spec.profile.name ?? 'agent',\n          events: [],\n          startedAt: now(),\n          endedAt: 0,\n          costUsd: 0,\n          tokenUsage: zeroTokenUsage(),\n        })\n      }\n\n      // Decide how this round acquires its sandbox streams. Without lineage it's\n      // a fresh box per iteration (today's path). With lineage it may continue\n      // the parent session (refine) or fork the parent checkpoint (fanout).\n      const lineagePlan = lineageState\n        ? planLineageRound(lineageState, specs, slice, parentIndex, controller.signal)\n        : undefined\n\n      await runBatch({\n        slice,\n        baseIndex,\n        iterations,\n        specs,\n        output: options.output,\n        validator: options.validator,\n        maxConcurrency,\n        streaming: sandboxStreaming,\n        signal: controller.signal,\n        ctx: options.ctx,\n        runId,\n        now,\n        roundIndex,\n        parentIndex,\n        collectBox,\n        lineagePlan,\n        lineageState,\n      })\n\n      if (controller.signal.aborted) throwAbort()\n\n      emitRunLoopHook(options, {\n        target: 'agent.decision',\n        phase: 'before',\n        runId,\n        timestamp: now(),\n        stepIndex: roundIndex,\n        payload: { historyLength: iterations.length },\n      })\n      const decision = await options.driver.decide(iterations)\n      emitRunLoopHook(options, {\n        target: 'agent.decision',\n        phase: 'after',\n        runId,\n        timestamp: now(),\n        stepIndex: roundIndex,\n        payload: { decision: stringifySafe(decision), historyLength: iterations.length },\n      })\n      await emitTrace(options.ctx.traceEmitter, {\n        kind: 'loop.decision',\n        runId,\n        timestamp: now(),\n        payload: { decision: stringifySafe(decision), historyLength: iterations.length },\n      })\n      // Terminal decision ends the loop; a non-terminal one falls through to the\n      // next plan() round, so this must return rather than continue.\n      if (isTerminalDecision(decision)) {\n        return await finalizeAndEmitEnded(options, decision, iterations, loopStart, now, runId)\n      }\n      // The loop continues: free any lineage boxes no future round can descend\n      // from, so the live-box set tracks the active frontier instead of growing\n      // with every round. No-op unless pruning is provably safe (see canPrune).\n      if (lineageState) await pruneLineage(lineageState, iterations)\n    }\n\n    // Either the cap was reached without a terminal decision, or plan() returned\n    // [] first — both ask the driver for its final state and close out identically.\n    return await decideAndFinalize(options, iterations, loopStart, now, runId)\n  } finally {\n    if (options.ctx.signal) options.ctx.signal.removeEventListener('abort', onOuterAbort)\n    // Same-sandbox mode kept worker boxes alive across plan() so the planner could\n    // stream into them — the kernel owns their teardown. Destroy in parallel so a\n    // large fanout's deletes don't serialize, and bound each so a hung platform\n    // delete cannot wedge loop return after the caller aborted.\n    await Promise.allSettled(\n      ownedBoxes.map((b) => destroySandboxSafe(b, options.ctx.traceEmitter, runId, now)),\n    )\n    if (options.onWorkerBox) options.onWorkerBox(undefined)\n    // The lineage owns every box it started or forked across all rounds; it tears\n    // them down at loop end (kept alive between rounds so a later round can\n    // continue/fork them).\n    if (lineageState) await lineageState.lineage.teardown()\n  }\n}\n\n/**\n * Per-loop lineage state: the backend-blind lineage, the caller's opt-in flags,\n * and the live handle for each completed iteration so a later round can continue\n * or fork from it. `undefined` ⇒ no lineage; the kernel uses the fresh-box path.\n */\ninterface LineageState {\n  lineage: SandboxLineage\n  options: LoopLineageOptions\n  /** iteration index → its live box+session handle (kept alive across rounds). */\n  handles: Map<number, SandboxLineageHandle>\n  /**\n   * Whether the kernel may free non-frontier boxes after each round. Safe only\n   * when the driver never authors its own branch point (`describePlan` absent),\n   * so the kernel-inferred `branchPoint` — which moves monotonically toward\n   * higher-scoring iterations — is the only descent source. A driver that\n   * declares `parentIndex` may descend from any prior iteration, so no box can\n   * be freed before loop end.\n   */\n  canPrune: boolean\n}\n\n/**\n * Build the lineage when either lineage flag is set. Probes the platform's fork\n * capability once per run (the lineage degrades gracefully when it's absent).\n * Rejects the lineage + `onWorkerBox` combination: both claim the same\n * box-ownership channel, and silently honoring one would leak or double-free.\n */\nasync function setUpLineage<Task, Output, Decision>(\n  options: RunLoopOptions<Task, Output, Decision>,\n  maxConcurrency: number,\n): Promise<LineageState | undefined> {\n  const lineageOpts = options.lineage\n  if (!lineageOpts || (!lineageOpts.sessionContinuity && !lineageOpts.forkFanout)) return undefined\n  if (options.onWorkerBox) {\n    throw new ValidationError(\n      'runLoop: `lineage` and `onWorkerBox` both own worker boxes — pass only one',\n    )\n  }\n  const capabilities = await probeSandboxCapabilities(options.ctx.sandboxClient)\n  return {\n    lineage: createSandboxLineage(options.ctx.sandboxClient, capabilities, {\n      maxConcurrency,\n      streaming: lineageOpts.streaming,\n    }),\n    options: lineageOpts,\n    handles: new Map(),\n    canPrune: typeof options.driver.describePlan !== 'function',\n  }\n}\n\n/**\n * One iteration's sandbox-stream source for a lineage round. The kernel awaits\n * `acquire()` inside the concurrency-bounded batch (so a fork's per-branch\n * `streamPrompt` and a continue's same-box stream are both rate-limited and\n * abort-checked like a fresh create). Returns the live event stream plus the\n * handle to record for the NEXT round to descend from.\n */\ninterface LineageStreamSource {\n  acquire(): Promise<{ events: AsyncIterable<SandboxEvent>; handle: SandboxLineageHandle }>\n}\n\n/** The per-round lineage plan: a stream source per slice offset, or `undefined`\n *  for offsets with no lineage source (defensive — never expected). */\ntype LineageRoundPlan = (LineageStreamSource | undefined)[]\n\n/**\n * Decide, for one round, how each iteration acquires its sandbox stream:\n *   - refine (1 task) + `sessionContinuity` + a live parent handle ⇒ continue\n *     the parent session on its box.\n *   - fanout (N tasks) + `forkFanout` + a live parent handle ⇒ fork the parent\n *     checkpoint once and stream each branch from a child box (degrades to fresh\n *     boxes inside the lineage when the platform can't fork).\n *   - otherwise (round 0, no parent, the off flag) ⇒ start a fresh box per\n *     iteration THROUGH the lineage so it's owned + a handle is recorded for a\n *     later round to descend from.\n * Round 0 (parentIndex undefined) always starts fresh — the independence of the\n * first batch is preserved.\n */\nfunction planLineageRound<Task>(\n  state: LineageState,\n  specs: AgentRunSpec<Task>[],\n  slice: Task[],\n  parentIndex: number | undefined,\n  signal: AbortSignal,\n): LineageRoundPlan {\n  const lineage = state.lineage\n  const parent = parentIndex !== undefined ? state.handles.get(parentIndex) : undefined\n  const promptFor = (offset: number): string => {\n    const spec = specs[offset % specs.length]\n    if (!spec) throw new ValidationError('runLoop: no AgentRunSpec available for lineage iteration')\n    return spec.taskToPrompt(slice[offset] as Task)\n  }\n  const specAt = (offset: number): AgentRunSpec<unknown> => {\n    const spec = specs[offset % specs.length]\n    if (!spec) throw new ValidationError('runLoop: no AgentRunSpec available for lineage iteration')\n    return spec as AgentRunSpec<unknown>\n  }\n\n  // Continue the parent session: a single-task round descending from a live\n  // handle, with the flag on. Reuses the parent's box + session id.\n  if (slice.length === 1 && parent && state.options.sessionContinuity) {\n    return [\n      {\n        async acquire() {\n          const events = await lineage.continue(parent, promptFor(0), signal)\n          // Continuation threads the SAME handle forward — later rounds keep\n          // descending from this box's evolving session.\n          return { events, handle: parent }\n        },\n      },\n    ]\n  }\n\n  // Fork the parent checkpoint: a multi-task round descending from a live handle,\n  // with the flag on. One checkpoint, N child streams — lazily awaited once and\n  // shared across the offsets so the batch checkpoints exactly once.\n  if (slice.length > 1 && parent && state.options.forkFanout) {\n    const prompts = slice.map((_, offset) => promptFor(offset))\n    const childSpecs = slice.map((_, offset) => specAt(offset))\n    let forked: Promise<{ handle: SandboxLineageHandle; events: AsyncIterable<SandboxEvent> }[]>\n    const ensureForked = () => {\n      forked ??= lineage.fork(parent, prompts, childSpecs, signal)\n      return forked\n    }\n    return slice.map((_, offset) => ({\n      async acquire() {\n        const branches = await ensureForked()\n        const branch = branches[offset]\n        if (!branch)\n          throw new ValidationError('runLoop: lineage fork produced no branch for offset')\n        return branch\n      },\n    }))\n  }\n\n  // Fresh through the lineage (round 0, no parent, or the relevant flag off):\n  // start an owned box per iteration and record a handle for later descent.\n  return slice.map((_, offset) => ({\n    async acquire() {\n      return lineage.start(specAt(offset), promptFor(offset), signal)\n    },\n  }))\n}\n\n/**\n * After a round, free lineage boxes no future round can descend from. The only\n * descent source for a kernel-inferred topology is `branchPoint`, which moves\n * monotonically toward higher-scoring iterations and never returns to one it has\n * passed — so every box except the current branch point's is unreachable and can\n * be torn down now instead of at loop end. Skipped entirely when the driver\n * authors its own branch point (`canPrune` false): it may descend from any prior\n * iteration. Also skipped when the branch point has no recorded handle (its\n * acquire failed) — that conservative case keeps every box.\n */\nasync function pruneLineage<Task, Output>(\n  state: LineageState,\n  iterations: ReadonlyArray<Iteration<Task, Output>>,\n): Promise<void> {\n  if (!state.canPrune) return\n  const keepIndex = branchPoint(iterations)\n  if (keepIndex === undefined) return\n  const keep = state.handles.get(keepIndex)\n  if (!keep) return\n  await state.lineage.prune([keep])\n  // Drop handle entries pointing at the now-freed boxes so the map never hands a\n  // later round a deleted box. Entries sharing the kept box (a refine chain)\n  // stay.\n  const stale: number[] = []\n  for (const [index, handle] of state.handles) {\n    if (handle.box !== keep.box) stale.push(index)\n  }\n  for (const index of stale) state.handles.delete(index)\n}\n\ninterface RunBatchArgs<Task, Output> {\n  slice: Task[]\n  baseIndex: number\n  iterations: Iteration<Task, Output>[]\n  specs: AgentRunSpec<Task>[]\n  output: OutputAdapter<Output>\n  validator: Validator<Output> | undefined\n  maxConcurrency: number\n  signal: AbortSignal\n  ctx: ExecCtx\n  runId: string\n  now: () => number\n  /** Plan round these iterations belong to — stamped as `groupId`. */\n  roundIndex: number\n  /** Iteration this round branched from — stamped as `parentIndex`. */\n  parentIndex?: number\n  /**\n   * Same-sandbox mode: when set, a finished iteration's box is handed here\n   * (kept alive for the planner) instead of being torn down. `undefined` =\n   * default per-iteration teardown.\n   */\n  collectBox?: (box: SandboxInstance) => void\n  /**\n   * Lineage mode: per-offset stream sources for this round. When set, an\n   * iteration acquires its sandbox stream through the lineage (continue / fork /\n   * fresh) instead of `createSandboxForSpec`, and the lineage — not the\n   * iteration — owns box teardown (deferred to loop end).\n   */\n  lineagePlan?: LineageRoundPlan\n  /** The loop's lineage state; iterations record their handle here for the next\n   *  round to descend from. Set iff `lineagePlan` is. */\n  lineageState?: LineageState\n  /** Sandbox streaming mode for the default fresh-box path. 'poll' fire-and-\n   *  detaches + status-polls the terminal result (drop-resilient for long batch\n   *  turns); 'sse' streams live (default). */\n  streaming: 'sse' | 'poll'\n}\n\nasync function runBatch<Task, Output>(args: RunBatchArgs<Task, Output>) {\n  const queue = args.slice.map((task, offset) => ({ task, index: args.baseIndex + offset }))\n  const inflight = new Set<Promise<void>>()\n  // Every started worker, so a rejecting iteration (abort short-circuit, or a\n  // throwing trace emitter) cannot orphan its still-running siblings: we always\n  // drain ALL of them before propagating the first error.\n  const started: Promise<void>[] = []\n  let firstError: unknown\n  try {\n    while (queue.length > 0 || inflight.size > 0) {\n      while (inflight.size < args.maxConcurrency && queue.length > 0) {\n        const item = queue.shift()!\n        const p = executeIteration({ ...args, item }).finally(() => inflight.delete(p))\n        started.push(p)\n        inflight.add(p)\n      }\n      if (inflight.size === 0) break\n      try {\n        await Promise.race(inflight)\n      } catch (err) {\n        if (firstError === undefined) firstError = err\n        // Stop scheduling new work; drain the rest in the finally below.\n        queue.length = 0\n        break\n      }\n    }\n  } finally {\n    const settled = await Promise.allSettled(started)\n    if (firstError === undefined) {\n      const rejected = settled.find((s) => s.status === 'rejected')\n      if (rejected && rejected.status === 'rejected') firstError = rejected.reason\n    }\n  }\n  if (firstError !== undefined) throw firstError\n}\n\ninterface ExecuteIterationArgs<Task, Output> extends RunBatchArgs<Task, Output> {\n  item: { task: Task; index: number }\n}\n\nasync function executeIteration<Task, Output>(args: ExecuteIterationArgs<Task, Output>) {\n  const slot = args.iterations[args.item.index]\n  if (!slot)\n    throw new ValidationError(`runLoop: missing iteration slot at index ${args.item.index}`)\n  const spec = args.specs[args.item.index % args.specs.length]\n  if (!spec) throw new ValidationError('runLoop: no AgentRunSpec available for iteration')\n  slot.startedAt = args.now()\n  slot.agentRunName = spec.name ?? spec.profile.name ?? 'agent'\n\n  await emitTrace(args.ctx.traceEmitter, {\n    kind: 'loop.iteration.started',\n    runId: args.runId,\n    timestamp: args.now(),\n    payload: {\n      iterationIndex: args.item.index,\n      agentRunName: slot.agentRunName,\n      taskHash: hashJson(args.item.task),\n      groupId: args.roundIndex,\n      parentIndex: args.parentIndex,\n    },\n  })\n\n  let box: SandboxInstance | undefined\n  // Lineage-owned boxes are torn down by the lineage at loop end, not here. The\n  // flag tracks whether THIS iteration's box came from the lineage so the\n  // teardown branch below skips it.\n  let lineageOwned = false\n  try {\n    // Stream source: the lineage (continue / fork / fresh) when this round runs\n    // under lineage, else a fresh box + a single `streamPrompt` (today's path,\n    // byte-identical when no lineage). The lineage path supplies a session id on\n    // the stream; the fresh path passes none — preserving N-independent-boxes.\n    let stream: AsyncIterable<SandboxEvent>\n    const source = args.lineagePlan?.[args.item.index - args.baseIndex]\n    if (source) {\n      const acquired = await source.acquire()\n      box = acquired.handle.box\n      lineageOwned = true\n      args.lineageState?.handles.set(args.item.index, acquired.handle)\n      stream = acquired.events\n    } else {\n      box = await createSandboxForSpec(args.ctx.sandboxClient, spec, args.signal)\n      const prompt = spec.taskToPrompt(args.item.task)\n      // 'poll' (opt-in) fire-and-detaches + status-polls the terminal result so a\n      // long, quiet turn never holds a drop-prone live SSE; 'sse' (default)\n      // streams live — byte-identical to the prior path.\n      stream =\n        args.streaming === 'poll'\n          ? promptEvents('poll', box, prompt, `${args.runId}-i${args.item.index}`, args.signal)\n          : box.streamPrompt(prompt, { signal: args.signal })\n    }\n    const placement = describeSandboxPlacement(args.ctx.sandboxClient, box)\n    await emitTrace(args.ctx.traceEmitter, {\n      kind: 'loop.iteration.dispatch',\n      runId: args.runId,\n      timestamp: args.now(),\n      payload: {\n        iterationIndex: args.item.index,\n        agentRunName: slot.agentRunName,\n        placement: placement.kind,\n        sandboxId: placement.sandboxId,\n        fleetId: placement.fleetId,\n        machineId: placement.machineId,\n        groupId: args.roundIndex,\n        parentIndex: args.parentIndex,\n      },\n    })\n    const events: SandboxEvent[] = []\n    for await (const event of stream) {\n      events.push(event)\n      const llmCall = extractLlmCallEvent(event, slot.agentRunName)\n      if (llmCall) {\n        slot.costUsd += llmCall.costUsd ?? 0\n        addTokenUsage(slot.tokenUsage, { input: llmCall.tokensIn, output: llmCall.tokensOut })\n        args.ctx.runHandle?.observe(llmCall)\n      }\n    }\n    slot.events = events\n    slot.output = args.output.parse(events)\n    if (args.validator) {\n      slot.verdict = await args.validator.validate(slot.output, {\n        iteration: args.item.index,\n        ...(box ? { box } : {}),\n        signal: args.signal,\n        traceEmitter: args.ctx.traceEmitter,\n      })\n    }\n  } catch (err) {\n    slot.error = err instanceof Error ? err : new Error(String(err))\n  } finally {\n    slot.endedAt = args.now()\n    await emitTrace(args.ctx.traceEmitter, {\n      kind: 'loop.iteration.ended',\n      runId: args.runId,\n      timestamp: args.now(),\n      payload: {\n        iterationIndex: args.item.index,\n        agentRunName: slot.agentRunName,\n        outputHash: slot.output !== undefined ? hashJson(slot.output) : undefined,\n        verdict: slot.verdict,\n        error: slot.error?.message,\n        costUsd: slot.costUsd,\n        durationMs: slot.endedAt - slot.startedAt,\n        tokenUsage:\n          slot.tokenUsage.input || slot.tokenUsage.output ? { ...slot.tokenUsage } : undefined,\n        groupId: args.roundIndex,\n        parentIndex: args.parentIndex,\n        outputPreview:\n          slot.output !== undefined ? stringifySafe(slot.output, { max: 280 }) : undefined,\n      },\n    })\n    // The loop owns the per-shot box lifecycle. Default: tear it down now so\n    // sandboxes don't leak. Same-sandbox mode: hand it to the kernel to keep\n    // alive for the planner. Lineage mode: the lineage owns the box and keeps it\n    // alive across rounds (a later round may continue/fork it), tearing it down\n    // at loop end — so skip per-iteration teardown here.\n    if (lineageOwned) {\n      // no-op: lineage.teardown() reaps this box at loop end\n    } else if (args.collectBox && box) {\n      args.collectBox(box)\n    } else {\n      await destroySandboxSafe(box, args.ctx.traceEmitter, args.runId, args.now)\n    }\n  }\n  // An abort caught above is NOT a soft per-iteration failure — it must\n  // short-circuit the batch, not degrade to a recorded empty iteration. The\n  // trace was already emitted in the finally, so re-throw it now.\n  if (isAbortError(slot.error) || args.signal.aborted) {\n    if (slot.error) throw slot.error\n    throwAbort()\n  }\n  // A structural lineage error (a dropped session, a fork-capability contract\n  // violation, a missing spec) is likewise not a soft worker failure: it\n  // invalidates the run's continuity/branching guarantee, so propagate it\n  // instead of degrading to a recorded empty iteration the driver might ignore.\n  if (slot.error instanceof ValidationError) throw slot.error\n}\n\nfunction isAbortError(err: unknown): boolean {\n  return err instanceof Error && err.name === 'AbortError'\n}\n\nconst TEARDOWN_TIMEOUT_MS = 15_000\n\n/**\n * Best-effort sandbox teardown. A failed delete must never surface as a loop\n * error, and instances without a `delete` (the loop's test fakes) are skipped.\n * A delete that throws or hangs (bounded by `TEARDOWN_TIMEOUT_MS`) is recorded\n * as a `loop.teardown.failed` trace so a silently-leaking box is observable —\n * distinct from a fake with no `delete`, which is expected and stays silent.\n */\nasync function destroySandboxSafe(\n  box: SandboxInstance | undefined,\n  trace?: LoopTraceEmitter,\n  runId?: string,\n  now?: () => number,\n): Promise<void> {\n  if (!box || typeof (box as { delete?: unknown }).delete !== 'function') return\n  const emitFailed = async (reason: string) => {\n    if (!trace || !runId) return\n    await emitTrace(trace, {\n      kind: 'loop.teardown.failed',\n      runId,\n      timestamp: (now ?? Date.now)(),\n      payload: { sandboxId: readSandboxId(box), reason },\n    })\n  }\n  // Bound the delete so a hung platform delete can't wedge loop return after an\n  // abort. `undefined` = timed out; `false` = delete threw; `true` = deleted.\n  const outcome = await withTimeout(deleteBoxSafe(box), TEARDOWN_TIMEOUT_MS)\n  if (outcome === undefined) await emitFailed('timeout')\n  else if (outcome === false) await emitFailed('delete threw')\n}\n\n/**\n * Branch point for a new round — the iteration a later round descends from.\n * Highest-valid-score iteration so far; ties + no-valid fall back to the latest\n * index. Inferred (not driver-declared), so refine renders as a chain and\n * fanout→refine chains off the fanout winner.\n */\nfunction branchPoint<Task, Output>(\n  iterations: ReadonlyArray<Iteration<Task, Output>>,\n): number | undefined {\n  if (iterations.length === 0) return undefined\n  let best = iterations.length - 1\n  let bestScore = -Infinity\n  for (const iter of iterations) {\n    if (iter.verdict?.valid !== true) continue\n    const score = iter.verdict.score ?? 0\n    if (score > bestScore) {\n      bestScore = score\n      best = iter.index\n    }\n  }\n  return best\n}\n\nexport function describeSandboxPlacement(\n  client: SandboxClient,\n  box: SandboxInstance,\n): LoopSandboxPlacement {\n  if (typeof client.describePlacement === 'function') {\n    try {\n      const result = client.describePlacement(box)\n      if (\n        result &&\n        typeof result === 'object' &&\n        (result.kind === 'sibling' || result.kind === 'fleet')\n      ) {\n        return {\n          kind: result.kind,\n          sandboxId: result.sandboxId ?? readSandboxId(box),\n          fleetId: result.fleetId,\n          machineId: result.machineId,\n        }\n      }\n    } catch {\n      // Adapter bug must not corrupt the iteration; fall through to default.\n    }\n  }\n  return { kind: 'sibling', sandboxId: readSandboxId(box) }\n}\n\nfunction readSandboxId(box: SandboxInstance): string | undefined {\n  const raw = (box as unknown as { id?: unknown }).id\n  return typeof raw === 'string' && raw.length > 0 ? raw : undefined\n}\n\n/**\n * Instantiate a sandbox for an `AgentRunSpec`: sets `backend.profile` to the\n * spec's profile (inferring the backend type when the spec doesn't override\n * it) and merges `sandboxOverrides`. Shared by the loop kernel and the\n * `AgentRuntime.act` sandbox bridge so both boot the sandbox identically.\n */\nexport async function createSandboxForSpec<Task>(\n  client: SandboxClient,\n  spec: AgentRunSpec<Task>,\n  signal: AbortSignal,\n): Promise<SandboxInstance> {\n  const opts = buildBackendOptions(spec.profile, spec.sandboxOverrides)\n  // Cold-start-resilient acquire: a slow scale-from-zero create (node boot +\n  // host-agent registration) can't surface as a failure — readiness is observed\n  // from sandbox status, and a gateway-timed-out create is recovered by lookup.\n  if (signal.aborted) throwAbort()\n  const box = await acquireSandbox(client, opts, { signal })\n  await spec.prepareBox?.(box, { signal })\n  return box\n}\n\ninterface FinalizeArgs<Task, Output, Decision> {\n  options: RunLoopOptions<Task, Output, Decision>\n  decision: Decision\n  iterations: Iteration<Task, Output>[]\n  startMs: number\n  now: () => number\n  runId: string\n}\n\nfunction finalize<Task, Output, Decision>(\n  args: FinalizeArgs<Task, Output, Decision>,\n): LoopResult<Task, Output, Decision> {\n  // Precedence: an explicit caller `selectWinner` wins; else a driver-AUTHORED\n  // winner (a `select` topology move); else the default argmax. A driver that\n  // declares nothing returns undefined and falls through — existing behavior.\n  const winner = args.options.selectWinner\n    ? args.options.selectWinner(args.iterations)\n    : (args.options.driver.selectWinner?.(args.iterations) ?? defaultSelectWinner(args.iterations))\n  const costUsd = args.iterations.reduce((sum, iter) => sum + (iter.costUsd || 0), 0)\n  const tokenUsage = args.iterations.reduce((acc: LoopTokenUsage, iter) => {\n    addTokenUsage(acc, iter.tokenUsage)\n    return acc\n  }, zeroTokenUsage())\n  const result: LoopResult<Task, Output, Decision> = {\n    decision: args.decision,\n    iterations: args.iterations,\n    winner,\n    durationMs: args.now() - args.startMs,\n    costUsd,\n    tokenUsage,\n  }\n  return result\n}\n\n/**\n * Run `decide`, emit the `loop.decision` trace, then finalize and emit\n * `loop.ended`. The two post-while exits (cap reached / `plan()` returned `[]`)\n * share this exact sequence.\n */\nasync function decideAndFinalize<Task, Output, Decision>(\n  options: RunLoopOptions<Task, Output, Decision>,\n  iterations: Iteration<Task, Output>[],\n  startMs: number,\n  now: () => number,\n  runId: string,\n): Promise<LoopResult<Task, Output, Decision>> {\n  emitRunLoopHook(options, {\n    target: 'agent.decision',\n    phase: 'before',\n    runId,\n    timestamp: now(),\n    payload: { historyLength: iterations.length },\n  })\n  const decision = await options.driver.decide(iterations)\n  emitRunLoopHook(options, {\n    target: 'agent.decision',\n    phase: 'after',\n    runId,\n    timestamp: now(),\n    payload: { decision: stringifySafe(decision), historyLength: iterations.length },\n  })\n  await emitTrace(options.ctx.traceEmitter, {\n    kind: 'loop.decision',\n    runId,\n    timestamp: now(),\n    payload: { decision: stringifySafe(decision), historyLength: iterations.length },\n  })\n  return finalizeAndEmitEnded(options, decision, iterations, startMs, now, runId)\n}\n\n/** Finalize the loop and emit the terminal `loop.ended` span. Used by the\n *  in-loop terminal path (decision trace already emitted) and decideAndFinalize. */\nasync function finalizeAndEmitEnded<Task, Output, Decision>(\n  options: RunLoopOptions<Task, Output, Decision>,\n  decision: Decision,\n  iterations: Iteration<Task, Output>[],\n  startMs: number,\n  now: () => number,\n  runId: string,\n): Promise<LoopResult<Task, Output, Decision>> {\n  const result = finalize({ options, decision, iterations, startMs, now, runId })\n  emitRunLoopHook(options, {\n    target: 'agent.run',\n    phase: 'after',\n    runId,\n    timestamp: now(),\n    payload: {\n      decision: stringifySafe(decision),\n      winnerIterationIndex: result.winner?.iterationIndex,\n      totalCostUsd: result.costUsd,\n      durationMs: result.durationMs,\n      iterations: iterations.length,\n    },\n  })\n  // Await the terminal span (unlike a fire-and-forget) so a process exiting\n  // right after runLoop resolves (MCP subprocess / CLI dispatch) can't drop it.\n  await emitTrace(options.ctx.traceEmitter, {\n    kind: 'loop.ended',\n    runId,\n    timestamp: now(),\n    payload: {\n      winnerIterationIndex: result.winner?.iterationIndex,\n      totalCostUsd: result.costUsd,\n      durationMs: result.durationMs,\n      iterations: iterations.length,\n    },\n  })\n  return result\n}\n\n/**\n * The kernel's winner argmax — best-valid-score, ties broken by earliest index,\n * falling back to the best-scoring non-errored output when none is valid. Exported\n * so the `runProgram` tree executor selects across merged sub-loop iterations with\n * the SAME semantics the kernel uses at a single loop's finalize (one selector, not\n * a forked copy).\n */\nexport function defaultSelectWinner<Task, Output>(\n  iterations: Iteration<Task, Output>[],\n): LoopWinner<Task, Output> | undefined {\n  const candidates = iterations.filter((iter) => iter.output !== undefined && !iter.error)\n  if (candidates.length === 0) return undefined\n  const valid = candidates.filter((iter) => iter.verdict?.valid === true)\n  const pool = valid.length > 0 ? valid : candidates\n  const sorted = [...pool].sort(\n    (a, b) => (b.verdict?.score ?? 0) - (a.verdict?.score ?? 0) || a.index - b.index,\n  )\n  const top = sorted[0]\n  if (!top || top.output === undefined) return undefined\n  return {\n    task: top.task,\n    output: top.output,\n    verdict: top.verdict,\n    iterationIndex: top.index,\n    agentRunName: top.agentRunName,\n  }\n}\n\nfunction resolveAgentRuns<Task, Output, Decision>(\n  options: RunLoopOptions<Task, Output, Decision>,\n): AgentRunSpec<Task>[] {\n  if (options.agentRun && options.agentRuns) {\n    throw new ValidationError('runLoop: pass exactly one of `agentRun` or `agentRuns`')\n  }\n  if (options.agentRun) return [options.agentRun]\n  if (options.agentRuns && options.agentRuns.length > 0) return options.agentRuns\n  throw new ValidationError('runLoop: `agentRun` or non-empty `agentRuns` is required')\n}\n\nfunction isTerminalDecision(decision: unknown): boolean {\n  return (\n    decision === 'stop' || decision === 'pick-winner' || decision === 'fail' || decision === 'done'\n  )\n}\n\nfunction emitRunLoopHook<Task, Output, Decision>(\n  options: RunLoopOptions<Task, Output, Decision>,\n  event: {\n    target: 'agent.run' | 'agent.plan' | 'agent.decision'\n    phase: 'before' | 'after' | 'error' | 'event'\n    runId: string\n    timestamp: number\n    stepIndex?: number\n    payload?: Record<string, unknown>\n  },\n): void {\n  notifyRuntimeHookEvent(\n    options.ctx.hooks,\n    {\n      id: `${event.runId}:${event.target}:${event.phase}${\n        event.stepIndex === undefined ? '' : `:${event.stepIndex}`\n      }`,\n      runId: event.runId,\n      target: event.target,\n      phase: event.phase,\n      timestamp: event.timestamp,\n      stepIndex: event.stepIndex,\n      payload: event.payload,\n      metadata: { producer: 'run-loop' },\n    },\n    { signal: options.ctx.signal },\n  )\n}\n\nasync function emitTrace(\n  emitter: LoopTraceEmitter | undefined,\n  event: LoopTraceEvent,\n): Promise<void> {\n  if (!emitter) return\n  await emitter.emit(event)\n}\n\n/**\n * Stable hash for the trace payload. Not cryptographic — only used so\n * downstream eval pipelines can group iterations whose task / output is the\n * same. Bare structural hash; non-JSON values stringify via their `toString`.\n */\nfunction hashJson(value: unknown): string {\n  let str: string\n  try {\n    str = JSON.stringify(value) ?? String(value)\n  } catch {\n    str = String(value)\n  }\n  // FNV-1a 32-bit — branch-free, dependency-free, good enough for grouping.\n  let h = 0x811c9dc5\n  for (let i = 0; i < str.length; i += 1) {\n    h ^= str.charCodeAt(i)\n    h = Math.imul(h, 0x01000193)\n  }\n  return (h >>> 0).toString(16).padStart(8, '0')\n}\n","/**\n * `loopDispatch` — turn `runLoop` into an agent-eval campaign dispatch.\n *\n * Without this adapter a consumer wiring `runLoop` into `runProfileMatrix` /\n * `runCampaign` has to, by hand, every time: (a) build an `ExecCtx` with a\n * sandbox client, (b) adapt the campaign `DispatchContext.trace` into a\n * `LoopTraceEmitter` (or lose all loop trace correlation), and (c) remember to\n * forward the loop's cost + tokens via `ctx.cost` (forgetting it yields a\n * `{0,0}` cell the backend-integrity guard reads as a stub). Three foot-guns,\n * the third silent. The fleet's products skipped (c) and fell back to a\n * `workerRecords[]` side-channel — the exact anti-pattern the substrate exists\n * to kill.\n *\n * `loopDispatch` collapses all three into one typed call:\n *\n *   const dispatch = loopDispatch({\n *     sandboxClient,\n *     toLoopOptions: (scenario, profile) => ({ driver, agentRun, output, validator, task }),\n *   })\n *   await runProfileMatrix({ profiles, scenarios, dispatch, judges, commitSha })\n *\n * Usage is reported automatically; trace events are forwarded automatically;\n * the ctx is built automatically. The seam becomes impossible to mis-wire.\n *\n * Typed structurally against the campaign `DispatchContext` (imported type-only\n * from `@tangle-network/agent-eval/campaign`) — a downward dependency, never an\n * inversion.\n */\n\n// agent-eval's AgentProfile (the eval-harness unit of variation, `model: string`)\n// — NOT sandbox's AgentProfile. ProfileDispatchFn is keyed on the former.\nimport type { AgentProfile } from '@tangle-network/agent-eval'\nimport type {\n  CampaignTraceWriter,\n  DispatchContext,\n  ProfileDispatchFn,\n  Scenario,\n} from '@tangle-network/agent-eval/campaign'\nimport { reportLoopUsage } from './report-usage'\nimport { type RunLoopOptions, runLoop } from './run-loop'\nimport type { LoopResult, LoopTraceEmitter, SandboxClient } from './types'\n\n/** runLoop options minus the `ctx` (loopDispatch builds the ctx). */\nexport type LoopOptionsForDispatch<Task, Output, Decision> = Omit<\n  RunLoopOptions<Task, Output, Decision>,\n  'ctx'\n>\n\nexport interface LoopDispatchOptions<\n  Task,\n  Output,\n  Decision,\n  TScenario extends Scenario,\n  TArtifact,\n> {\n  /** Sandbox client used for every cell's `runLoop`. Supplied once. */\n  sandboxClient: SandboxClient\n  /** Build the per-cell runLoop options from the scenario (+ profile, when\n   *  used with `runProfileMatrix`). */\n  toLoopOptions: (\n    scenario: TScenario,\n    profile: AgentProfile,\n  ) => LoopOptionsForDispatch<Task, Output, Decision>\n  /** Map the finished loop to the artifact the judges score. Default:\n   *  `result.winner?.output`. A loop with no winner yields `undefined` (judges\n   *  skip the cell) — but the loop's token usage is STILL reported, so the\n   *  integrity guard sees real activity. */\n  toArtifact?: (result: LoopResult<Task, Output, Decision>) => TArtifact\n  /** Forward `loop.*` trace events into the campaign's scoped trace so loop\n   *  spans correlate with the cell. Default true. */\n  forwardTrace?: boolean\n  /** Cost-meter source label for the loop's spend. Default `'loop'`. */\n  costSource?: string\n}\n\n/** Bridge a campaign `DispatchContext.trace` to a `LoopTraceEmitter` so every\n *  `loop.*` event lands as a span under the cell's scoped trace. */\nfunction campaignTraceToLoopEmitter(trace: CampaignTraceWriter): LoopTraceEmitter {\n  return {\n    emit(event) {\n      trace\n        .span(event.kind, { runId: event.runId, timestamp: event.timestamp, ...event.payload })\n        .end()\n    },\n  }\n}\n\nasync function runLoopForCell<Task, Output, Decision, TScenario extends Scenario, TArtifact>(\n  opts: LoopDispatchOptions<Task, Output, Decision, TScenario, TArtifact>,\n  scenario: TScenario,\n  profile: AgentProfile,\n  ctx: DispatchContext,\n): Promise<TArtifact> {\n  const loopOptions = opts.toLoopOptions(scenario, profile)\n  const result = await runLoop<Task, Output, Decision>({\n    ...loopOptions,\n    ctx: {\n      sandboxClient: opts.sandboxClient,\n      signal: ctx.signal,\n      traceEmitter: opts.forwardTrace === false ? undefined : campaignTraceToLoopEmitter(ctx.trace),\n    },\n  })\n  reportLoopUsage(ctx.cost, result, opts.costSource ?? 'loop')\n  const toArtifact =\n    opts.toArtifact ?? ((r: LoopResult<Task, Output, Decision>) => r.winner?.output as TArtifact)\n  return toArtifact(result)\n}\n\n/**\n * Adapter for `runProfileMatrix` (profile is an axis). Returns a\n * `ProfileDispatchFn` that runs `runLoop` per (profile, scenario) cell and\n * reports usage automatically.\n */\nexport function loopDispatch<Task, Output, Decision, TScenario extends Scenario, TArtifact>(\n  opts: LoopDispatchOptions<Task, Output, Decision, TScenario, TArtifact>,\n): ProfileDispatchFn<TScenario, TArtifact> {\n  return (profile, scenario, ctx) => runLoopForCell(opts, scenario, profile, ctx)\n}\n","/**\n * createMcpEnvironment — wrap any MCP server as an `Environment` (the product-adoption\n * primitive: a product's agent tools are usually already an MCP surface, so the domain\n * only writes the lifecycle hooks — open a scoped artifact, score it with a deployable\n * check, close it — and the tool plumbing is derived from the server).\n *\n * What the helper owns (the generic 80%, hardened on the EnterpriseOps gym):\n *   - JSON-RPC `tools/list` → `AgenticTool[]`, with schemas coerced to the\n *     OpenAI-tool-valid shape (top-level oneOf/anyOf/allOf/enum/not are rejected by\n *     tool-calling providers; nested combinators are fine).\n *   - JSON-RPC `tools/call` → the tool's text content (errors surfaced as `ERROR: …`\n *     strings — a bad call is the agent's outcome, not an infra fault).\n *   - SSE response parsing (streamable-HTTP MCP servers answer with `data:` lines).\n *   - Bounded retry with backoff on thrown fetches (transient network ≠ task failure).\n *\n * What the domain supplies: `open` (create/seed the per-task artifact and return its\n * MCP endpoint — url + headers carry the per-artifact scoping, e.g. a database id\n * header), `score` (the deployable check), and optional `close`/`selectTools`.\n */\n\nimport type { Environment } from './run-benchmark'\nimport type { AgenticTask, AgenticTool, ArtifactHandle, SurfaceScore } from './strategy'\n\n/** Where a handle's MCP server lives; headers carry per-artifact scoping. */\nexport interface McpEndpoint {\n  url: string\n  headers?: Record<string, string>\n}\n\nexport interface McpEnvironmentOptions {\n  name: string\n  /** Create/seed the per-task artifact; return its handle + the MCP endpoint scoped to it. */\n  open(task: AgenticTask): Promise<{ handle: ArtifactHandle; endpoint: McpEndpoint }>\n  /** The deployable check over the artifact's current state. */\n  score(task: AgenticTask, handle: ArtifactHandle): Promise<SurfaceScore>\n  /** Teardown (delete the seeded artifact). Optional — omit for stateless servers. */\n  close?(handle: ArtifactHandle): Promise<void>\n  /** Restrict/order the server's tools per task (e.g. the task's selected_tools). Default: all. */\n  selectTools?(task: AgenticTask, all: AgenticTool[]): AgenticTool[]\n  /** Cap on a tool result's text fed back to the worker. Default 1500 chars. */\n  maxResultChars?: number\n}\n\n/** POST JSON-RPC and parse a JSON body OR the last `data:` line of an SSE stream.\n *  Retries thrown fetches (transient network) with linear backoff; HTTP status and\n *  JSON-RPC errors are returned to the caller, not retried. */\nasync function rpc(\n  endpoint: McpEndpoint,\n  body: unknown,\n): Promise<{ status: number; json: unknown }> {\n  let lastErr: unknown\n  for (let attempt = 0; attempt < 4; attempt += 1) {\n    try {\n      const r = await fetch(endpoint.url, {\n        method: 'POST',\n        headers: { 'content-type': 'application/json', ...(endpoint.headers ?? {}) },\n        body: JSON.stringify(body),\n      })\n      const text = await r.text()\n      const dataLines = text\n        .split('\\n')\n        .filter((l) => l.startsWith('data:'))\n        .map((l) => l.slice(5).trim())\n      const payload = dataLines.length ? dataLines[dataLines.length - 1] : text\n      try {\n        return { status: r.status, json: JSON.parse(payload ?? 'null') }\n      } catch {\n        return { status: r.status, json: text }\n      }\n    } catch (err) {\n      lastErr = err\n      await new Promise((res) => setTimeout(res, 1000 * (attempt + 1)))\n    }\n  }\n  throw new Error(\n    `mcp rpc ${endpoint.url} failed after 4 attempts: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`,\n  )\n}\n\n/** Coerce an MCP inputSchema to an OpenAI-tool-valid top-level object schema. */\nfunction sanitizeSchema(s: unknown): Record<string, unknown> {\n  const o = s && typeof s === 'object' ? (s as Record<string, unknown>) : {}\n  const banned = o.oneOf || o.anyOf || o.allOf || o.not || o.enum\n  if (o.type === 'object' && !banned && o.properties && typeof o.properties === 'object') {\n    return {\n      type: 'object',\n      properties: o.properties as Record<string, unknown>,\n      ...(Array.isArray(o.required) ? { required: o.required as string[] } : {}),\n    }\n  }\n  return { type: 'object', properties: {} }\n}\n\nexport function createMcpEnvironment(opts: McpEnvironmentOptions): Environment {\n  const endpoints = new Map<string, McpEndpoint>()\n  const maxChars = opts.maxResultChars ?? 1500\n\n  return {\n    name: opts.name,\n\n    async open(task) {\n      const { handle, endpoint } = await opts.open(task)\n      endpoints.set(handle.id, endpoint)\n      return handle\n    },\n\n    async tools(task, handle) {\n      const endpoint = endpoints.get(handle.id)\n      if (!endpoint) throw new Error(`${opts.name}: tools() before open() for ${handle.id}`)\n      const { json } = await rpc(endpoint, {\n        jsonrpc: '2.0',\n        id: 1,\n        method: 'tools/list',\n        params: {},\n      })\n      const all = (\n        (\n          json as {\n            result?: {\n              tools?: Array<{ name: string; description?: string; inputSchema?: unknown }>\n            }\n          }\n        ).result?.tools ?? []\n      ).map(\n        (t): AgenticTool => ({\n          type: 'function',\n          function: {\n            name: t.name,\n            description: (t.description ?? '').slice(0, 1000),\n            parameters: sanitizeSchema(t.inputSchema),\n          },\n        }),\n      )\n      return opts.selectTools ? opts.selectTools(task, all) : all\n    },\n\n    async call(handle, name, args) {\n      const endpoint = endpoints.get(handle.id)\n      if (!endpoint) return 'ERROR: workspace closed'\n      const { json } = await rpc(endpoint, {\n        jsonrpc: '2.0',\n        id: 2,\n        method: 'tools/call',\n        params: { name, arguments: args },\n      })\n      const result =\n        (json as {\n          result?: { content?: Array<{ text?: string }>; isError?: boolean }\n          error?: unknown\n        }) ?? {}\n      if (result.error) return `ERROR: ${JSON.stringify(result.error).slice(0, 300)}`\n      const text =\n        result.result?.content?.map((c) => c.text ?? '').join('\\n') ??\n        JSON.stringify(result.result ?? json)\n      return text.slice(0, maxChars)\n    },\n\n    score: (task, handle) => opts.score(task, handle),\n\n    async close(handle) {\n      endpoints.delete(handle.id)\n      await opts.close?.(handle)\n    },\n  }\n}\n","/**\n * @experimental\n *\n * The reactive `Scope` impl (KEYSTONE, build step 4 + the step-8 adapter).\n *\n * An `Agent.act` runs inside a `Scope`. It `spawn`s children dynamically and reacts to\n * them via `next()`. The scope owns ONE in-memory nursery — the authoritative live set —\n * and is the single place that drives a child's lifecycle: reserve budget atomically,\n * resolve a `Executor` through the open registry, run it (one-shot OR streaming),\n * fold its normalized `UsageEvent`s into a conserved `Spend`, reconcile the reservation\n * (refunding the unspent remainder), persist the result blob + journal records, and\n * deliver the `Settled` through the `next()` cursor.\n *\n * Three invariants this impl enforces by construction:\n *  - `next()` is a ray.wait n=1 cursor over THIS scope's live set; it assigns the\n *    monotonic `seq` (the recorded cursor order) at the moment it yields a settlement, so\n *    replay re-delivers in the identical order — `seq` is never wall-clock.\n *  - Budget is reserved at spawn and reconciled at settle through the shared `BudgetPool`,\n *    so `spawn` fails CLOSED on an exhausted pool and total ≡ free + reserved + committed.\n *  - `view` reads the in-memory nursery, never the journal — O(live), synchronous.\n *\n * The settle path is the only writer of journal `settled` events; the spawn path the only\n * writer of `spawned` events. The result blob is `put` BEFORE the journal `settled` record\n * references its `outRef`, so a crash can never leave a journaled ref with no blob.\n */\n\nimport { contentAddress } from '../../durable/spawn-journal'\nimport { ValidationError } from '../../errors'\nimport { notifyRuntimeHookEvent, type RuntimeHooks } from '../../runtime-hooks'\nimport type { Iteration } from '../types'\nimport type { BudgetPool, ReservationTicket } from './budget'\nimport type {\n  Agent,\n  AgentSpec,\n  Budget,\n  DefaultVerdict,\n  Executor,\n  ExecutorContext,\n  ExecutorRegistry,\n  ExecutorResult,\n  Handle,\n  NodeId,\n  NodeSnapshot,\n  NodeStatus,\n  ResultBlobStore,\n  Scope,\n  Settled,\n  SpawnJournal,\n  SpawnOpts,\n  Spend,\n  TreeView,\n  UsageEvent,\n} from './types'\n\n/** Construction args for `createScope`. The supervisor threads the shared pool, journal,\n *  blob store, and executor registry through; `depth`/`maxDepth` pair the runtime\n *  recursion ceiling with the conserved pool (R3). */\nexport interface ScopeArgs {\n  /** This scope's owning node id — children get `${parentId}:s${seq}` ids. */\n  readonly parentId: NodeId\n  /** Journal/blob root key the supervisor `beginTree`'d. */\n  readonly root: NodeId\n  /** The shared conserved reservation pool (one per supervised run). */\n  readonly pool: BudgetPool\n  /** Append-only spawn journal; this scope writes `spawned` + `settled` records. */\n  readonly journal: SpawnJournal\n  /** Content-addressed result store backing `outRef` rehydration. */\n  readonly blobs: ResultBlobStore\n  /** The open executor resolver (BYO → router/inline → registered harness factory). */\n  readonly executors: ExecutorRegistry\n  /** Per-spawn executor-construction seams (sandbox client, router config, cli bin). */\n  readonly seams: Readonly<Record<string, unknown>>\n  /** This scope's recursion depth (root = 0). */\n  readonly depth: number\n  /** Runtime recursion-depth ceiling — a spawn past it fails closed `depth-exceeded`. */\n  readonly maxDepth?: number\n  /** Abort signal for this scope; an abort cascades into every live child's executor. */\n  readonly signal: AbortSignal\n  /** Injected clock — keeps the journal `at` timestamp deterministic in tests. */\n  readonly now?: () => number\n  /** Lifecycle stream sink. `spawn` emits `agent.spawn`, `next` emits `agent.child` — the\n   *  SAME stream `runLoop`/`tool-loop` feed, so the recursive tree is ONE observable stream\n   *  (the topology viewer reads it). Undefined ⇒ the journal stays the only record. */\n  readonly hooks?: RuntimeHooks\n}\n\n/**\n * Internal live-set entry. `settled` resolves once the child's executor has fully drained,\n * its reservation reconciled, and its result blob persisted; `next()` awaits these to drive\n * the cursor. `resolved` mirrors that terminal value synchronously so a concurrent `next()`\n * can pick the next undelivered settlement without re-racing. `delivered` guards exactly-once\n * delivery; `seq` is stamped by `next()`, never here.\n */\ninterface LiveChild {\n  readonly id: NodeId\n  status: NodeStatus\n  runtime: NodeSnapshot['runtime']\n  readonly budget: Budget\n  readonly label: string\n  spent: Spend\n  outRef?: string\n  /** Resolves with the terminal settlement WITHOUT a `seq` — `next()` stamps the seq. */\n  readonly settled: Promise<PreSeqSettled>\n  /** Synchronous mirror of `settled`'s value once it has resolved (else `undefined`). */\n  resolved?: PreSeqSettled\n  /** True once `next()` has yielded this child's settlement. */\n  delivered: boolean\n  /** The executor's out-of-band inbox, captured at spawn — backs `scope.send`. */\n  readonly deliver?: (msg: unknown) => void\n}\n\n/** A child's terminal settlement before the cursor stamps the monotonic `seq`. */\ntype PreSeqSettled =\n  | { kind: 'done'; out: unknown; outRef: string; verdict?: DefaultVerdict; spent: Spend }\n  | { kind: 'down'; reason: string; infra: boolean; restartCount: number }\n\nexport function createScope<Out>(args: ScopeArgs): Scope<Out> {\n  const children = new Map<NodeId, LiveChild>()\n  // Two distinct monotonic counters in two namespaces:\n  //  - `spawnOrdinal` is the spawn order (0,1,2,…); it mints the deterministic node id\n  //    `${parent}:s${ordinal}` and stamps the `spawned` event's `seq`. Known at spawn.\n  //  - `cursorSeq` is the order `next()` yields settlements (B2); it stamps the\n  //    `settled`/`cancelled` event's `seq` and the `Settled.seq` the driver branches on.\n  // They are separate so a `spawned` event never collides with a `settled` event in the\n  // journal's per-tree uniqueness guard (which is scoped to the cursor namespace).\n  let spawnOrdinal = 0\n  let cursorSeq = 0\n  const now = args.now ?? Date.now\n\n  function spawn<C extends Out>(\n    agent: Agent<unknown, C>,\n    task: unknown,\n    opts: SpawnOpts,\n  ):\n    | { ok: true; handle: Handle<C> }\n    | { ok: false; reason: 'budget-exhausted' | 'depth-exceeded' } {\n    if (args.maxDepth !== undefined && args.depth >= args.maxDepth) {\n      return { ok: false, reason: 'depth-exceeded' }\n    }\n\n    // Resolve the leaf executor through the OPEN registry FIRST (no reservation to unwind\n    // if the agent is misconfigured). An agent carries its executor mapping as the\n    // `executorSpec` (an `AgentSpec`); resolution precedence (BYO → router/inline → harness\n    // factory) lives in the registry, not in a call-site switch.\n    const spec = (agent as unknown as { executorSpec?: unknown }).executorSpec\n    if (!isAgentSpec(spec)) {\n      throw new ValidationError(\n        `scope.spawn: agent \"${agent.name}\" exposes no \\`executorSpec\\` (AgentSpec) to resolve a Executor`,\n      )\n    }\n    const resolved = args.executors.resolve<C>(spec)\n    if (!resolved.succeeded) throw new ValidationError(`scope.spawn: ${resolved.error}`)\n\n    // Reserve the child's whole ceiling atomically; fail CLOSED when the pool can't cover\n    // it (never read-then-spawn overcommit, so Σk is conserved by construction).\n    const reservation = args.pool.reserve(opts.budget)\n    if (!reservation.ok) return { ok: false, reason: reservation.reason }\n\n    // Everything between reserve and runChild's hand-off owns the reservation. A SYNCHRONOUS\n    // throw here (most likely the executor factory `resolved.value(spec, ctx)`) would otherwise\n    // leak the reservation — runChild, which reconciles the ticket, is never reached. Release it\n    // with zero spend on throw, then rethrow, so `total ≡ free + reserved + committed` holds.\n    // (runChild is the last statement and never sync-throws, so there is no double-reconcile.)\n    try {\n      const ordinal = spawnOrdinal++\n      const id: NodeId = `${args.parentId}:s${ordinal}`\n\n      // The child's abort chains off this scope's signal (a scope abort reaps every child)\n      // AND off its own handle.abort(). Aborting mid-acquire cascades through the executor's\n      // signal into its acquireSandbox find-by-name reap, so an acquiring node never leaks.\n      const childAbort = new AbortController()\n      const cascadeAbort = () => childAbort.abort()\n      if (args.signal.aborted) childAbort.abort()\n      else args.signal.addEventListener('abort', cascadeAbort, { once: true })\n\n      const ctx: ExecutorContext = { signal: childAbort.signal, seams: args.seams }\n      const executor = resolved.value(spec, ctx) as Executor<C>\n\n      const handle: Handle<C> = {\n        id,\n        label: opts.label,\n        get status(): NodeStatus {\n          return children.get(id)?.status ?? 'cancelled'\n        },\n        abort(reason?: string): void {\n          childAbort.abort(reason)\n        },\n      }\n\n      const live: LiveChild = {\n        id,\n        status: 'acquiring',\n        runtime: executor.runtime,\n        budget: opts.budget,\n        label: opts.label,\n        spent: zeroSpend(),\n        settled: undefined as unknown as Promise<PreSeqSettled>,\n        delivered: false,\n        ...(executor.deliver ? { deliver: executor.deliver.bind(executor) } : {}),\n      }\n      children.set(id, live)\n\n      void args.journal.appendEvent(args.root, {\n        kind: 'spawned',\n        id,\n        parent: args.parentId,\n        label: opts.label,\n        budget: opts.budget,\n        runtime: executor.runtime,\n        seq: ordinal,\n        at: new Date(now()).toISOString(),\n      })\n\n      notifyRuntimeHookEvent(\n        args.hooks,\n        {\n          id: `${id}:spawn`,\n          runId: args.root,\n          target: 'agent.spawn',\n          phase: 'after',\n          timestamp: now(),\n          stepIndex: ordinal,\n          parentId: args.parentId,\n          payload: {\n            childId: id,\n            label: opts.label,\n            runtime: executor.runtime,\n            budget: opts.budget,\n            depth: args.depth,\n          },\n        },\n        { signal: args.signal },\n      )\n\n      // Drive the executor to settlement off to the side; `next()` awaits the resulting\n      // promise. A thrown executor (or a real abort) is TYPED into a `down` record by\n      // `runChild` (never re-thrown) so a single failing child never rejects the cursor.\n      const settled = runChild(\n        live,\n        executor,\n        childAbort,\n        task,\n        opts,\n        args.pool,\n        reservation.ticket,\n        args.blobs,\n      )\n        .then((s) => {\n          live.resolved = s\n          return s\n        })\n        .finally(() => {\n          args.signal.removeEventListener('abort', cascadeAbort)\n        })\n      ;(live as { settled: Promise<PreSeqSettled> }).settled = settled\n\n      return { ok: true, handle }\n    } catch (err) {\n      args.pool.reconcile(reservation.ticket, zeroSpend())\n      throw err\n    }\n  }\n\n  async function next(): Promise<Settled<Out> | null> {\n    const undelivered = () => [...children.values()].filter((c) => !c.delivered)\n    if (undelivered().length === 0) return null\n\n    // ray.wait n=1: await the FIRST not-yet-delivered child to settle. Loop because a\n    // concurrent `next()` may take the race winner between the await and the pick.\n    for (;;) {\n      const pending = undelivered()\n      if (pending.length === 0) return null\n      // Prefer an already-resolved-but-undelivered child (no await needed).\n      const ready = pending.find((c) => c.resolved !== undefined)\n      const chosen = ready ?? (await raceFirstSettled(pending))\n      if (chosen.delivered) continue\n      chosen.delivered = true\n\n      const seq = cursorSeq++\n      const settlement = chosen.resolved\n      if (!settlement) {\n        throw new ValidationError(\n          `scope.next: child '${chosen.id}' won the settle race without a resolved value`,\n        )\n      }\n      return finalizeSettlement<Out>(chosen, settlement, seq, args, now)\n    }\n  }\n\n  function send(nodeId: NodeId, msg: unknown): boolean {\n    const child = children.get(nodeId)\n    // Deliver only to a child that is still LIVE (not yet yielded by the cursor) and whose executor\n    // accepts an inbox. A settled/unknown child, or a leaf with no `deliver`, cannot be steered.\n    if (!child || child.delivered || !child.deliver) return false\n    child.deliver(msg)\n    return true\n  }\n\n  return {\n    spawn,\n    next,\n    send,\n    get view(): TreeView {\n      return makeTreeView(args.parentId, children)\n    },\n    get budget() {\n      return args.pool.readout()\n    },\n  }\n}\n\n/** Await whichever pending child settles first, returning the child (its `resolved` is set\n *  by the time this resolves because `runChild`'s `.then` sets it before the promise\n *  resolves downstream). */\nasync function raceFirstSettled(pending: LiveChild[]): Promise<LiveChild> {\n  return Promise.race(pending.map((c) => c.settled.then(() => c)))\n}\n\n/** Stamp the cursor `seq`, write the `settled` journal record, and project the\n *  `PreSeqSettled` into the frozen `Settled` the driver branches on. */\nasync function finalizeSettlement<Out>(\n  child: LiveChild,\n  settlement: PreSeqSettled,\n  seq: number,\n  args: ScopeArgs,\n  now: () => number,\n): Promise<Settled<Out>> {\n  const handle = frozenHandle<Out>(child)\n  if (settlement.kind === 'down') {\n    child.status = 'failed'\n    await args.journal.appendEvent(args.root, {\n      kind: 'settled',\n      id: child.id,\n      status: 'down',\n      spent: child.spent,\n      infra: settlement.infra,\n      seq,\n      at: new Date(now()).toISOString(),\n    })\n    notifyRuntimeHookEvent(\n      args.hooks,\n      {\n        id: `${child.id}:settled`,\n        runId: args.root,\n        target: 'agent.child',\n        phase: 'after',\n        timestamp: now(),\n        stepIndex: seq,\n        parentId: args.parentId,\n        payload: {\n          childId: child.id,\n          status: 'down',\n          reason: settlement.reason,\n          infra: settlement.infra,\n          spent: child.spent,\n        },\n      },\n      { signal: args.signal },\n    )\n    return {\n      kind: 'down',\n      handle,\n      reason: settlement.reason,\n      infra: settlement.infra,\n      restartCount: settlement.restartCount,\n      seq,\n    }\n  }\n\n  child.status = 'done'\n  child.outRef = settlement.outRef\n  child.spent = settlement.spent\n  await args.journal.appendEvent(args.root, {\n    kind: 'settled',\n    id: child.id,\n    status: 'done',\n    outRef: settlement.outRef,\n    ...(settlement.verdict ? { verdict: settlement.verdict } : {}),\n    spent: settlement.spent,\n    seq,\n    at: new Date(now()).toISOString(),\n  })\n  notifyRuntimeHookEvent(\n    args.hooks,\n    {\n      id: `${child.id}:settled`,\n      runId: args.root,\n      target: 'agent.child',\n      phase: 'after',\n      timestamp: now(),\n      stepIndex: seq,\n      parentId: args.parentId,\n      payload: {\n        childId: child.id,\n        status: 'done',\n        outRef: settlement.outRef,\n        score: settlement.verdict?.score,\n        valid: settlement.verdict?.valid,\n        spent: settlement.spent,\n      },\n    },\n    { signal: args.signal },\n  )\n  return {\n    kind: 'done',\n    handle,\n    out: settlement.out as Out,\n    outRef: settlement.outRef,\n    ...(settlement.verdict ? { verdict: settlement.verdict } : {}),\n    spent: settlement.spent,\n    seq,\n  }\n}\n\n/**\n * Drive one child's `Executor` to a terminal `PreSeqSettled`, folding usage into the\n * conserved `Spend`, reconciling the reservation, and persisting the result blob. Both\n * executor shapes are handled here: a one-shot `Promise<ExecutorResult>` and a streaming\n * `AsyncIterable<UsageEvent>` whose terminal artifact is read from `resultArtifact()`.\n *\n * A thrown executor (or a real abort) becomes a TYPED `down` — never re-thrown — so a\n * single failing child cannot reject the `next()` cursor (the M2 typed-result discipline,\n * applied per child). The reservation is reconciled on EVERY path (success, abort, throw)\n * so the conserved pool can never leak a reservation.\n */\nasync function runChild<C>(\n  live: LiveChild,\n  executor: Executor<C>,\n  childAbort: AbortController,\n  task: unknown,\n  opts: SpawnOpts,\n  pool: BudgetPool,\n  ticket: ReservationTicket,\n  blobs: ResultBlobStore,\n): Promise<PreSeqSettled> {\n  let reconciled = false\n  const reconcileOnce = (spend: Spend) => {\n    if (reconciled) return\n    reconciled = true\n    // A budgetExempt executor reports zero spend by contract; the reconcile refunds its\n    // whole reservation, keeping it out of the conserved Σk by construction.\n    pool.reconcile(ticket, clampSpend(spend, opts.budget))\n  }\n  try {\n    live.status = 'running'\n    const ran = executor.execute(task, childAbort.signal)\n    let artifact: ExecutorResult<C>\n    if (isAsyncIterable(ran)) {\n      // Streaming: fold the incremental usage events as they arrive (the conserved-pool\n      // authority), then read the terminal artifact after the stream drains.\n      const spend = await foldStream(ran)\n      live.spent = spend\n      artifact = executor.resultArtifact() as ExecutorResult<C>\n      reconcileOnce(spend)\n    } else {\n      const terminal = await ran\n      live.spent = terminal.spent\n      artifact = terminal\n      reconcileOnce(terminal.spent)\n    }\n\n    if (childAbort.signal.aborted) {\n      await teardownSafe(executor, opts.shutdown ?? 'brutalKill')\n      return downRecord('aborted before settle', true)\n    }\n\n    // The durable record is keyed by the canonical content address of the output — the\n    // single addressing scheme the blob store enforces and the supervisor's winner path\n    // uses. An executor's self-minted `resultArtifact().outRef` is its own internal dedup\n    // hint; the journal/blob `outRef` is re-derived here so replay rehydrates by one\n    // scheme. Persist the blob BEFORE the journal `settled` record references its `outRef`,\n    // so a crash never leaves a journaled ref pointing at a missing blob.\n    const outRef = contentAddress(artifact.out)\n    await blobs.put(outRef, artifact.out)\n    await teardownSafe(executor, opts.shutdown ?? 'infinity')\n    return {\n      kind: 'done',\n      out: artifact.out,\n      outRef,\n      ...(artifact.verdict ? { verdict: artifact.verdict } : {}),\n      spent: live.spent,\n    }\n  } catch (err) {\n    // Reconcile the (likely partial) spend so the reservation is refunded even on a throw.\n    reconcileOnce(live.spent)\n    await teardownSafe(executor, 'brutalKill')\n    const aborted = childAbort.signal.aborted || isAbortError(err)\n    return downRecord(errMessage(err), aborted || isInfraError(err))\n  }\n}\n\n/**\n * The step-8 merge-boundary adapter (M4): rehydrate a `Settled.done` into the kernel's\n * `Iteration` shape so `defaultSelectWinner` stays single-sourced — the supervisor selects\n * across settled children with the SAME argmax the loop kernel uses, not a forked copy.\n *\n * `index` is the cursor `seq` (the recorded, replay-stable order); `output`/`verdict`/\n * `tokenUsage`/`costUsd` are read straight off the settlement (already rehydrated from the\n * `outRef` blob by `next()`). Events are empty — a settled child is an opaque leaf result,\n * not a sandbox event stream — and the timing/cost fields project its conserved `Spend`.\n * Fail loud on a `down` settlement: only a `done` child is an iteration.\n */\nexport function settledToIteration<Out>(settled: Settled<Out>): Iteration<unknown, Out> {\n  if (settled.kind === 'down') {\n    throw new ValidationError(\n      `settledToIteration: cannot adapt a 'down' settlement (node '${settled.handle.id}', seq ${settled.seq}) to an Iteration`,\n    )\n  }\n  return {\n    index: settled.seq,\n    task: undefined,\n    agentRunName: settled.handle.label,\n    output: settled.out,\n    ...(settled.verdict ? { verdict: settled.verdict } : {}),\n    events: [],\n    startedAt: 0,\n    endedAt: settled.spent.ms,\n    costUsd: settled.spent.usd,\n    tokenUsage: { input: settled.spent.tokens.input, output: settled.spent.tokens.output },\n  }\n}\n\n// ── Helpers ─────────────────────────────────────────────────────────────────────\n\nfunction makeTreeView(root: NodeId, children: Map<NodeId, LiveChild>): TreeView {\n  const nodes: NodeSnapshot[] = [...children.values()].map((c) => ({\n    id: c.id,\n    parent: root,\n    label: c.label,\n    status: c.status,\n    runtime: c.runtime,\n    budget: c.budget,\n    spent: c.spent,\n    ...(c.outRef ? { outRef: c.outRef } : {}),\n  }))\n  return {\n    root,\n    nodes,\n    inFlight: nodes.filter((n) => n.status === 'running' || n.status === 'acquiring').length,\n  }\n}\n\nfunction frozenHandle<C>(child: LiveChild): Handle<C> {\n  return {\n    id: child.id,\n    label: child.label,\n    status: child.status,\n    abort(): void {\n      // A settled child is terminal; abort is a no-op (its executor already tore down).\n    },\n  }\n}\n\nasync function foldStream(stream: AsyncIterable<UsageEvent>): Promise<Spend> {\n  const tokens = { input: 0, output: 0 }\n  let usd = 0\n  let iterations = 0\n  for await (const ev of stream) {\n    if (ev.kind === 'tokens') {\n      tokens.input += ev.input\n      tokens.output += ev.output\n    } else if (ev.kind === 'cost') {\n      usd += ev.usd\n    } else {\n      iterations += 1\n    }\n  }\n  return { iterations, tokens, usd, ms: 0 }\n}\n\n/** Clamp a child's reported spend to its reservation so the pool's fail-loud over-spend\n *  guard never trips on a benign overshoot from an external usage report; the difference\n *  refunds to the pool as if the child stopped at its ceiling. */\nfunction clampSpend(spend: Spend, budget: Budget): Spend {\n  const totalTokens = spend.tokens.input + spend.tokens.output\n  const tokensOk = totalTokens <= budget.maxTokens\n  const itersOk = spend.iterations <= budget.maxIterations\n  const usdOk = budget.maxUsd === undefined || spend.usd <= budget.maxUsd\n  if (tokensOk && itersOk && usdOk) return spend\n  const ratio = !tokensOk && totalTokens > 0 ? budget.maxTokens / totalTokens : 1\n  return {\n    iterations: Math.min(spend.iterations, budget.maxIterations),\n    tokens:\n      ratio < 1\n        ? {\n            input: Math.floor(spend.tokens.input * ratio),\n            output: Math.floor(spend.tokens.output * ratio),\n          }\n        : spend.tokens,\n    usd: budget.maxUsd === undefined ? spend.usd : Math.min(spend.usd, budget.maxUsd),\n    ms: spend.ms,\n  }\n}\n\nasync function teardownSafe<C>(\n  executor: Executor<C>,\n  grace: number | 'brutalKill' | 'infinity',\n): Promise<void> {\n  try {\n    await executor.teardown(grace)\n  } catch {\n    // Teardown failure is observable through the node staying live; swallow so it never\n    // masks the settlement itself. The supervisor's join barrier reaps on its own grace.\n  }\n}\n\nfunction downRecord(reason: string, infra: boolean): PreSeqSettled {\n  return { kind: 'down', reason, infra, restartCount: 0 }\n}\n\nfunction zeroSpend(): Spend {\n  return { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 }\n}\n\nfunction isAsyncIterable(value: unknown): value is AsyncIterable<UsageEvent> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as AsyncIterable<UsageEvent>)[Symbol.asyncIterator] === 'function'\n  )\n}\n\n/** An `AgentSpec` is identified structurally — it carries a `profile` and a `harness`\n *  field (`null` or a `BackendType`) and optionally an `executor`. */\nfunction isAgentSpec(value: unknown): value is AgentSpec {\n  if (typeof value !== 'object' || value === null) return false\n  const v = value as Record<string, unknown>\n  return 'profile' in v && 'harness' in v\n}\n\nfunction isAbortError(err: unknown): boolean {\n  return (\n    typeof err === 'object' &&\n    err !== null &&\n    'name' in err &&\n    (err as { name: unknown }).name === 'AbortError'\n  )\n}\n\n/** External-boundary failures (network/FS/subprocess) are infra — excluded from the merge\n *  `n` and the equal-k assertion. A `ValidationError` from a built-in executor wraps a\n *  config/transport failure, so it counts as infra; other throws are a real bad result. */\nfunction isInfraError(err: unknown): boolean {\n  return err instanceof ValidationError\n}\n\nfunction errMessage(err: unknown): string {\n  if (err instanceof Error) return err.message\n  return String(err)\n}\n","/**\n * @experimental\n *\n * The generic combinator library — the content-free act-bodies the wave's §1 contract froze.\n *\n * Each export is a `CombinatorShape<Task, D>` (an alias of `LoopShape<Task, D>`): a factory\n * `(ShapeContext) => Agent<Task, Outcome<D>>` whose `act` runs ONE composition shape over the\n * keystone `Scope` — spawn children through `ctx.spawnChild` + `scope.spawn`, drain settlements\n * via `scope.next()`, select across `done` children with the SINGLE-SOURCED `settledToIteration`\n * + `defaultSelectWinner` (selector≠judge — never a re-rank behind the driver), and synthesize a\n * terminal `Outcome<D>`.\n *\n * The shapes carry NO domain: a \"research sweep over angles\" is `fanout(angles, { synthesize })`\n * under a research persona; a \"code build test\" is `pipeline([plan, implement, integrate])` under\n * a coder persona. The SHAPE is here; the model/prompt/role/goal live on the `Persona` + task,\n * threaded to each child verbatim by the spec-objects the builders take. No model name, prompt,\n * role, or domain noun appears below.\n *\n * Two fail-loud invariants every combinator honors: a child the conserved pool cannot admit is a\n * CONCRETE blocker (never an eager over-fan, never a silent drop), and a `blocked` outcome always\n * names at least one blocker (a shape that cannot finish MUST say why — `blocked([])` throws).\n */\n\nimport { ValidationError } from '../../errors'\nimport { defaultSelectWinner } from '../run-loop'\nimport { settledToIteration } from '../supervise/scope'\nimport type { Agent, Scope, Settled } from '../supervise/types'\nimport type { Iteration } from '../types'\nimport type { Outcome, ShapeContext } from './types'\nimport type {\n  CombinatorShape,\n  FanoutOptions,\n  LoopUntilSpec,\n  LoopUntilState,\n  PanelJudge,\n  PanelSpec,\n  PanelVerdict,\n  PipelineStage,\n  ScopeWidenGate,\n  VerifySpec,\n  WidenDecision,\n  WidenSpec,\n} from './wave-types'\n\n// ── pipeline — sequential composition, first blocked stage short-circuits ─────────\n\n/**\n * `pipeline(stages)` — run the stages in order, feeding each stage's `done` deliverable into the\n * next stage's task. The first stage that ends `blocked` (a child that went down, a child the\n * pool would not admit, or a stage whose `collect` chose to block) short-circuits — its blockers\n * ARE the pipeline's blockers, never coerced past a failed stage. The terminal stage's `done`\n * deliverable is the pipeline's deliverable.\n */\nexport function pipeline<Task, D>(\n  stages: ReadonlyArray<PipelineStage<Task, unknown, unknown>>,\n): CombinatorShape<Task, D> {\n  if (stages.length === 0) {\n    throw new ValidationError('pipeline: at least one stage is required')\n  }\n  return (ctx: ShapeContext<D>): Agent<Task, Outcome<D>> => ({\n    name: `${ctx.persona.name}/pipeline`,\n    async act(task, scope): Promise<Outcome<D>> {\n      let carry: unknown = task\n      for (const stage of stages) {\n        const child = ctx.spawnChild(stage.label, ctx.persona.root)\n        const res = scope.spawn(child, stage.feed(carry, ctx, task), {\n          budget: ctx.budget.perChild,\n          label: stage.label,\n        })\n        if (!res.ok) {\n          return blocked([`${stage.label}: not admitted (${res.reason})`])\n        }\n        const settled = await drainOne(scope, stage.label)\n        const out = stage.collect(settled as Settled<Outcome<unknown>>)\n        if (out.kind === 'blocked') return out\n        carry = out.deliverable\n      }\n      return { kind: 'done', deliverable: carry as D }\n    },\n  })\n}\n\n// ── fanout — N children in one round, optional single synthesis child ─────────────\n\n/**\n * `fanout(items, opts)` — spawn one child per item in a single round (bounded by the conserved\n * pool's fail-closed admission), drain via `scope.next()`, then either synthesize over the\n * gathered settlements (one SEPARATE synthesis child) or return the best-valid child via the\n * single-sourced selector. A round that admitted zero children, or whose synthesis child could\n * not be admitted, is a concrete blocker.\n */\nexport function fanout<Task, Item, D>(\n  items: ReadonlyArray<Item>,\n  opts: FanoutOptions<Item, D>,\n): CombinatorShape<Task, D> {\n  return (ctx: ShapeContext<D>): Agent<Task, Outcome<D>> => ({\n    name: `${ctx.persona.name}/fanout`,\n    async act(_task, scope): Promise<Outcome<D>> {\n      const rejected: string[] = []\n      let opened = 0\n      for (const [i, item] of items.entries()) {\n        const label = opts.label ? opts.label(item, i) : `item:${i}`\n        const child = ctx.spawnChild(label, ctx.persona.root)\n        const res = scope.spawn(child, opts.itemTask(item, i, ctx), {\n          budget: ctx.budget.perChild,\n          label,\n        })\n        if (res.ok) opened += 1\n        else rejected.push(`${label}: not admitted (${res.reason})`)\n      }\n      if (opened === 0) {\n        return blocked(\n          rejected.length > 0\n            ? rejected\n            : ['fanout: budget admitted no item (fanout fully rejected)'],\n        )\n      }\n\n      const drained = await drain<D>(scope)\n      if (drained.done.length === 0) {\n        return blocked(\n          orderedBlockers(\n            drained.blockers,\n            rejected,\n            'fanout: every item settled without a usable result',\n          ),\n        )\n      }\n\n      if (!opts.synthesize) {\n        const winner = defaultSelectWinner(drained.iterations)\n        if (!winner || winner.output === undefined) {\n          return blocked(\n            orderedBlockers(drained.blockers, rejected, 'fanout: no item survived selection'),\n          )\n        }\n        return { kind: 'done', deliverable: winner.output as D }\n      }\n\n      const synthLabel = 'synthesize'\n      const synthChild = ctx.spawnChild(synthLabel, ctx.persona.root)\n      const synthRes = scope.spawn(synthChild, opts.synthesize.synthesisTask(drained.done, ctx), {\n        budget: ctx.budget.perChild,\n        label: synthLabel,\n      })\n      if (!synthRes.ok) {\n        return blocked([...drained.blockers, `${synthLabel}: not admitted (${synthRes.reason})`])\n      }\n      const synthSettled = await drainOne(scope, synthLabel)\n      const out = opts.synthesize.collect(synthSettled)\n      if (out.kind === 'blocked') return out\n      return out\n    },\n  })\n}\n\n// ── loopUntil — budget-bounded iterative deepening, deployable non-oracle stop ────\n\n/**\n * `loopUntil(seed, spec)` — one `step` child per round; `fold` accumulates each settlement into\n * the running state; `until` (reading the round's trace findings, NOT a fresh raw verdict) is\n * the deployable stop. The conserved pool IS the loop bound: once `spawn` fails closed the loop\n * stops. A loop that exhausted the pool without `until` ever satisfying is a concrete blocker.\n *\n * Findings are threaded through the `SteerContext` firewall in the analyst seam (`analyst.ts`);\n * absent a wired analyst on this surface the firewall stays dormant and `until` is consulted with\n * an empty findings array — never a fabricated finding (fail-loud honesty over a silent default).\n */\nexport function loopUntil<Task, State, D>(\n  seed: State,\n  spec: LoopUntilSpec<Task, State, D>,\n): CombinatorShape<Task, D> {\n  return (ctx: ShapeContext<D>): Agent<Task, Outcome<D>> => ({\n    name: `${ctx.persona.name}/loopUntil`,\n    async act(task, scope): Promise<Outcome<D>> {\n      let state: LoopUntilState<State> = { round: 0, value: seed }\n      const blockers: string[] = []\n      for (;;) {\n        const label = spec.label ? spec.label(state.round) : `step:${state.round}`\n        const child = ctx.spawnChild(label, ctx.persona.root)\n        const res = scope.spawn(child, spec.step(task, state, ctx), {\n          budget: ctx.budget.perChild,\n          label,\n        })\n        if (!res.ok) {\n          if (state.round === 0) return blocked([`${label}: not admitted (${res.reason})`])\n          break\n        }\n        const settled = await drainOne(scope, label)\n        if (settled.kind === 'down') blockers.push(blockerFromDown(settled))\n        state = spec.fold(state, settled)\n        const reached = spec.until(state, [])\n        if (reached) return reached\n        state = { round: state.round + 1, value: state.value }\n      }\n      return blocked(\n        blockers.length > 0\n          ? blockers\n          : ['loopUntil: budget exhausted before the satisfiability gate was reached'],\n      )\n    },\n  })\n}\n\n// ── panel — M judges over ONE artifact, write-only merge (selector≠judge limit) ───\n\n/**\n * `panel(spec)` — spawn the M judge children over the SAME artifact, drain their settlements,\n * and fold them into a panel verdict via the pure WRITE-ONLY `merge` (a judge's output never\n * reaches another judge's task; the merge never spawns or re-ranks). A `down` judge carries no\n * verdict and is excluded from the merge denominator. A panel that admitted no judge is a\n * concrete blocker before `merge` is consulted.\n */\nexport function panel<Task, Artifact, D>(spec: PanelSpec<Artifact, D>): CombinatorShape<Task, D> {\n  if (spec.judges.length === 0) {\n    throw new ValidationError('panel: at least one judge is required')\n  }\n  return (ctx: ShapeContext<D>): Agent<Task, Outcome<D>> => ({\n    name: `${ctx.persona.name}/panel`,\n    async act(task, scope): Promise<Outcome<D>> {\n      const artifact = task as unknown as Artifact\n      const byLabel = new Map<string, PanelJudge>()\n      const rejected: string[] = []\n      let opened = 0\n      for (const judge of spec.judges) {\n        const child = ctx.spawnChild(judge.label, ctx.persona.root)\n        const res = scope.spawn(child, spec.judgeTask(artifact, judge, ctx), {\n          budget: ctx.budget.perChild,\n          label: judge.label,\n        })\n        if (res.ok) {\n          byLabel.set(judge.label, judge)\n          opened += 1\n        } else {\n          rejected.push(`${judge.label}: not admitted (${res.reason})`)\n        }\n      }\n      if (opened === 0) {\n        return blocked(rejected.length > 0 ? rejected : ['panel: budget admitted no judge'])\n      }\n\n      const verdicts: PanelVerdict[] = []\n      for (let s = await scope.next(); s !== null; s = await scope.next()) {\n        const judge = byLabel.get(s.handle.label)\n        if (!judge) {\n          throw new ValidationError(\n            `panel: settled child \"${s.handle.label}\" has no judge descriptor`,\n          )\n        }\n        if (s.kind === 'down') {\n          verdicts.push({ judge, down: true })\n          continue\n        }\n        verdicts.push({\n          judge,\n          down: false,\n          ...(s.verdict ? { verdict: s.verdict } : {}),\n          output: s.out,\n        })\n      }\n      return spec.merge(verdicts, artifact)\n    },\n  })\n}\n\n// ── verify — 2-node implement→verifier gate (selector≠judge) ──────────────────────\n\n/**\n * `verify(spec)` — an IMPLEMENT child produces a candidate, then a SEPARATE VERIFIER child grades\n * it; only a `valid` verifier verdict ships. Any other outcome (implement down, verifier down,\n * verifier verdict absent or not `valid`) is a concrete blocker carrying the failure verbatim —\n * never a coerced \"done\". The implement child does not grade itself.\n */\nexport function verify<Task, Candidate, D>(\n  spec: VerifySpec<Task, Candidate, D>,\n): CombinatorShape<Task, D> {\n  return (ctx: ShapeContext<D>): Agent<Task, Outcome<D>> => ({\n    name: `${ctx.persona.name}/verify`,\n    async act(task, scope): Promise<Outcome<D>> {\n      const implementLabel = spec.implementLabel ?? 'implement'\n      const implChild = ctx.spawnChild(implementLabel, ctx.persona.root)\n      const implRes = scope.spawn(implChild, spec.implement(task, ctx), {\n        budget: ctx.budget.perChild,\n        label: implementLabel,\n      })\n      if (!implRes.ok) return blocked([`${implementLabel}: not admitted (${implRes.reason})`])\n      const candidate = await drainOne(scope, implementLabel)\n      if (candidate.kind === 'down') return blocked([blockerFromDown(candidate)])\n\n      const verifierLabel = spec.verifierLabel ?? 'verify'\n      const verifierChild = ctx.spawnChild(verifierLabel, ctx.persona.root)\n      const verifierRes = scope.spawn(\n        verifierChild,\n        spec.verifier(candidate as Settled<Outcome<Candidate>>, ctx),\n        { budget: ctx.budget.perChild, label: verifierLabel },\n      )\n      if (!verifierRes.ok)\n        return blocked([`${verifierLabel}: not admitted (${verifierRes.reason})`])\n      const gate = await drainOne(scope, verifierLabel)\n      if (gate.kind === 'down') return blocked([blockerFromDown(gate)])\n      if (!gate.verdict || gate.verdict.valid !== true) {\n        return blocked([`${verifierLabel}: gate rejected the candidate (${verdictDetail(gate)})`])\n      }\n      return spec.collect(candidate as Settled<Outcome<Candidate>>, gate.verdict)\n    },\n  })\n}\n\n// ── widen — streaming progressive widening (G5), FLAT by default ──────────────────\n\n/**\n * `widen(spec)` — the streaming spawn-on-completion driver. Spawns the seed lineages, then REACTS\n * to each `scope.next()`: on every settled child it consults `spec.gate.decide` and, when the gate\n * returns `widen`, spawns AT MOST ONE more child toward the chosen lineage under the remaining\n * conserved pool. `promising` is derived from the round's trace findings (the analyst seam),\n * never a child's raw `verdict` — and the default gate (`flatWidenGate`) never widens, so the R2\n * firewall stays dormant. Terminal selection is `spec.synthesize` over every settled lineage.\n *\n * No analyst is wired on this frozen surface, so `decide` is consulted with an empty findings\n * array; a flat gate ignores it. A non-flat gate that wants findings reads them through the\n * `SteerContext` firewall the analyst seam owns — never fabricated here.\n */\nexport function widen<Task, Seed, D>(spec: WidenSpec<Seed, D>): CombinatorShape<Task, D> {\n  return (ctx: ShapeContext<D>): Agent<Task, Outcome<D>> => ({\n    name: `${ctx.persona.name}/widen`,\n    async act(_task, scope): Promise<Outcome<D>> {\n      let opened = 0\n      for (const [i, seed] of spec.seeds.entries()) {\n        const label = `seed:${i}`\n        const child = ctx.spawnChild(label, ctx.persona.root)\n        const res = scope.spawn(child, spec.seedTask(seed, i, ctx), {\n          budget: ctx.budget.perChild,\n          label,\n        })\n        if (res.ok) opened += 1\n      }\n      if (opened === 0) {\n        return blocked(['widen: budget admitted no seed lineage'])\n      }\n\n      const gathered: Settled<Outcome<D>>[] = []\n      let widenIndex = 0\n      for (let s = await scope.next(); s !== null; s = await scope.next()) {\n        gathered.push(s)\n        const decision: WidenDecision<D> = spec.gate.decide(s, [], scope.budget)\n        if (decision.kind !== 'widen') continue\n        const label = `widen:${widenIndex}`\n        widenIndex += 1\n        const child = ctx.spawnChild(label, ctx.persona.root)\n        // Fail-closed admission bounds the widening — a rejected widen is simply not opened\n        // (the gate may widen again off a later settlement); the budget is the breadth bound.\n        scope.spawn(child, spec.widenTask(decision.toward, ctx), {\n          budget: ctx.budget.perChild,\n          label,\n        })\n      }\n\n      const done = gathered.filter(isDone)\n      if (done.length === 0) {\n        return blocked(\n          orderedBlockers(\n            gathered.filter(isDown).map(blockerFromDown),\n            [],\n            'widen: every lineage settled without a usable result',\n          ),\n        )\n      }\n      return spec.synthesize(done, ctx)\n    },\n  })\n}\n\n/**\n * The flat default `ScopeWidenGate` — never widens, keeping the R2 selector≠judge collision\n * dormant. A gate run passes this explicitly; a test asserts the default is flat.\n */\nexport function flatWidenGate<D>(): ScopeWidenGate<D> {\n  return {\n    decide(): WidenDecision<D> {\n      return { kind: 'stop' }\n    },\n  }\n}\n\n// ── Shared drain / select / blocker microstructure ────────────────────────────────\n\n/** Drain every remaining settlement: project `done` children into kernel `Iteration`s for the\n *  single-sourced selector + keep the `done` settlements (for a synthesis child), and collect\n *  `down` children as concrete blockers (their reason surfaced verbatim). */\nasync function drain<D>(scope: Scope<Outcome<D>>): Promise<{\n  iterations: Iteration<unknown, Outcome<D>>[]\n  done: Settled<Outcome<D>>[]\n  blockers: string[]\n}> {\n  const iterations: Iteration<unknown, Outcome<D>>[] = []\n  const done: Settled<Outcome<D>>[] = []\n  const blockers: string[] = []\n  for (let s = await scope.next(); s !== null; s = await scope.next()) {\n    if (s.kind === 'down') {\n      blockers.push(blockerFromDown(s))\n      continue\n    }\n    iterations.push(settledToIteration(s))\n    done.push(s)\n  }\n  return { iterations, done, blockers }\n}\n\n/**\n * Drain exactly one settlement off a scope whose prior children are fully drained, so `next()`\n * yields precisely the child just spawned. Fail loud if it yields nothing — a spawned child that\n * never settles is a keystone invariant violation, not a result the combinator may swallow.\n */\nasync function drainOne<D>(scope: Scope<Outcome<D>>, label: string): Promise<Settled<Outcome<D>>> {\n  const s = await scope.next()\n  if (s === null) {\n    throw new ValidationError(`combinator: child \"${label}\" was spawned but never settled`)\n  }\n  return s\n}\n\nfunction isDone<D>(s: Settled<Outcome<D>>): s is Extract<Settled<Outcome<D>>, { kind: 'done' }> {\n  return s.kind === 'done'\n}\n\nfunction isDown<D>(s: Settled<Outcome<D>>): s is Extract<Settled<Outcome<D>>, { kind: 'down' }> {\n  return s.kind === 'down'\n}\n\nfunction blockerFromDown<D>(s: Extract<Settled<Outcome<D>>, { kind: 'down' }>): string {\n  return `${s.handle.label}: ${s.infra ? 'infra' : 'failed'} — ${s.reason}`\n}\n\nfunction verdictDetail<D>(s: Extract<Settled<Outcome<D>>, { kind: 'done' }>): string {\n  if (!s.verdict) return 'no verdict'\n  return s.verdict.notes ?? `score ${s.verdict.score}`\n}\n\n/** Compose the round's drained blockers + rejected-admission reasons, falling back to a named\n *  default ONLY when neither produced a reason — a `blocked` outcome must never be vacuous. */\nfunction orderedBlockers(drained: string[], rejected: string[], fallback: string): string[] {\n  const all = [...drained, ...rejected]\n  return all.length > 0 ? all : [fallback]\n}\n\n/** Build a `blocked` outcome, failing loud on the empty-blocker contract violation (a shape that\n *  cannot finish MUST name at least one concrete blocker — never a vacuous block). */\nfunction blocked<D>(blockers: string[]): Extract<Outcome<D>, { kind: 'blocked' }> {\n  if (blockers.length === 0) {\n    throw new ValidationError('combinator: a blocked outcome must name at least one blocker')\n  }\n  return { kind: 'blocked', blockers }\n}\n","/**\n * @experimental\n *\n * The cross-run corpus (G2) — the learning-flywheel's durable accreted-fact store.\n *\n * `Corpus` is DISTINCT from the per-run `SpawnJournal` (decisions/replay) and `ResultBlobStore`\n * (payloads): a `CorpusRecord` is a FACT one run LEARNED that a FUTURE run reads back (the\n * world-model), not a replay input. This module owns the two impls the wave surface pins —\n * `InMemoryCorpus` and `FileCorpus` (JSONL, append-only) — plus `renderCorpusToInstructions`,\n * the READ side that projects accreted facts into a fresh `AgentProfile`'s instruction seams.\n *\n * The boundary is fail-loud, typed-outcome: `append` is idempotent on an identical record and\n * returns a typed error (never throws, never a silent overwrite) on a conflicting re-append under\n * the same `id`. Malformed records — a structurally-invalid `CorpusRecord` from disk or a caller —\n * fail loud (the validator throws), since a corpus that silently accepts garbage would poison\n * every downstream run that reads it back.\n */\n\nimport type { AgentProfile } from '@tangle-network/sandbox'\nimport type {\n  Corpus,\n  CorpusFilter,\n  CorpusRecord,\n  RenderCorpusToInstructionsOptions,\n} from './wave-types'\n\n// ── Record validation ────────────────────────────────────────────────────────\n\nconst corpusSchemaVersion = '1.0.0'\n\n/**\n * Assert a value is a well-formed `CorpusRecord`. A PROVENANCE-and-shape check: every\n * identity/render-gating field must be present and typed, `confidence` must be a finite 0..1,\n * `evidence` (when present) must be `{ kind, uri }[]`. Throws on any violation — a corpus that\n * silently accepted a malformed fact would project garbage into a future run's prompt. The\n * thrown message names the offending field so a bad on-disk line is diagnosable.\n */\nexport function assertCorpusRecord(value: unknown, where: string): asserts value is CorpusRecord {\n  if (typeof value !== 'object' || value === null) {\n    throw new Error(`${where}: corpus record is not an object`)\n  }\n  const r = value as Record<string, unknown>\n  if (r.schemaVersion !== corpusSchemaVersion) {\n    throw new Error(\n      `${where}: corpus record schemaVersion '${String(r.schemaVersion)}' != '${corpusSchemaVersion}'`,\n    )\n  }\n  requireNonEmptyString(r.id, `${where}.id`)\n  requireNonEmptyString(r.runId, `${where}.runId`)\n  requireNonEmptyString(r.producedAt, `${where}.producedAt`)\n  requireNonEmptyString(r.area, `${where}.area`)\n  requireNonEmptyString(r.claim, `${where}.claim`)\n  if (r.rationale !== undefined && typeof r.rationale !== 'string') {\n    throw new Error(`${where}.rationale: expected string, got ${typeof r.rationale}`)\n  }\n  if (!Array.isArray(r.tags) || r.tags.some((t) => typeof t !== 'string')) {\n    throw new Error(`${where}.tags: expected string[]`)\n  }\n  if (typeof r.confidence !== 'number' || !Number.isFinite(r.confidence)) {\n    throw new Error(`${where}.confidence: expected a finite number, got ${String(r.confidence)}`)\n  }\n  if (r.confidence < 0 || r.confidence > 1) {\n    throw new Error(`${where}.confidence: ${r.confidence} is outside the [0, 1] range`)\n  }\n  if (r.evidence !== undefined) {\n    if (!Array.isArray(r.evidence)) {\n      throw new Error(`${where}.evidence: expected an array`)\n    }\n    for (let i = 0; i < r.evidence.length; i++) {\n      const ev = r.evidence[i] as Record<string, unknown> | null\n      if (typeof ev !== 'object' || ev === null) {\n        throw new Error(`${where}.evidence[${i}]: not an object`)\n      }\n      requireNonEmptyString(ev.kind, `${where}.evidence[${i}].kind`)\n      requireNonEmptyString(ev.uri, `${where}.evidence[${i}].uri`)\n    }\n  }\n}\n\nfunction requireNonEmptyString(value: unknown, where: string): void {\n  if (typeof value !== 'string' || value.length === 0) {\n    throw new Error(`${where}: expected a non-empty string, got ${describe(value)}`)\n  }\n}\n\nfunction describe(value: unknown): string {\n  if (value === undefined) return 'undefined'\n  if (value === null) return 'null'\n  if (typeof value === 'string') return `'${value}'`\n  return typeof value\n}\n\n// ── Identity + idempotence ───────────────────────────────────────────────────\n\n/**\n * Two records collide IFF they share an `id`. An append under an already-stored `id` is idempotent\n * only when the new record is byte-identical to the stored one (same fact, re-learned); any other\n * field differing under the same `id` is a CONFLICT — a typed-error append, never a silent\n * overwrite. The identity field is `id`; the producer mints it over its identity-defining fields\n * (claim + tags) so a re-learned fact dedups.\n */\nfunction recordsEqual(a: CorpusRecord, b: CorpusRecord): boolean {\n  return stableStringify(a) === stableStringify(b)\n}\n\nfunction stableStringify(value: unknown): string {\n  if (value === null || typeof value !== 'object') return JSON.stringify(value) ?? 'null'\n  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`\n  const entries = Object.entries(value as Record<string, unknown>)\n    .filter(([, v]) => v !== undefined)\n    .sort(([x], [y]) => (x < y ? -1 : x > y ? 1 : 0))\n  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(',')}}`\n}\n\n// ── Query ─────────────────────────────────────────────────────────────────────\n\n/**\n * Apply a `CorpusFilter` as an AND-narrowing over a record list and sort most-confident first\n * (ties → most-recent `producedAt`, so the freshest of two equally-confident facts wins). Pure —\n * the in-mem and file impls both route their reads through this so query semantics are\n * single-sourced. An empty result is valid (not an error).\n */\nfunction applyFilter(\n  records: ReadonlyArray<CorpusRecord>,\n  filter: CorpusFilter,\n): ReadonlyArray<CorpusRecord> {\n  const matched = records.filter((r) => {\n    if (filter.area !== undefined && r.area !== filter.area) return false\n    if (filter.runId !== undefined && r.runId !== filter.runId) return false\n    if (filter.minConfidence !== undefined && r.confidence < filter.minConfidence) return false\n    if (filter.tags !== undefined && !filter.tags.every((t) => r.tags.includes(t))) return false\n    return true\n  })\n  const ordered = [...matched].sort((a, b) =>\n    b.confidence !== a.confidence\n      ? b.confidence - a.confidence\n      : b.producedAt < a.producedAt\n        ? -1\n        : b.producedAt > a.producedAt\n          ? 1\n          : 0,\n  )\n  if (filter.limit !== undefined) {\n    if (!Number.isInteger(filter.limit) || filter.limit < 0) {\n      throw new Error(\n        `corpus query: filter.limit must be a non-negative integer, got ${filter.limit}`,\n      )\n    }\n    return ordered.slice(0, filter.limit)\n  }\n  return ordered\n}\n\n// ── In-memory corpus ────────────────────────────────────────────────────────\n\n/**\n * In-memory `Corpus`. Keyed by record `id`; `append` validates the record, is idempotent on an\n * identical re-append, and returns a typed `{ succeeded: false }` on a conflicting re-append under\n * the same `id` (never overwrites). `query` routes through the single-sourced `applyFilter`.\n */\nexport class InMemoryCorpus implements Corpus {\n  private readonly byId = new Map<string, CorpusRecord>()\n\n  async append(\n    record: CorpusRecord,\n  ): Promise<{ succeeded: true } | { succeeded: false; error: string }> {\n    try {\n      assertCorpusRecord(record, 'append: record')\n    } catch (err) {\n      return { succeeded: false, error: err instanceof Error ? err.message : String(err) }\n    }\n    const existing = this.byId.get(record.id)\n    if (existing) {\n      if (recordsEqual(existing, record)) return { succeeded: true }\n      return {\n        succeeded: false,\n        error:\n          `corpus conflict: id '${record.id}' is already stored with a different record; ` +\n          'a learned fact is append-only — re-mint the id or reconcile before re-appending',\n      }\n    }\n    this.byId.set(record.id, freeze(record))\n    return { succeeded: true }\n  }\n\n  async query(filter: CorpusFilter): Promise<ReadonlyArray<CorpusRecord>> {\n    return applyFilter([...this.byId.values()], filter)\n  }\n}\n\n// ── File corpus (JSONL, append-only) ──────────────────────────────────────────\n\n/**\n * JSONL on disk — one validated `CorpusRecord` per line, append-only. `query` replays the whole\n * file, validating every line (a malformed line fails loud — a corrupted corpus must never read\n * back silently) and folding by `id`: a later identical line dedups, a later conflicting line\n * under the same `id` is a corruption (fail loud). `append` first replays to enforce the same\n * idempotence/conflict contract as the in-mem impl, then fsyncs the new line so a crash between\n * writes never loses an acknowledged fact. Shares the JSONL append-line spine with the spawn\n * journal, but the interface stays separate (a learned fact is not a replay record).\n */\nexport class FileCorpus implements Corpus {\n  constructor(private readonly path: string) {}\n\n  async append(\n    record: CorpusRecord,\n  ): Promise<{ succeeded: true } | { succeeded: false; error: string }> {\n    try {\n      assertCorpusRecord(record, 'append: record')\n    } catch (err) {\n      return { succeeded: false, error: err instanceof Error ? err.message : String(err) }\n    }\n    let stored: Map<string, CorpusRecord>\n    try {\n      stored = await this.load()\n    } catch (err) {\n      return { succeeded: false, error: err instanceof Error ? err.message : String(err) }\n    }\n    const existing = stored.get(record.id)\n    if (existing) {\n      if (recordsEqual(existing, record)) return { succeeded: true }\n      return {\n        succeeded: false,\n        error:\n          `corpus conflict: id '${record.id}' is already stored in ${this.path} with a different ` +\n          'record; a learned fact is append-only — re-mint the id or reconcile before re-appending',\n      }\n    }\n    await this.appendLine(record)\n    return { succeeded: true }\n  }\n\n  async query(filter: CorpusFilter): Promise<ReadonlyArray<CorpusRecord>> {\n    const stored = await this.load()\n    return applyFilter([...stored.values()], filter)\n  }\n\n  private async load(): Promise<Map<string, CorpusRecord>> {\n    const fs = await import('node:fs/promises')\n    let text: string\n    try {\n      text = await fs.readFile(this.path, 'utf8')\n    } catch (err) {\n      if (isNoEntError(err)) return new Map()\n      throw err\n    }\n    const lines = text.split('\\n').filter((line) => line.length > 0)\n    const byId = new Map<string, CorpusRecord>()\n    for (let i = 0; i < lines.length; i++) {\n      const line = lines[i] as string\n      let parsed: unknown\n      try {\n        parsed = JSON.parse(line)\n      } catch (err) {\n        throw new Error(\n          `corpus corrupted: ${this.path} line ${i + 1} is not valid JSON: ` +\n            (err instanceof Error ? err.message : String(err)),\n        )\n      }\n      assertCorpusRecord(parsed, `corpus ${this.path} line ${i + 1}`)\n      const existing = byId.get(parsed.id)\n      if (existing && !recordsEqual(existing, parsed)) {\n        throw new Error(\n          `corpus corrupted: ${this.path} has two different records for id '${parsed.id}'; ` +\n            'an append-only corpus must never hold a conflicting re-append under one id',\n        )\n      }\n      byId.set(parsed.id, freeze(parsed))\n    }\n    return byId\n  }\n\n  private async appendLine(record: CorpusRecord): Promise<void> {\n    const fs = await import('node:fs/promises')\n    const path = await import('node:path')\n    await fs.mkdir(path.dirname(this.path), { recursive: true })\n    const fh = await fs.open(this.path, 'a')\n    try {\n      await fh.write(`${JSON.stringify(record)}\\n`)\n      await fh.sync()\n    } finally {\n      await fh.close()\n    }\n  }\n}\n\n// ── Render-back: project accreted facts into a profile's instruction seams ─────\n\n/**\n * The learning-flywheel READ side. Queries the corpus through `filter`, renders the matching facts\n * (most-confident first, capped by `maxLines`) into instruction lines, and returns a FRESH\n * `AgentProfile` with them merged in — never mutates the input profile. Default `target: 'prompt'`\n * appends the lines to `prompt.instructions[]` (the additive append-line seam); `target:\n * 'resources'` folds them into the single-blob `resources.instructions` string (preserving any\n * existing blob, but failing loud on a non-string existing blob — a `resources.instructions` that\n * was already an `AgentProfileResourceRef` cannot be string-appended without dropping it).\n *\n * An empty query result returns a fresh COPY of the profile with no instruction change (a valid\n * \"nothing learned yet\" read, not an error).\n */\nexport async function renderCorpusToInstructions(\n  opts: RenderCorpusToInstructionsOptions,\n): Promise<AgentProfile> {\n  const { corpus, filter, profile, target = 'prompt', maxLines } = opts\n  if (maxLines !== undefined && (!Number.isInteger(maxLines) || maxLines < 0)) {\n    throw new Error(\n      `renderCorpusToInstructions: maxLines must be a non-negative integer, got ${maxLines}`,\n    )\n  }\n  const matched = await corpus.query(filter)\n  const capped = maxLines !== undefined ? matched.slice(0, maxLines) : matched\n  const lines = capped.map(renderLine)\n\n  if (lines.length === 0) return structuredClone(profile)\n\n  const next = structuredClone(profile)\n  if (target === 'resources') {\n    const resources = next.resources ?? {}\n    const prior = resources.instructions\n    if (prior !== undefined && typeof prior !== 'string') {\n      throw new Error(\n        'renderCorpusToInstructions: resources.instructions is an AgentProfileResourceRef, not a ' +\n          'string; cannot string-append corpus facts without dropping the ref (pass target: ' +\n          \"'prompt' or pre-resolve the ref)\",\n      )\n    }\n    const blob = [prior, ...lines].filter((s): s is string => typeof s === 'string' && s.length > 0)\n    next.resources = { ...resources, instructions: blob.join('\\n') }\n    return next\n  }\n\n  const prompt = next.prompt ?? {}\n  next.prompt = { ...prompt, instructions: [...(prompt.instructions ?? []), ...lines] }\n  return next\n}\n\n/** One corpus fact → one instruction line. The claim is the line; a rationale (when present) is\n *  appended in parentheses so a reader sees the why without a second line. Content-only — no\n *  metric/score/verdict text is synthesized (the corpus holds facts, not selector evidence). */\nfunction renderLine(record: CorpusRecord): string {\n  return record.rationale ? `${record.claim} (${record.rationale})` : record.claim\n}\n\n// ── Internal helpers ───────────────────────────────────────────────────────────\n\nfunction freeze(record: CorpusRecord): CorpusRecord {\n  return Object.freeze({ ...record })\n}\n\nfunction isNoEntError(err: unknown): boolean {\n  return (\n    typeof err === 'object' &&\n    err !== null &&\n    'code' in err &&\n    (err as { code: unknown }).code === 'ENOENT'\n  )\n}\n","/**\n * @experimental\n *\n * The leaf runtime — the built-in `Executor` IMPLEMENTATIONS behind the ONE\n * open interface frozen in `./types`, plus the open resolver/registry that maps\n * an `AgentSpec` to one of them OR accepts a bring-your-own executor verbatim.\n *\n * The interface is the extension point, not a closed `inline|sandbox|cli` union:\n *   - router/inline : a direct OpenAI-compatible Router call, no box (one-shot).\n *   - sandbox       : COMPOSES the existing `runLoop` kernel as a single-task\n *                     leaf and surfaces its token/cost usage as `UsageEvent`s;\n *                     forwards PR #150's optional `lineage` passthrough WITHOUT\n *                     reinventing checkpoint/fork (streaming).\n *   - cli           : a Halo/RLM subprocess; `budgetExempt` (no token accounting),\n *                     excluded from the equal-k arms by construction (streaming).\n * Every metered runtime reports through the SAME normalized `UsageEvent` channel\n * so the conserved budget pool meters them identically. A user's own agent is\n * first-class the moment it implements `Executor` — register it by name or\n * pass it as `AgentSpec.executor`.\n *\n * Layering: `estimateCost`/`isModelPriced` are substrate primitives from\n * `@tangle-network/agent-eval`; `runLoop`/`acquireSandbox` are runtime kernels\n * from this package. No per-vendor adapters live here.\n */\n\nimport { spawn } from 'node:child_process'\nimport { estimateCost, isModelPriced } from '@tangle-network/agent-eval'\nimport type { BackendType, SandboxEvent } from '@tangle-network/sandbox'\nimport { ValidationError } from '../../errors'\nimport { routerChatWithUsage, type ToolSpec } from '../router-client'\nimport type { RunLoopOptions } from '../run-loop'\nimport { runLoop } from '../run-loop'\nimport type {\n  AgentRunSpec,\n  Driver,\n  ExecCtx,\n  Iteration,\n  OutputAdapter,\n  SandboxClient,\n} from '../types'\nimport { zeroTokenUsage } from '../util'\nimport type {\n  AgentSpec,\n  DefaultVerdict,\n  Executor,\n  ExecutorContext,\n  ExecutorFactory,\n  ExecutorRegistry,\n  ExecutorResult,\n  Runtime,\n  Spend,\n  UsageEvent,\n} from './types'\n\n// ── Seam contracts (read off ExecutorContext.seams, narrowed per built-in) ─────\n\n/**\n * Router/inline connection seam. A direct OpenAI-compatible Router endpoint —\n * the cheapest leaf, no box, no tools. `model` overrides the profile's model\n * hint when present; otherwise the profile's `model.default` is required.\n */\nexport interface RouterSeam {\n  routerBaseUrl: string\n  routerKey: string\n  model?: string\n}\n\n/**\n * Sandbox executor seam. The `sandboxClient` the composed `runLoop` creates\n * boxes through, plus the optional trace/run/lineage wiring forwarded into the\n * loop. `lineage` is opaque here (PR #150's `RunLoopOptions.lineage`): forwarded\n * forward-compatibly, never inspected — this executor does NOT reinvent\n * checkpoint/fork.\n */\nexport interface SandboxSeam {\n  sandboxClient: SandboxClient\n  /** Forwarded into the composed `runLoop`'s `ctx` (trace emitter, run handle, etc.). */\n  loopCtx?: Partial<Omit<ExecCtx, 'sandboxClient' | 'signal'>>\n  /** PR #150 `RunLoopOptions.lineage` passthrough — opaque; forwarded, not parsed. */\n  lineage?: unknown\n  /** Hard cap on the composed loop's iterations. The budget pool reserves against\n   *  the spawn `Budget.maxIterations`; this is the leaf's own ceiling. Default 1. */\n  maxIterations?: number\n}\n\n/** CLI subprocess seam. `bin` + `args` describe the Halo/RLM process to spawn. */\nexport interface CliSeam {\n  bin: string\n  args?: string[]\n  /** Extra environment for the subprocess (merged over `process.env`). */\n  env?: Record<string, string>\n  /** Working directory for the subprocess. */\n  cwd?: string\n}\n\n/**\n * cli-bridge seam. A local OpenAI-compatible bridge that fronts harness CLIs\n * (claude-code / opencode / kimi / pi) behind one HTTP surface; `model` doubles\n * as the harness selector (e.g. `claude-code/sonnet`, `opencode/<provider>/<model>`).\n * `agentProfile` is the bridge-dialect profile (metadata.disallowedTools, mcp)\n * forwarded verbatim per request — how an arm disables native tools or injects\n * a provider search MCP.\n */\nexport interface BridgeSeam {\n  bridgeUrl: string\n  bridgeBearer: string\n  model: string\n  agentProfile?: Record<string, unknown>\n  timeoutMs?: number\n}\n\nconst routerSeamKey = 'router'\nconst sandboxSeamKey = 'sandbox'\nconst cliSeamKey = 'cli'\nconst bridgeSeamKey = 'bridge'\n\n// ── Content-addressed result pointers (the B1 replay source) ───────────────────\n\n/** Deterministic content hash for an `outRef`. FNV-1a 32-bit over the canonical\n *  JSON of the result — not cryptographic, sufficient for content-addressing the\n *  replay blob so two identical outputs collapse to one pointer. */\nfunction contentRef(prefix: string, value: unknown): string {\n  let str: string\n  try {\n    str = JSON.stringify(value) ?? String(value)\n  } catch {\n    str = String(value)\n  }\n  let h = 0x811c9dc5\n  for (let i = 0; i < str.length; i += 1) {\n    h ^= str.charCodeAt(i)\n    h = Math.imul(h, 0x01000193)\n  }\n  return `${prefix}:${(h >>> 0).toString(16).padStart(8, '0')}`\n}\n\nfunction zeroSpend(): Spend {\n  return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 }\n}\n\n// ── router/inline executor (harness === null) ──────────────────────────────────\n\n/**\n * A direct OpenAI-compatible Router chat-completion. One-shot: resolves a\n * `ExecutorResult` and reports its terminal usage as `UsageEvent`s through the\n * conserved pool. Reports REAL token usage — when the provider omits `usage`,\n * the spend records zero tokens but the call still counts one iteration (a\n * phantom fabricated 0 is never emitted as a priced cost).\n *\n * Transport = `routerChatWithUsage` (`../router-client`): transient router\n * failures (429/5xx/Cloudflare-origin) retry with backoff before the executor\n * fails the task.\n */\nexport const routerInlineExecutor: ExecutorFactory<unknown> = (spec, ctx) => {\n  const seam = readSeam<RouterSeam>(ctx, routerSeamKey, 'router/inline')\n  const model = seam.model ?? spec.profile.model?.default\n  if (!model) {\n    throw new ValidationError(\n      'routerInlineExecutor: no model — set RouterSeam.model or AgentProfile.model.default',\n    )\n  }\n  if (!seam.routerBaseUrl || !seam.routerKey) {\n    throw new ValidationError('routerInlineExecutor: RouterSeam.routerBaseUrl + routerKey required')\n  }\n\n  const controller = new AbortController()\n  const abortIfSignalled = () => {\n    if (ctx.signal.aborted) controller.abort()\n  }\n  abortIfSignalled()\n  if (!ctx.signal.aborted) ctx.signal.addEventListener('abort', abortIfSignalled, { once: true })\n\n  let artifact: ExecutorResult<unknown> | undefined\n\n  return {\n    runtime: 'router' as Runtime,\n    async execute(task, signal): Promise<ExecutorResult<unknown>> {\n      const messages = taskToMessages(task, spec)\n      const started = Date.now()\n      const linked = linkSignals(signal, controller.signal)\n      const r = await routerChatWithUsage(\n        { routerBaseUrl: seam.routerBaseUrl, routerKey: seam.routerKey, model },\n        messages,\n        linked ? { signal: linked } : {},\n      )\n      const spent: Spend = {\n        iterations: 1,\n        tokens: r.usage ? { input: r.usage.input, output: r.usage.output } : zeroTokenUsage(),\n        usd: r.costUsd ?? 0,\n        ms: Date.now() - started,\n      }\n      const out = { content: r.content } as unknown\n      artifact = { outRef: contentRef('router', { model, content: r.content }), out, spent }\n      return artifact\n    },\n    teardown(_grace): Promise<{ destroyed: boolean }> {\n      controller.abort()\n      return Promise.resolve({ destroyed: true })\n    },\n    resultArtifact() {\n      if (!artifact) {\n        throw new ValidationError('routerInlineExecutor: resultArtifact() read before execute()')\n      }\n      return { ...artifact, spent: artifact.spent }\n    },\n  }\n}\n\nexport type { ToolSpec }\n\n/**\n * Router seam WITH tool use — the tool-using router backend. Same direct\n * OpenAI-compatible endpoint as `RouterSeam`, but each turn passes `tools`; when\n * the model emits tool_calls they run via `executeToolCall` ON THIS HOST and the\n * results fold back as `tool` messages, repeating until the model answers without\n * a tool or `maxTurns` is hit. A real agentic loop, OFF-BOX — no sandbox, so it\n * is unaffected by a box's egress allowlist. One turn = one completion = the\n * equal-compute unit. `executeToolCall` receives the task so per-task tool\n * surfaces (e.g. a gym keyed by task) can dispatch correctly.\n */\nexport interface RouterToolsSeam {\n  routerBaseUrl: string\n  routerKey: string\n  model?: string\n  tools: ReadonlyArray<ToolSpec>\n  executeToolCall: (name: string, args: Record<string, unknown>, task: unknown) => Promise<string>\n  /** Max inference turns. Default 200 (runaway backstop — set far above any\n   *  legitimate workflow). For tighter per-workflow limits use a cost budget\n   *  or wall-clock deadline at the call site. */\n  maxTurns?: number\n}\nconst routerToolsSeamKey = 'router-tools'\n\ninterface RouterToolsResponse {\n  choices?: Array<{\n    message?: {\n      content?: string | null\n      tool_calls?: Array<{ id?: string; function?: { name?: string; arguments?: string } }>\n    }\n  }>\n  usage?: { prompt_tokens?: number; completion_tokens?: number }\n}\n\n/**\n * The tool-using router executor. Drives the multi-turn tool loop the single-shot\n * `routerInlineExecutor` cannot express; same fail-loud + real-usage discipline.\n */\nexport const routerToolsInlineExecutor: ExecutorFactory<unknown> = (spec, ctx) => {\n  const seam = readSeam<RouterToolsSeam>(ctx, routerToolsSeamKey, 'router-tools')\n  const model = seam.model ?? spec.profile.model?.default\n  if (!model) {\n    throw new ValidationError(\n      'routerToolsInlineExecutor: no model — set RouterToolsSeam.model or AgentProfile.model.default',\n    )\n  }\n  if (!seam.routerBaseUrl || !seam.routerKey) {\n    throw new ValidationError(\n      'routerToolsInlineExecutor: RouterToolsSeam.routerBaseUrl + routerKey required',\n    )\n  }\n  const maxTurns = seam.maxTurns ?? 200\n\n  const controller = new AbortController()\n  const abortIfSignalled = () => {\n    if (ctx.signal.aborted) controller.abort()\n  }\n  abortIfSignalled()\n  if (!ctx.signal.aborted) ctx.signal.addEventListener('abort', abortIfSignalled, { once: true })\n\n  let artifact: ExecutorResult<unknown> | undefined\n\n  return {\n    runtime: 'router' as Runtime,\n    async execute(task, signal): Promise<ExecutorResult<unknown>> {\n      const started = Date.now()\n      const linked = linkSignals(signal, controller.signal)\n      const messages: Array<Record<string, unknown>> = [\n        ...(taskToMessages(task, spec) as Array<Record<string, unknown>>),\n      ]\n      const tokens = zeroTokenUsage()\n      let turns = 0\n      let lastText = ''\n\n      for (let t = 0; t < maxTurns; t += 1) {\n        turns += 1\n        const res = await fetch(`${seam.routerBaseUrl.replace(/\\/$/, '')}/chat/completions`, {\n          method: 'POST',\n          headers: {\n            'content-type': 'application/json',\n            authorization: `Bearer ${seam.routerKey}`,\n          },\n          body: JSON.stringify({\n            model,\n            messages,\n            tools: seam.tools,\n            tool_choice: 'auto',\n            temperature: 0.2,\n          }),\n          ...(linked ? { signal: linked } : {}),\n        })\n        if (!res.ok) {\n          throw new ValidationError(\n            `routerToolsInlineExecutor: router ${res.status}: ${(await res.text()).slice(0, 200)}`,\n          )\n        }\n        const data = (await res.json()) as RouterToolsResponse\n        const u = data.usage\n        if (u && typeof u.prompt_tokens === 'number' && typeof u.completion_tokens === 'number') {\n          tokens.input += u.prompt_tokens\n          tokens.output += u.completion_tokens\n        }\n        const msg = data.choices?.[0]?.message\n        if (msg?.content) lastText = msg.content\n        const toolCalls = msg?.tool_calls ?? []\n        if (toolCalls.length === 0) break // the model answered — loop done\n\n        // Record the assistant turn verbatim, then run each call on the host and\n        // fold the result back as a `tool` message for the next turn.\n        messages.push({\n          role: 'assistant',\n          content: msg?.content ?? '',\n          tool_calls: toolCalls.map((tc, i) => ({\n            id: tc.id ?? `call_${i}`,\n            type: 'function',\n            function: { name: tc.function?.name ?? '', arguments: tc.function?.arguments ?? '{}' },\n          })),\n        })\n        for (let i = 0; i < toolCalls.length; i += 1) {\n          const tc = toolCalls[i]\n          const id = tc?.id ?? `call_${i}`\n          let args: Record<string, unknown> = {}\n          try {\n            args = JSON.parse(tc?.function?.arguments ?? '{}') as Record<string, unknown>\n          } catch {\n            // Malformed args are a real outcome, not an infra fault — feed the error\n            // back so the model can correct, rather than aborting the whole loop.\n            messages.push({\n              role: 'tool',\n              tool_call_id: id,\n              content: 'error: tool arguments were not valid JSON',\n            })\n            continue\n          }\n          const result = await seam.executeToolCall(tc?.function?.name ?? '', args, task)\n          messages.push({ role: 'tool', tool_call_id: id, content: result })\n        }\n      }\n\n      const usd = isModelPriced(model) ? estimateCost(tokens.input, tokens.output, model) : 0\n      const spent: Spend = { iterations: turns, tokens, usd, ms: Date.now() - started }\n      const out = { content: lastText } as unknown\n      artifact = { outRef: contentRef('router-tools', { model, content: lastText }), out, spent }\n      return artifact\n    },\n    teardown(_grace): Promise<{ destroyed: boolean }> {\n      controller.abort()\n      return Promise.resolve({ destroyed: true })\n    },\n    resultArtifact() {\n      if (!artifact) {\n        throw new ValidationError(\n          'routerToolsInlineExecutor: resultArtifact() read before execute()',\n        )\n      }\n      return { ...artifact, spent: artifact.spent }\n    },\n  }\n}\n\n// ── sandbox executor (harness is a BackendType) ────────────────────────────────\n\n/**\n * COMPOSES `runLoop` as a single-task leaf: one box, a refine driver bounded to\n * the seam's `maxIterations` (default 1), the spec's profile as the agent run.\n * Surfaces the loop's aggregated `tokenUsage` + `costUsd` as `UsageEvent`s after\n * it drains, and yields one `iteration` event per loop iteration. Forwards the\n * optional `lineage` passthrough WITHOUT importing sandbox-lineage / reinventing\n * checkpoint/fork.\n *\n * Streaming shape: the loop runs to completion inside the first `next()`, then\n * the recorded usage events are yielded; the terminal artifact is read from\n * `resultArtifact()` after the stream drains.\n */\nexport const sandboxExecutor: ExecutorFactory<unknown> = (spec, ctx) => {\n  if (spec.harness === null) {\n    throw new ValidationError('sandboxExecutor: harness is null (router/inline) — wrong executor')\n  }\n  const harness = spec.harness as BackendType\n  const seam = readSeam<SandboxSeam>(ctx, sandboxSeamKey, 'sandbox')\n  if (!seam.sandboxClient || typeof seam.sandboxClient.create !== 'function') {\n    throw new ValidationError('sandboxExecutor: SandboxSeam.sandboxClient.create required')\n  }\n  const maxIterations = seam.maxIterations ?? 1\n  if (!Number.isFinite(maxIterations) || maxIterations <= 0) {\n    throw new ValidationError('sandboxExecutor: maxIterations must be > 0')\n  }\n\n  const controller = new AbortController()\n  const abortIfSignalled = () => {\n    if (ctx.signal.aborted) controller.abort()\n  }\n  abortIfSignalled()\n  if (!ctx.signal.aborted) ctx.signal.addEventListener('abort', abortIfSignalled, { once: true })\n\n  let artifact: ExecutorResult<unknown> | undefined\n\n  // The leaf runs an opaque, self-parallelizing coding harness; the loop just\n  // refines once over it. Output is the raw event stream parsed to its tail text.\n  const output: OutputAdapter<SandboxLeafOut> = {\n    parse(events: SandboxEvent[]): SandboxLeafOut {\n      return { events }\n    },\n  }\n  const driver = singleShotDriver<SandboxLeafOut>(maxIterations)\n\n  return {\n    runtime: 'sandbox' as Runtime,\n    execute(task, signal): AsyncIterable<UsageEvent> {\n      return streamSandboxLeaf({\n        task,\n        signal,\n        harness,\n        spec,\n        seam,\n        output,\n        driver,\n        maxIterations,\n        controller,\n        loopCtx: seam.loopCtx,\n        onArtifact: (a) => {\n          artifact = a\n        },\n      })\n    },\n    teardown(_grace): Promise<{ destroyed: boolean }> {\n      // The composed runLoop owns its box teardown (finally{allSettled(destroy)});\n      // aborting the loop's signal cascades into that barrier.\n      controller.abort()\n      return Promise.resolve({ destroyed: true })\n    },\n    resultArtifact() {\n      if (!artifact) {\n        throw new ValidationError('sandboxExecutor: resultArtifact() read before stream drained')\n      }\n      return artifact\n    },\n  }\n}\n\ninterface SandboxLeafOut {\n  events: SandboxEvent[]\n}\n\ninterface StreamSandboxArgs {\n  task: unknown\n  signal: AbortSignal\n  harness: BackendType\n  spec: AgentSpec\n  seam: SandboxSeam\n  output: OutputAdapter<SandboxLeafOut>\n  driver: Driver<unknown, SandboxLeafOut, string>\n  maxIterations: number\n  controller: AbortController\n  loopCtx?: Partial<Omit<ExecCtx, 'sandboxClient' | 'signal'>>\n  onArtifact: (a: ExecutorResult<unknown>) => void\n}\n\nasync function* streamSandboxLeaf(args: StreamSandboxArgs): AsyncIterable<UsageEvent> {\n  const linked = new AbortController()\n  const cascade = () => linked.abort()\n  if (args.signal.aborted || args.controller.signal.aborted) linked.abort()\n  else {\n    args.signal.addEventListener('abort', cascade, { once: true })\n    args.controller.signal.addEventListener('abort', cascade, { once: true })\n  }\n\n  const agentRun: AgentRunSpec<unknown> = {\n    profile: args.spec.profile,\n    taskToPrompt: (t) => taskToPrompt(t),\n    name: args.spec.profile.name ?? args.harness,\n    sandboxOverrides: { backend: { type: args.harness } },\n  }\n  const started = Date.now()\n\n  // `lineage` is a PR #150 RunLoopOptions field absent on this branch — forwarded\n  // forward-compatibly without coupling to its (not-yet-present) static type.\n  const loopOptions = {\n    driver: args.driver,\n    agentRun,\n    output: args.output,\n    task: args.task,\n    maxIterations: args.maxIterations,\n    maxConcurrency: 1,\n    ctx: {\n      ...(args.loopCtx ?? {}),\n      sandboxClient: args.seam.sandboxClient,\n      signal: linked.signal,\n    } as ExecCtx,\n    ...(args.seam.lineage !== undefined ? { lineage: args.seam.lineage } : {}),\n  } as RunLoopOptions<unknown, SandboxLeafOut, string>\n\n  try {\n    const result = await runLoop(loopOptions)\n    const out = result.winner?.output ?? { events: [] }\n    const verdict = result.winner?.verdict\n    const spent: Spend = {\n      iterations: result.iterations.length,\n      tokens: { input: result.tokenUsage.input, output: result.tokenUsage.output },\n      usd: result.costUsd,\n      ms: Date.now() - started,\n    }\n    args.onArtifact({\n      outRef: contentRef('sandbox', { harness: args.harness, out }),\n      out,\n      ...(verdict ? { verdict } : {}),\n      spent,\n    })\n    for (let i = 0; i < result.iterations.length; i += 1) yield { kind: 'iteration' }\n    if (result.tokenUsage.input || result.tokenUsage.output) {\n      yield { kind: 'tokens', input: result.tokenUsage.input, output: result.tokenUsage.output }\n    }\n    if (result.costUsd) yield { kind: 'cost', usd: result.costUsd }\n  } finally {\n    args.signal.removeEventListener('abort', cascade)\n    args.controller.signal.removeEventListener('abort', cascade)\n  }\n}\n\n// ── cli executor (Halo / external RLM subprocess) ──────────────────────────────\n\n/**\n * Spawns a subprocess (`bin` + `args`). It cannot account tokens, so it is\n * `budgetExempt: true`: its spend is NOT metered against the conserved pool and\n * its iterations are EXCLUDED from the equal-k arms by construction (the\n * resolver/equal-k path checks `budgetExempt`). teardown is SIGTERM → SIGKILL\n * with a grace window. Streaming: yields one `iteration` event on clean exit.\n */\nexport const cliExecutor: ExecutorFactory<unknown> = (_spec, ctx) => {\n  const seam = readSeam<CliSeam>(ctx, cliSeamKey, 'cli')\n  if (!seam.bin) throw new ValidationError('cliExecutor: CliSeam.bin required')\n\n  const controller = new AbortController()\n  const abortIfSignalled = () => {\n    if (ctx.signal.aborted) controller.abort()\n  }\n  abortIfSignalled()\n  if (!ctx.signal.aborted) ctx.signal.addEventListener('abort', abortIfSignalled, { once: true })\n\n  let proc: ReturnType<typeof spawn> | undefined\n  let artifact: ExecutorResult<unknown> | undefined\n\n  return {\n    runtime: 'cli' as Runtime,\n    budgetExempt: true,\n    execute(task, signal): AsyncIterable<UsageEvent> {\n      return streamCliLeaf({\n        task,\n        signal,\n        seam,\n        controller,\n        onProc: (p) => {\n          proc = p\n        },\n        onArtifact: (a) => {\n          artifact = a\n        },\n      })\n    },\n    async teardown(grace): Promise<{ destroyed: boolean }> {\n      controller.abort()\n      if (!proc || proc.exitCode !== null || proc.killed) return { destroyed: true }\n      return killWithGrace(proc, grace)\n    },\n    resultArtifact() {\n      if (!artifact) {\n        throw new ValidationError('cliExecutor: resultArtifact() read before stream drained')\n      }\n      return artifact\n    },\n  }\n}\n\ninterface StreamCliArgs {\n  task: unknown\n  signal: AbortSignal\n  seam: CliSeam\n  controller: AbortController\n  onProc: (p: ReturnType<typeof spawn>) => void\n  onArtifact: (a: ExecutorResult<unknown>) => void\n}\n\nasync function* streamCliLeaf(args: StreamCliArgs): AsyncIterable<UsageEvent> {\n  const prompt = taskToPrompt(args.task)\n  const proc = spawn(args.seam.bin, args.seam.args ?? [], {\n    ...(args.seam.cwd ? { cwd: args.seam.cwd } : {}),\n    env: { ...process.env, ...(args.seam.env ?? {}) },\n    stdio: ['pipe', 'pipe', 'pipe'],\n  })\n  args.onProc(proc)\n\n  const onAbort = () => killWithGrace(proc, 'brutalKill')\n  if (args.signal.aborted || args.controller.signal.aborted) onAbort()\n  else {\n    args.signal.addEventListener('abort', onAbort, { once: true })\n    args.controller.signal.addEventListener('abort', onAbort, { once: true })\n  }\n\n  // Feed the task on stdin; the subprocess owns its own tool/agent loop.\n  if (proc.stdin) {\n    proc.stdin.write(prompt)\n    proc.stdin.end()\n  }\n  const chunks: string[] = []\n  const errChunks: string[] = []\n  if (proc.stdout) proc.stdout.on('data', (d: Buffer) => chunks.push(d.toString('utf8')))\n  if (proc.stderr) proc.stderr.on('data', (d: Buffer) => errChunks.push(d.toString('utf8')))\n\n  const exit = await new Promise<{ code: number | null; error?: Error }>((resolve) => {\n    proc.once('error', (err) => resolve({ code: null, error: err }))\n    proc.once('close', (code) => resolve({ code }))\n  })\n  args.signal.removeEventListener('abort', onAbort)\n  args.controller.signal.removeEventListener('abort', onAbort)\n\n  if (exit.error) {\n    throw new ValidationError(`cliExecutor: spawn failed: ${exit.error.message}`, {\n      cause: exit.error,\n    })\n  }\n  if (exit.code !== 0) {\n    throw new ValidationError(\n      `cliExecutor: ${args.seam.bin} exited ${exit.code}: ${errChunks.join('').slice(0, 200)}`,\n    )\n  }\n  const out = { content: chunks.join('') } as unknown\n  // budgetExempt: spend is recorded zero (not metered) — never a fabricated cost.\n  args.onArtifact({ outRef: contentRef('cli', out), out, spent: zeroSpend() })\n  yield { kind: 'iteration' }\n}\n\n/** SIGTERM, then SIGKILL after `grace` ms (`'brutalKill'` = immediate SIGKILL,\n *  `'infinity'` = await clean exit, never escalate). */\nfunction killWithGrace(\n  proc: ReturnType<typeof spawn>,\n  grace: number | 'brutalKill' | 'infinity',\n): Promise<{ destroyed: boolean }> {\n  if (proc.exitCode !== null || proc.killed) return Promise.resolve({ destroyed: true })\n  return new Promise((resolve) => {\n    let timer: ReturnType<typeof setTimeout> | undefined\n    proc.once('close', () => {\n      if (timer) clearTimeout(timer)\n      resolve({ destroyed: true })\n    })\n    if (grace === 'brutalKill') {\n      proc.kill('SIGKILL')\n      return\n    }\n    proc.kill('SIGTERM')\n    if (grace === 'infinity') return\n    timer = setTimeout(() => {\n      if (proc.exitCode === null && !proc.killed) proc.kill('SIGKILL')\n    }, grace)\n  })\n}\n\n// ── bridge executor (harness CLIs behind the local cli-bridge) ──────────────────\n\n/**\n * One harness turn through the cli-bridge: a single OpenAI-compatible chat call\n * whose `model` selects the harness and whose `agent_profile` carries the arm\n * (native-tool disables, provider MCPs). One-shot like router/inline; reports\n * REAL usage when the bridge surfaces it, never a fabricated cost.\n */\nexport const bridgeExecutor: ExecutorFactory<unknown> = (spec, ctx) => {\n  const seam = readSeam<BridgeSeam>(ctx, bridgeSeamKey, 'bridge')\n  if (!seam.bridgeUrl || !seam.bridgeBearer || !seam.model) {\n    throw new ValidationError(\n      'bridgeExecutor: BridgeSeam.bridgeUrl + bridgeBearer + model required',\n    )\n  }\n  const controller = new AbortController()\n  const abortIfSignalled = () => {\n    if (ctx.signal.aborted) controller.abort()\n  }\n  abortIfSignalled()\n  if (!ctx.signal.aborted) ctx.signal.addEventListener('abort', abortIfSignalled, { once: true })\n\n  let artifact: ExecutorResult<unknown> | undefined\n\n  return {\n    runtime: 'cli' as Runtime,\n    async execute(task, signal): Promise<ExecutorResult<unknown>> {\n      const messages = taskToMessages(task, spec)\n      const started = Date.now()\n      const linked = linkSignals(signal, controller.signal)\n      const timer = seam.timeoutMs\n        ? setTimeout(() => controller.abort(), seam.timeoutMs)\n        : undefined\n      try {\n        const res = await fetch(`${seam.bridgeUrl.replace(/\\/$/, '')}/v1/chat/completions`, {\n          method: 'POST',\n          headers: {\n            'content-type': 'application/json',\n            authorization: `Bearer ${seam.bridgeBearer}`,\n          },\n          body: JSON.stringify({\n            model: seam.model,\n            stream: false,\n            ...(seam.agentProfile ? { agent_profile: seam.agentProfile } : {}),\n            messages,\n          }),\n          ...(linked ? { signal: linked } : {}),\n        })\n        if (!res.ok) {\n          throw new ValidationError(\n            `bridgeExecutor: bridge ${res.status}: ${(await res.text()).slice(0, 300)}`,\n          )\n        }\n        const data = (await res.json()) as {\n          choices?: Array<{\n            message?: { content?: string; tool_calls?: Array<{ function?: { name?: string } }> }\n          }>\n          usage?: { prompt_tokens?: number; completion_tokens?: number; cost?: number }\n        }\n        const u = data.usage\n        const usage =\n          u && typeof u.prompt_tokens === 'number' && typeof u.completion_tokens === 'number'\n            ? { input: u.prompt_tokens, output: u.completion_tokens }\n            : undefined\n        const msg = data.choices?.[0]?.message\n        const content = msg?.content ?? ''\n        const toolCalls = (msg?.tool_calls ?? []).map((t) => t.function?.name ?? 'unknown')\n        const spent: Spend = {\n          iterations: 1,\n          tokens: usage ? { input: usage.input, output: usage.output } : zeroTokenUsage(),\n          usd: typeof u?.cost === 'number' ? u.cost : 0,\n          ms: Date.now() - started,\n        }\n        const out = { content, toolCalls } as unknown\n        artifact = { outRef: contentRef('bridge', { model: seam.model, content }), out, spent }\n        return artifact\n      } finally {\n        if (timer) clearTimeout(timer)\n      }\n    },\n    teardown(_grace): Promise<{ destroyed: boolean }> {\n      controller.abort()\n      return Promise.resolve({ destroyed: true })\n    },\n    resultArtifact() {\n      if (!artifact) {\n        throw new ValidationError('bridgeExecutor: resultArtifact() read before execute()')\n      }\n      return { ...artifact, spent: artifact.spent }\n    },\n  }\n}\n\n// ── createExecutor: the ONE built-in factory (backend as data) ──────────────────\n\n/**\n * The single built-in executor entrypoint. The backend is DATA — the cost dial a\n * profile, an experiment config, or a replay journal can name — not an import\n * choice. Injects the matching seam and delegates to the built-in implementation;\n * the port stays OPEN: bring-your-own agents implement `Executor` directly and\n * never pass through here.\n */\nexport type ExecutorConfig =\n  | ({ backend: 'router' } & RouterSeam)\n  | ({ backend: 'router-tools' } & RouterToolsSeam)\n  | ({ backend: 'bridge' } & BridgeSeam)\n  | ({ backend: 'cli' } & CliSeam)\n  | ({ backend: 'sandbox'; harness?: BackendType } & SandboxSeam)\n\nexport function createExecutor(config: ExecutorConfig): ExecutorFactory<unknown> {\n  return (spec, ctx) => {\n    const { backend, ...seam } = config as ExecutorConfig & Record<string, unknown>\n    const seamed: ExecutorContext = { ...ctx, seams: { ...ctx.seams, [backend]: seam } }\n    switch (config.backend) {\n      case 'router':\n        return routerInlineExecutor(spec, seamed)\n      case 'router-tools':\n        return routerToolsInlineExecutor(spec, seamed)\n      case 'bridge':\n        return bridgeExecutor(spec, seamed)\n      case 'cli':\n        return cliExecutor(spec, seamed)\n      case 'sandbox': {\n        // The sandbox executor requires a concrete harness; a spec-level harness\n        // wins, else the config names it (fail-loud inside if both are absent).\n        const harness = spec.harness ?? config.harness ?? null\n        return sandboxExecutor({ ...spec, harness }, seamed)\n      }\n    }\n  }\n}\n\n// ── The open registry ──────────────────────────────────────────────────────────\n\n/**\n * The open resolver/registry. Pre-registers the three built-ins under their\n * runtime tags (`'router'`, `'sandbox'`, `'cli'`) and accepts `register(name,\n * factory)` for any additional runtime — and a BYO `AgentSpec.executor` resolves\n * without touching the registry at all. NOT a closed switch; registration + BYO\n * ARE the extension points.\n *\n * `resolve` precedence (frozen in `ExecutorRegistry`): a BYO `spec.executor` →\n * `harness === null` → the `'router'` factory; else a registered factory for the\n * harness-derived runtime (`'sandbox'` for any `BackendType`); else fail loud.\n */\nexport function createExecutorRegistry(): ExecutorRegistry {\n  const factories = new Map<Runtime, ExecutorFactory<unknown>>()\n  factories.set('router', routerInlineExecutor)\n  factories.set('inline', routerInlineExecutor)\n  factories.set('sandbox', sandboxExecutor)\n  factories.set('cli', cliExecutor)\n\n  return {\n    register<Out>(runtime: Runtime, factory: ExecutorFactory<Out>): void {\n      if (factories.has(runtime)) {\n        throw new ValidationError(`executor registry: runtime \"${runtime}\" already registered`)\n      }\n      factories.set(runtime, factory as ExecutorFactory<unknown>)\n    },\n    resolve<Out>(\n      spec: AgentSpec,\n    ): { succeeded: true; value: ExecutorFactory<Out> } | { succeeded: false; error: string } {\n      // BYO: a caller-supplied executor wins, wrapped in a trivial per-spawn factory.\n      if (spec.executor) {\n        const byo = spec.executor\n        return { succeeded: true, value: (() => byo) as ExecutorFactory<Out> }\n      }\n      // router/inline: an agent with no harness is a direct Router call.\n      if (spec.harness === null) {\n        const f = factories.get('router')\n        if (!f) return { succeeded: false, error: 'executor registry: no \"router\" factory' }\n        return { succeeded: true, value: f as ExecutorFactory<Out> }\n      }\n      // sandbox: any BackendType maps to the sandbox-composing-runLoop executor.\n      const runtimeTag: Runtime = 'sandbox'\n      const f = factories.get(runtimeTag)\n      if (!f) {\n        return {\n          succeeded: false,\n          error: `executor registry: no factory for runtime \"${runtimeTag}\" (harness \"${spec.harness}\") and no BYO executor`,\n        }\n      }\n      return { succeeded: true, value: f as ExecutorFactory<Out> }\n    },\n  }\n}\n\n// ── Shared helpers ──────────────────────────────────────────────────────────────\n\n/** Narrow a named seam off the `ExecutorContext`, failing loud when absent — no\n *  silent default for a required external-boundary seam. */\nfunction readSeam<T>(ctx: ExecutorContext, key: string, who: string): T {\n  const seam = ctx.seams[key]\n  if (seam === undefined || seam === null) {\n    throw new ValidationError(`${who} executor: missing required seam \"${key}\" on ExecutorContext`)\n  }\n  return seam as T\n}\n\n/** A leaf task is opaque (`unknown`). A string is the prompt verbatim; an object\n *  with a `prompt`/`content`/`task` string field uses it; otherwise it serializes. */\nfunction taskToPrompt(task: unknown): string {\n  if (typeof task === 'string') return task\n  if (task && typeof task === 'object') {\n    const obj = task as Record<string, unknown>\n    for (const k of ['prompt', 'content', 'task', 'message']) {\n      if (typeof obj[k] === 'string') return obj[k] as string\n    }\n  }\n  return JSON.stringify(task)\n}\n\n/** Router messages from the opaque task + the profile's system prompt, when set. */\nfunction taskToMessages(task: unknown, spec: AgentSpec): Array<{ role: string; content: string }> {\n  const messages: Array<{ role: string; content: string }> = []\n  const system = spec.profile.prompt?.systemPrompt\n  if (typeof system === 'string' && system.length > 0) {\n    messages.push({ role: 'system', content: system })\n  }\n  messages.push({ role: 'user', content: taskToPrompt(task) })\n  return messages\n}\n\n/** A driver that refines a single task up to `maxIterations` times then stops —\n *  the minimal policy that lets the sandbox executor run `runLoop` as one leaf. */\nfunction singleShotDriver<Out>(maxIterations: number): Driver<unknown, Out, string> {\n  return {\n    name: 'leaf',\n    plan(task, history): Promise<unknown[]> {\n      return Promise.resolve(history.length >= maxIterations ? [] : [task])\n    },\n    decide(history: ReadonlyArray<Iteration<unknown, Out>>): string {\n      return history.length >= maxIterations ? 'stop' : 'continue'\n    },\n  }\n}\n\n/** Link two abort signals into one that fires when either does. Returns\n *  `undefined` when neither is present so `fetch` gets no signal at all. */\nfunction linkSignals(a: AbortSignal, b: AbortSignal): AbortSignal | undefined {\n  if (a.aborted || b.aborted) {\n    const c = new AbortController()\n    c.abort()\n    return c.signal\n  }\n  const c = new AbortController()\n  const onAbort = () => c.abort()\n  a.addEventListener('abort', onAbort, { once: true })\n  b.addEventListener('abort', onAbort, { once: true })\n  return c.signal\n}\n\n// Re-export the verdict + spend surface so a consumer importing the runtime\n// built-ins gets the budget vocabulary from one place.\nexport type { DefaultVerdict, Executor, ExecutorResult, Spend, UsageEvent }\n","/**\n * The one router chat client: direct OpenAI-compatible completions through the\n * Tangle router — the cheapest dial, no sandbox. Three layers: `routerChatWithUsage`\n * (chat-only), `routerChatWithTools` (one completion with function tools), and\n * `routerToolLoop` (the off-box agentic loop over tool-calling). Shared by the\n * built-in executors and the bench/lab harnesses.\n *\n * Reports REAL token usage so the backend-integrity guard sees a real backend.\n * Returns `undefined` usage when the provider omitted it — never a fabricated 0\n * (a phantom 0 reads as a free call downstream, which the gate would act on).\n */\n\nimport { estimateCost, isModelPriced } from '@tangle-network/agent-eval'\n\nexport interface RouterConfig {\n  routerBaseUrl: string\n  routerKey: string\n  model: string\n}\n\nexport interface RouterChatResult {\n  content: string\n  /** REAL usage, or undefined when the provider reported none. */\n  usage?: { input: number; output: number }\n  /** Derived from usage via `estimateCost` when the model is priced; else undefined. */\n  costUsd?: number\n}\n\nexport async function routerChatWithUsage(\n  cfg: RouterConfig,\n  messages: Array<{ role: string; content: string }>,\n  opts?: { temperature?: number; signal?: AbortSignal; maxTokens?: number },\n): Promise<RouterChatResult> {\n  const url = `${cfg.routerBaseUrl.replace(/\\/$/, '')}/chat/completions`\n  const headers = { 'content-type': 'application/json', authorization: `Bearer ${cfg.routerKey}` }\n  let temperature = opts?.temperature ?? 0.2\n  // Retry TRANSIENT upstream failures (429/5xx) with backoff so a single capacity\n  // hiccup doesn't kill a whole multi-model benchmark run; and auto-handle the\n  // \"only temperature 1 is allowed\" 400 some thinking models (e.g. kimi-k2.6) return.\n  let lastErr = ''\n  for (let attempt = 0; attempt < 5; attempt += 1) {\n    const res = await fetch(url, {\n      method: 'POST',\n      headers,\n      // max_tokens default is generous: THINKING models (kimi-k2.6) spend the budget on\n      // reasoning_content first — a small router default yields EMPTY content.\n      body: JSON.stringify({\n        model: cfg.model,\n        messages,\n        temperature,\n        max_tokens: opts?.maxTokens ?? 8192,\n      }),\n      ...(opts?.signal ? { signal: opts.signal } : {}),\n    })\n    if (res.ok) return parseChatResult(await res.json(), cfg.model)\n    const status = res.status\n    const text = (await res.text()).slice(0, 200)\n    lastErr = `router ${status}: ${text}`\n    if (status === 400 && /temperature/i.test(text) && temperature !== 1) {\n      temperature = 1 // model requires temperature 1 — retry once with it\n      continue\n    }\n    // Non-retryable (auth/quota/malformed) fails loud immediately; retryable\n    // statuses back off and continue until the loop's attempt bound, then the\n    // post-loop throw is the honest \"exhausted retries\" terminal. 408/425 + the\n    // Cloudflare-origin family (520/522/524) are transient under heavy parallel\n    // load — a fleet of concurrent gate runs hits 524 (\"origin timeout\") and must\n    // retry, not crash the whole run.\n    if (![408, 425, 429, 500, 502, 503, 504, 520, 522, 524].includes(status))\n      throw new Error(lastErr)\n    if (attempt < 4) await new Promise((r) => setTimeout(r, 800 * 2 ** attempt))\n  }\n  throw new Error(`${lastErr} (exhausted retries)`)\n}\n\nfunction parseChatResult(json: unknown, model: string): RouterChatResult {\n  const data = json as {\n    choices?: Array<{ message?: { content?: string } }>\n    usage?: { prompt_tokens?: number; completion_tokens?: number }\n  }\n  const u = data.usage\n  const usage =\n    u && typeof u.prompt_tokens === 'number' && typeof u.completion_tokens === 'number'\n      ? { input: u.prompt_tokens, output: u.completion_tokens }\n      : undefined\n  const costUsd =\n    usage && isModelPriced(model) ? estimateCost(usage.input, usage.output, model) : undefined\n  return {\n    content: data.choices?.[0]?.message?.content ?? '',\n    ...(usage ? { usage } : {}),\n    ...(costUsd !== undefined ? { costUsd } : {}),\n  }\n}\n\n/** A tool-call the model emitted (provider-neutral; mirrors the runtime's ToolCallRequest). */\nexport interface RouterToolCall {\n  id: string\n  name: string\n  /** Raw JSON arguments string as emitted by the model. */\n  arguments: string\n}\n\nexport interface RouterChatToolsResult {\n  content: string | null\n  toolCalls: RouterToolCall[]\n  usage?: { input: number; output: number }\n  costUsd?: number\n}\n\n/**\n * A router completion WITH tool-calling — the operator driver's LLM seam. Passes OpenAI-shape\n * `messages` (system/user/assistant-with-tool_calls/tool roles) + function `tools`, and returns the\n * assistant text plus the tool calls the model wants run. Same fail-loud + real-usage discipline as\n * `routerChatWithUsage`. `tool_choice: 'auto'` lets the model decide; the driver loops on the result.\n */\nexport async function routerChatWithTools(\n  cfg: RouterConfig,\n  messages: ReadonlyArray<Record<string, unknown>>,\n  tools: ReadonlyArray<{\n    type: 'function'\n    function: { name: string; description?: string; parameters: unknown }\n  }>,\n  opts?: { temperature?: number; signal?: AbortSignal; toolChoice?: 'auto' | 'required' | 'none' },\n): Promise<RouterChatToolsResult> {\n  const res = await fetch(`${cfg.routerBaseUrl.replace(/\\/$/, '')}/chat/completions`, {\n    method: 'POST',\n    headers: { 'content-type': 'application/json', authorization: `Bearer ${cfg.routerKey}` },\n    body: JSON.stringify({\n      model: cfg.model,\n      messages,\n      tools,\n      tool_choice: opts?.toolChoice ?? 'auto',\n      temperature: opts?.temperature ?? 0.3,\n    }),\n    ...(opts?.signal ? { signal: opts.signal } : {}),\n  })\n  if (!res.ok) throw new Error(`router ${res.status}: ${(await res.text()).slice(0, 200)}`)\n  const data = (await res.json()) as {\n    choices?: Array<{\n      message?: {\n        content?: string | null\n        tool_calls?: Array<{ id?: string; function?: { name?: string; arguments?: string } }>\n      }\n    }>\n    usage?: { prompt_tokens?: number; completion_tokens?: number }\n  }\n  const msg = data.choices?.[0]?.message\n  const toolCalls: RouterToolCall[] = (msg?.tool_calls ?? []).map((tc, i) => ({\n    id: tc.id ?? `call_${i}`,\n    name: tc.function?.name ?? '',\n    arguments: tc.function?.arguments ?? '{}',\n  }))\n  const u = data.usage\n  const usage =\n    u && typeof u.prompt_tokens === 'number' && typeof u.completion_tokens === 'number'\n      ? { input: u.prompt_tokens, output: u.completion_tokens }\n      : undefined\n  const costUsd =\n    usage && isModelPriced(cfg.model)\n      ? estimateCost(usage.input, usage.output, cfg.model)\n      : undefined\n  return {\n    content: msg?.content ?? null,\n    toolCalls,\n    ...(usage ? { usage } : {}),\n    ...(costUsd !== undefined ? { costUsd } : {}),\n  }\n}\n\nexport interface ToolSpec {\n  type: 'function'\n  function: { name: string; description?: string; parameters: unknown }\n}\n\nexport interface RouterToolLoopResult {\n  /** The model's final assistant text (the turn where it stopped calling tools, or the budget turn). */\n  final: string\n  /** Inference turns spent (≤ maxTurns) — the equal-budget unit vs random@k. */\n  turns: number\n  toolCalls: number\n  /** The behavior trace: each tool call + its result, in order. What a trace-analyst\n   *  steerer reads (behavior, never the verdict) to diagnose + redirect the next shot. */\n  toolTrace: Array<{ name: string; args: string; result: string }>\n  usage: { input: number; output: number }\n}\n\n/**\n * The tool-using router backend: a real agentic loop OVER the Tangle router (which\n * supports tool-calling), off-box — no sandbox. Each turn is one router completion\n * with `tools`; if the model emits tool_calls, `execute` runs them on the host and\n * their results are folded back as `tool` messages; the loop repeats until the\n * model answers without a tool call or the turn budget is hit. One turn = one\n * inference call, so `maxTurns` is the equal-compute unit against random@k.\n *\n * This is the depth substrate for agentic gates (the worker ACTS, observes the real\n * result, and continues) that the chat-only `routerChatWithUsage` cannot express.\n */\nexport async function routerToolLoop(\n  cfg: RouterConfig,\n  system: string,\n  user: string,\n  tools: ReadonlyArray<ToolSpec>,\n  execute: (name: string, args: Record<string, unknown>) => Promise<string>,\n  opts?: { maxTurns?: number; temperature?: number; signal?: AbortSignal },\n): Promise<RouterToolLoopResult> {\n  const maxTurns = opts?.maxTurns ?? 4\n  const messages: Array<Record<string, unknown>> = [\n    { role: 'system', content: system },\n    { role: 'user', content: user },\n  ]\n  let toolCalls = 0\n  let lastText = ''\n  const usage = { input: 0, output: 0 }\n  const toolTrace: Array<{ name: string; args: string; result: string }> = []\n\n  for (let turn = 1; turn <= maxTurns; turn += 1) {\n    const r = await routerChatWithTools(cfg, messages, tools, {\n      ...(opts?.temperature !== undefined ? { temperature: opts.temperature } : {}),\n      ...(opts?.signal ? { signal: opts.signal } : {}),\n    })\n    if (r.usage) {\n      usage.input += r.usage.input\n      usage.output += r.usage.output\n    }\n    if (r.content) lastText = r.content\n    if (r.toolCalls.length === 0)\n      return { final: lastText, turns: turn, toolCalls, toolTrace, usage }\n\n    // Record the assistant turn verbatim (content + the tool_calls it requested), then\n    // run each call on the host and fold the result back as a `tool` message.\n    messages.push({\n      role: 'assistant',\n      content: r.content ?? '',\n      tool_calls: r.toolCalls.map((tc) => ({\n        id: tc.id,\n        type: 'function',\n        function: { name: tc.name, arguments: tc.arguments },\n      })),\n    })\n    for (const tc of r.toolCalls) {\n      toolCalls += 1\n      let args: Record<string, unknown> = {}\n      try {\n        args = JSON.parse(tc.arguments) as Record<string, unknown>\n      } catch {\n        // Malformed tool args from the model are a real outcome, not an infra fault — feed\n        // the error back so the model can correct, rather than throwing the whole loop.\n        messages.push({\n          role: 'tool',\n          tool_call_id: tc.id,\n          content: `error: arguments were not valid JSON: ${tc.arguments.slice(0, 200)}`,\n        })\n        continue\n      }\n      const out = await execute(tc.name, args)\n      messages.push({ role: 'tool', tool_call_id: tc.id, content: out })\n      toolTrace.push({ name: tc.name, args: tc.arguments, result: out })\n    }\n  }\n  return { final: lastText, turns: maxTurns, toolCalls, toolTrace, usage }\n}\n","/**\n * @experimental\n *\n * The conserved budget reservation pool — the invariant the whole instrument\n * rests on (critique M5/B3). One root `Budget` becomes a conserved pool of three\n * quantities (tokens, usd, iterations) plus an absolute deadline. Children reserve\n * atomically at spawn and reconcile at settle:\n *\n *   total ≡ free + reserved + committed          (invariant, always)\n *\n * `reserve` moves a child's whole ceiling from `free` → `reserved` and fails closed\n * when `free` can't cover it (never read-then-spawn overcommit, so `Σk(treatment) ≡\n * Σk(blind)` by construction). `reconcile` releases the reservation, commits ACTUAL\n * spend, and refunds the unspent remainder to `free`. Tokens and usd are separate\n * channels (`LoopTokenUsage` has no `usd`); iterations are conserved alongside them.\n *\n * Pure and deterministic: `now()` is injected, there is no I/O, and no wall-clock or\n * RNG read. A `reserve`/`reconcile` ticket is single-use (fail-loud on double or\n * unknown reconcile) so a child can never refund twice.\n */\n\nimport { addTokenUsage, zeroTokenUsage } from '../util'\nimport type { Budget, LoopTokenUsage, Spend, UsageEvent } from './types'\n\nexport type { Budget, Spend, UsageEvent }\n\n/** Opaque, single-use reservation handle returned by `reserve` and consumed by\n *  `reconcile`. Carries the reserved ceilings so reconciliation needs no lookup. */\nexport interface ReservationTicket {\n  readonly id: number\n  readonly reserved: {\n    readonly tokens: number\n    readonly usd: number\n    readonly iterations: number\n  }\n}\n\n/** Post-reservation pool readout — the shape `Scope.budget` exposes. `tokensLeft`,\n *  `usdLeft`, and `reservedTokens` reflect committed-but-unsettled reservations;\n *  `deadlineMs` is the ABSOLUTE wall-clock deadline (0 when the root set none). */\nexport type BudgetReadout = Readonly<{\n  tokensLeft: number\n  usdLeft: number\n  deadlineMs: number\n  reservedTokens: number\n}>\n\nexport interface BudgetPool {\n  /**\n   * Atomically reserve a child's full ceiling from the free balance. Fails closed\n   * ({ ok: false }) when the pool can't cover tokens, usd, or iterations — the\n   * caller inspects `ok` before `ticket`.\n   */\n  reserve(\n    b: Budget,\n  ): { ok: true; ticket: ReservationTicket } | { ok: false; reason: 'budget-exhausted' }\n  /**\n   * Release a reservation: commit the actual `spent`, refund the unspent remainder\n   * to the free pool. Throws on an unknown or already-reconciled ticket (fail loud —\n   * a double refund would silently break conservation).\n   */\n  reconcile(ticket: ReservationTicket, spent: Spend): void\n  /** Fold a normalized `UsageEvent` stream (or array) into a `Spend`. Tokens via\n   *  `addTokenUsage`, usd on its own channel, iterations from `'iteration'` events.\n   *  `ms` is left zero — wall-clock duration is the caller's to record, not the pool's. */\n  spendFrom(events: AsyncIterable<UsageEvent> | UsageEvent[]): Promise<Spend>\n  /** The current readout, reflecting all outstanding reservations. */\n  readout(): BudgetReadout\n  /** Fail loud if any reservation is still open — the conserved-pool leak detector. Called at the\n   *  supervisor's join barrier: once every child has settled, no ticket may remain (a leaked\n   *  reservation would silently break `total ≡ free + reserved + committed`). */\n  assertNoOpenTickets(): void\n}\n\n/** Fold a normalized `UsageEvent` array into a `Spend`. Tokens and usd are separate\n *  channels; iterations come from `'iteration'` events. Pure; `ms` stays zero (the\n *  pool does not read wall-clock). */\nexport function spendFromUsageEvents(events: UsageEvent[]): Spend {\n  const tokens = zeroTokenUsage()\n  let usd = 0\n  let iterations = 0\n  for (const ev of events) {\n    if (ev.kind === 'tokens') {\n      addTokenUsage(tokens, { input: ev.input, output: ev.output })\n    } else if (ev.kind === 'cost') {\n      usd += ev.usd\n    } else {\n      iterations += 1\n    }\n  }\n  return { iterations, tokens, usd, ms: 0 }\n}\n\nasync function foldUsage(events: AsyncIterable<UsageEvent> | UsageEvent[]): Promise<Spend> {\n  if (Array.isArray(events)) return spendFromUsageEvents(events)\n  const tokens = zeroTokenUsage()\n  let usd = 0\n  let iterations = 0\n  for await (const ev of events) {\n    if (ev.kind === 'tokens') {\n      addTokenUsage(tokens, { input: ev.input, output: ev.output })\n    } else if (ev.kind === 'cost') {\n      usd += ev.usd\n    } else {\n      iterations += 1\n    }\n  }\n  return { iterations, tokens, usd, ms: 0 }\n}\n\nfunction totalTokens(usage: LoopTokenUsage): number {\n  return usage.input + usage.output\n}\n\n/**\n * Create a conserved reservation pool from a root `Budget`. `now()` is injected so the\n * deadline readout is deterministic; defaults to `Date.now` for non-test callers. The\n * absolute deadline is fixed at construction (`now() + budget.deadlineMs`) so the\n * readout's `deadlineMs` is a stable wall-clock instant, not a shrinking remainder.\n */\nexport function createBudgetPool(root: Budget, now: () => number = Date.now): BudgetPool {\n  // free + reserved + committed ≡ root totals, per channel, always.\n  let freeTokens = root.maxTokens\n  let reservedTokens = 0\n  let committedTokens = 0\n\n  const usdCapped = root.maxUsd !== undefined\n  let freeUsd = root.maxUsd ?? 0\n  let reservedUsd = 0\n  let committedUsd = 0\n\n  let freeIterations = root.maxIterations\n  let reservedIterations = 0\n  let committedIterations = 0\n\n  const absoluteDeadlineMs = root.deadlineMs !== undefined ? now() + root.deadlineMs : 0\n\n  let nextTicketId = 0\n  const open = new Set<number>()\n\n  function reserve(\n    b: Budget,\n  ): { ok: true; ticket: ReservationTicket } | { ok: false; reason: 'budget-exhausted' } {\n    const wantTokens = b.maxTokens\n    const wantUsd = b.maxUsd ?? 0\n    const wantIterations = b.maxIterations\n    // Fail-closed admission: every requested channel must fit the free balance. A\n    // usd request against an uncapped root is unsatisfiable (the root declared no $).\n    if (wantTokens > freeTokens) return { ok: false, reason: 'budget-exhausted' }\n    if (wantIterations > freeIterations) return { ok: false, reason: 'budget-exhausted' }\n    if (wantUsd > 0 && (!usdCapped || wantUsd > freeUsd)) {\n      return { ok: false, reason: 'budget-exhausted' }\n    }\n\n    freeTokens -= wantTokens\n    reservedTokens += wantTokens\n    freeIterations -= wantIterations\n    reservedIterations += wantIterations\n    if (wantUsd > 0) {\n      freeUsd -= wantUsd\n      reservedUsd += wantUsd\n    }\n\n    const id = nextTicketId++\n    open.add(id)\n    return {\n      ok: true,\n      ticket: { id, reserved: { tokens: wantTokens, usd: wantUsd, iterations: wantIterations } },\n    }\n  }\n\n  function reconcile(ticket: ReservationTicket, spent: Spend): void {\n    if (!open.has(ticket.id)) {\n      throw new Error(`budget pool: reconcile of unknown or already-settled ticket ${ticket.id}`)\n    }\n    open.delete(ticket.id)\n\n    const { tokens: rTokens, usd: rUsd, iterations: rIterations } = ticket.reserved\n\n    // Clamp actual spend to the reservation: a child must never commit more than it\n    // reserved (that would overdraw the conserved pool). Over-spend is a fail-loud bug.\n    const spentTokens = totalTokens(spent.tokens)\n    if (spentTokens > rTokens) {\n      throw new Error(\n        `budget pool: ticket ${ticket.id} spent ${spentTokens} tokens > reserved ${rTokens}`,\n      )\n    }\n    if (spent.iterations > rIterations) {\n      throw new Error(\n        `budget pool: ticket ${ticket.id} spent ${spent.iterations} iterations > reserved ${rIterations}`,\n      )\n    }\n    // USD is conserved ONLY when the root declared a ceiling. `maxUsd` is optional: when no\n    // root ceiling exists, usd is an OBSERVED quantity (committed for accounting), never a\n    // budgeted constraint — so an unset ceiling must not behave as a hard $0 limit that\n    // fail-closes a real priced spend. The over-spend clamp applies only to a capped pool.\n    if (usdCapped && spent.usd > rUsd) {\n      throw new Error(`budget pool: ticket ${ticket.id} spent $${spent.usd} > reserved $${rUsd}`)\n    }\n\n    // Release the whole reservation, then commit actual spend; the difference is the\n    // refund that flows back to `free`.\n    reservedTokens -= rTokens\n    committedTokens += spentTokens\n    freeTokens += rTokens - spentTokens\n\n    reservedIterations -= rIterations\n    committedIterations += spent.iterations\n    freeIterations += rIterations - spent.iterations\n\n    if (usdCapped && rUsd > 0) {\n      reservedUsd -= rUsd\n      committedUsd += spent.usd\n      freeUsd += rUsd - spent.usd\n    } else {\n      // Uncapped (or a zero-ceiling child under a capped root): record the observed spend\n      // without touching the reservation channel — usd is accounted, not conserved here.\n      committedUsd += spent.usd\n    }\n  }\n\n  function readout(): BudgetReadout {\n    return {\n      tokensLeft: freeTokens,\n      usdLeft: usdCapped ? freeUsd : 0,\n      deadlineMs: absoluteDeadlineMs,\n      reservedTokens,\n    }\n  }\n\n  function assertNoOpenTickets(): void {\n    if (open.size > 0) {\n      throw new Error(\n        `budget pool: ${open.size} reservation(s) still open at join barrier (leaked ticket ids: ${[...open].join(', ')}) — conserved-pool invariant violated`,\n      )\n    }\n  }\n\n  return {\n    reserve,\n    reconcile,\n    spendFrom: foldUsage,\n    readout,\n    assertNoOpenTickets,\n  }\n}\n","/**\n * @experimental\n *\n * The `Supervisor` impl (KEYSTONE, build step 5).\n *\n * Owns the four things a free-running recursive `act` cannot own itself: the GLOBAL\n * conserved budget pool, the event-sourced spawn log, the abort cascade over the whole\n * live tree, and the OTP intensity breaker. `run` builds the root `Scope` over those,\n * runs the root `Agent.act`, and returns a TYPED `SupervisedResult` — a no-winner is\n * never coerced into a best-effort `Out`.\n *\n * Three lifecycle invariants this impl enforces by construction:\n *  - Join barrier: when `act()` settles (resolve OR reject), every still-live child is\n *    torn down before `run` returns — the generalization of the kernel's\n *    `finally{ Promise.allSettled(destroy) }` barrier (run-loop.ts) from boxes to the\n *    whole sub-tree. A teardown failure is `allSettled`'d and journaled as a\n *    `cancelled` event; it NEVER masks act()'s own outcome. act()'s rejection is the\n *    PRIMARY error (the kernel's firstError precedence), so a teardown throw during the\n *    barrier can never overwrite the real failure.\n *  - Abort cascade: a root abort (caller signal, `RootHandle.abort`, a tripped breaker,\n *    or pool exhaustion) aborts ONE internal controller whose signal is the root scope's\n *    signal. The scope cascades that into every live child's executor abort — which, for\n *    an `acquiring` child, chains into the `acquireSandbox` signal and reaps the\n *    find-by-name orphan box (M1). The supervisor never reaps children directly.\n *  - The supervisor NEVER re-enters a child (m3): the kernel/`acquireSandbox` already\n *    retried at the leaf, and a driver re-spawns through `scope.spawn`. The breaker only\n *    COUNTS `down` settlements within the intensity window and trips to a typed\n *    no-winner; it does not restart anything.\n *\n * Selection lives in the driver, not here (selector≠judge): `act` returns the synthesized\n * winner `Out`. The supervisor content-addresses that `Out` for its replay `outRef`,\n * reads `spentTotal` off the conserved pool, and wraps it as a typed `winner` — it does\n * not re-rank children behind the driver's back.\n */\n\nimport { contentAddress } from '../../durable/spawn-journal'\nimport { RuntimeRunStateError } from '../../errors'\nimport { type BudgetPool, createBudgetPool } from './budget'\nimport { createScope } from './scope'\nimport type {\n  Agent,\n  RootHandle,\n  RootSignal,\n  Scope,\n  SpawnEvent,\n  SpawnJournal,\n  Spend,\n  SupervisedResult,\n  Supervisor,\n  SupervisorOpts,\n  TreeView,\n} from './types'\n\n/** The default runtime recursion-depth ceiling, paired with the conserved pool so a\n *  runaway recursion hits budget-exhaustion first and depth-exceeded second (R3). */\nconst defaultMaxDepth = 4\n\n/** A no-winner reason the supervisor can prove from its OWN lifecycle state — pinned to\n *  the frozen `SupervisedResult` reason union. A driver rejecting for a domain reason\n *  (not budget/abort) is classed `all-children-down`, the only typed bucket for \"the tree\n *  produced no usable result\". */\ntype NoWinnerReason = (SupervisedResult<unknown> & { kind: 'no-winner' })['reason']\n\nexport function createSupervisor<Task, Out>(): Supervisor<Task, Out> {\n  let attached: RootControl | undefined\n\n  async function run(\n    root: Agent<Task, Out>,\n    task: Task,\n    opts: SupervisorOpts,\n  ): Promise<SupervisedResult<Out>> {\n    const now = opts.now ?? Date.now\n    const pool = createBudgetPool(opts.budget, now)\n    await opts.journal.beginTree(opts.runId, new Date(now()).toISOString())\n\n    // Journal the root as its own `spawned` node (parent-less, the spawn-ordinal-0 marker), so a\n    // journal-based reader — `trajectoryReport`, `replaySpawnTree`, `materializeTreeView` — can\n    // reconstruct the WHOLE realized tree from a real run, not only hand-built journals. The root\n    // is never `scope.spawn`ed (the supervisor runs `act` directly), so without this the root node\n    // is absent and `trajectoryReport` fails its `nodes.has(root)` invariant. The uniqueness guard\n    // skips `spawned` events (only the cursor namespace must be unique), so sharing ordinal 0 with\n    // the first child's spawn is not a collision; replay ignores `spawned` events for settlement\n    // reconstruction, so the replayed `Settled[]` is unchanged.\n    await opts.journal.appendEvent(opts.runId, {\n      kind: 'spawned',\n      id: opts.runId,\n      label: 'root',\n      budget: opts.budget,\n      runtime: 'inline',\n      seq: 0,\n      at: new Date(now()).toISOString(),\n    })\n\n    // ONE internal controller is the root scope's abort source. Every cascade path\n    // (caller signal, RootHandle.abort, breaker trip, deadline) aborts it; the scope\n    // fans it out to each live child's executor (acquire-aware reap included).\n    const controller = new AbortController()\n    const cascadeAbort = (reason?: string) => {\n      if (controller.signal.aborted) return\n      // Carry the reason on the signal so it chains down to each child's abort signal\n      // (`childAbort.signal.reason`) — the diagnostic the scope's executors observe.\n      controller.abort(reason)\n    }\n\n    const onCallerAbort = () => cascadeAbort('caller signal aborted')\n    if (opts.signal) {\n      if (opts.signal.aborted) cascadeAbort('caller signal aborted')\n      else opts.signal.addEventListener('abort', onCallerAbort, { once: true })\n    }\n\n    // The breaker watches `down` settlements via a counting journal decorator, so it\n    // observes every child failure without intercepting `scope.next()` (the driver's\n    // private channel). Tripping aborts the same controller; the trip is recorded so the\n    // final result can name it.\n    const breaker = createIntensityBreaker(opts, () => cascadeAbort('intensity breaker tripped'))\n    const journal = wrapJournalForBreaker(opts.journal, breaker)\n\n    const scope = createScope<Out>({\n      parentId: opts.runId,\n      root: opts.runId,\n      pool,\n      journal,\n      blobs: opts.blobs,\n      executors: opts.executors,\n      seams: {},\n      depth: 0,\n      maxDepth: opts.maxDepth ?? defaultMaxDepth,\n      signal: controller.signal,\n      now,\n      hooks: opts.hooks,\n    })\n\n    // `view`/drain read the scope opaquely (`Out` erased) — the supervisor never `spawn`s\n    // on it, so the live-tree readout and the join barrier are `Out`-agnostic.\n    const openScope = scope as unknown as Scope<unknown>\n\n    // Bind any attached RootHandle to THIS live run so view()/signal()/abort() reach the\n    // live scope + the one cascade controller. Detached again in the finally barrier.\n    if (attached) {\n      attached.bind({ scope: openScope, cascadeAbort, signal: pushRootSignal(cascadeAbort) })\n    }\n\n    let actOutcome: { ok: true; out: Out } | { ok: false; error: unknown }\n    try {\n      const out = await root.act(task, scope)\n      actOutcome = { ok: true, out }\n    } catch (error) {\n      // act()'s rejection is the PRIMARY error; capture it before the join barrier so a\n      // teardown failure in the barrier can never overwrite it (firstError precedence).\n      actOutcome = { ok: false, error }\n    } finally {\n      // Join barrier: tear down every still-live child. Generalizes the kernel's\n      // `finally{ Promise.allSettled(destroy) }` — a teardown throw is allSettled'd and\n      // journaled, never re-thrown.\n      await drainLiveChildren(openScope, controller)\n      if (opts.signal) opts.signal.removeEventListener('abort', onCallerAbort)\n      if (attached) attached.unbind()\n    }\n\n    const tree = scope.view\n    if (actOutcome.ok) {\n      // Every child has settled (join barrier above); no reservation may remain. A leaked ticket\n      // would silently corrupt the conserved spend total, so fail loud here — on the success path\n      // only, where the act() error precedence does not apply.\n      pool.assertNoOpenTickets()\n      // The driver synthesized a winner. Content-address it for the replay `outRef`, put\n      // it once, and sum the conserved spend off every journaled settlement. No\n      // re-ranking — the driver already selected.\n      const out = actOutcome.out\n      const outRef = contentAddress(out)\n      await opts.blobs.put(outRef, out)\n      return {\n        kind: 'winner',\n        out,\n        outRef,\n        tree,\n        spentTotal: await spentTotalFromJournal(journal, opts.runId),\n      }\n    }\n\n    // act() rejected. The reason is proven from lifecycle state, in precedence order:\n    // a tripped breaker outranks any abort (it is the most specific cause) outranks\n    // budget-exhaustion outranks the residual \"the tree produced nothing usable\" bucket.\n    // A no-winner is TYPED — never a best-effort coercion of a partial child (M2).\n    return {\n      kind: 'no-winner',\n      reason: classifyNoWinner(controller, pool, opts, breaker),\n      tree,\n      downCount: breaker.downCount(),\n    }\n  }\n\n  function attach(h: RootHandle<Out>): void {\n    const control = rootControls.get(h as RootHandle<unknown>)\n    if (!control) {\n      throw new RuntimeRunStateError(\n        'supervisor.attach: handle was not minted by createRootHandle (no control channel)',\n      )\n    }\n    attached = control\n  }\n\n  return { run, attach }\n}\n\n// ── Root handle ───────────────────────────────────────────────────────────────\n\n/** The live binding the supervisor populates while a run is in flight. `view` reads the\n *  live scope; `cascadeAbort`/`signal` reach the one cascade controller. */\ninterface RunBinding {\n  readonly scope: Scope<unknown>\n  readonly cascadeAbort: (reason?: string) => void\n  readonly signal: (msg: RootSignal) => void\n}\n\n/** The supervisor-private control behind a `RootHandle`. `createRootHandle` mints it and\n *  registers it in `rootControls`; `attach` looks it up and `bind`s it to the live run. */\ninterface RootControl {\n  bind(binding: RunBinding): void\n  unbind(): void\n}\n\n/** Module-private channel from a minted `RootHandle` to its `RootControl`, so `attach`\n *  can prove a handle is ours and reach its binding without leaking the control onto the\n *  frozen `RootHandle` shape. */\nconst rootControls = new WeakMap<RootHandle<unknown>, RootControl>()\n\n/**\n * Mint a `RootHandle` plus its supervisor-private control. The handle is the substrate a\n * chat/pi-viz client attaches to (Q2): `view()` reads the live tree, `signal()` delivers\n * an out-of-band message, `abort()` cascades. Before `run` binds it (and after `run`\n * unbinds it) the handle is fail-loud: a client that talks to a handle that is not\n * driving a live run gets a typed error, never a silent no-op.\n */\nexport function createRootHandle<Out>(): RootHandle<Out> {\n  let binding: RunBinding | undefined\n  const handle: RootHandle<Out> = {\n    view(): TreeView {\n      if (!binding) {\n        throw new RuntimeRunStateError(\n          'RootHandle.view: handle is not bound to a live run (attach it before run, read after run starts)',\n        )\n      }\n      return binding.scope.view\n    },\n    signal(msg: RootSignal): void {\n      if (!binding) {\n        throw new RuntimeRunStateError('RootHandle.signal: handle is not bound to a live run')\n      }\n      binding.signal(msg)\n    },\n    abort(reason?: string): void {\n      if (!binding) {\n        throw new RuntimeRunStateError('RootHandle.abort: handle is not bound to a live run')\n      }\n      binding.cascadeAbort(reason ?? 'root handle aborted')\n    },\n  }\n  rootControls.set(handle as RootHandle<unknown>, {\n    bind(b: RunBinding): void {\n      binding = b\n    },\n    unbind(): void {\n      binding = undefined\n    },\n  })\n  return handle\n}\n\n/** A `RootSignal` sink: `cancel` cascades an abort; pause/resume/ask are observability\n *  signals the substrate accepts but does not act on here (the chat/pi-viz client owns\n *  pause semantics — building them now would be mechanism ahead of the gate). */\nfunction pushRootSignal(cascadeAbort: (reason?: string) => void): (msg: RootSignal) => void {\n  return (msg: RootSignal): void => {\n    if (msg.kind === 'cancel') cascadeAbort(msg.reason ?? 'root signal: cancel')\n  }\n}\n\n// ── OTP intensity breaker ───────────────────────────────────────────────────────\n\n/**\n * Counts `down` settlements inside a sliding window. More than `maxRestarts` of them\n * within `withinMs` trips the supervisor (aborting the cascade) rather than letting a\n * driver re-spawn a doomed child forever. With either bound unset the breaker is inert\n * (it still counts `down`s for `downCount`). The breaker NEVER restarts a child — it is a\n * circuit breaker over the driver's own re-spawn decisions (m3).\n */\ninterface IntensityBreaker {\n  recordDown(at: number): void\n  tripped(): boolean\n  downCount(): number\n}\n\nfunction createIntensityBreaker(opts: SupervisorOpts, trip: () => void): IntensityBreaker {\n  const max = opts.maxRestarts\n  const within = opts.withinMs\n  const armed = max !== undefined && within !== undefined\n  const recent: number[] = []\n  let total = 0\n  let isTripped = false\n  return {\n    recordDown(at: number): void {\n      total += 1\n      if (!armed || isTripped) return\n      recent.push(at)\n      const cutoff = at - within\n      while (recent.length > 0 && recent[0]! < cutoff) recent.shift()\n      if (recent.length > max) {\n        isTripped = true\n        trip()\n      }\n    },\n    tripped(): boolean {\n      return isTripped\n    },\n    downCount(): number {\n      return total\n    },\n  }\n}\n\n/** Decorate the journal so the breaker observes every `settled`-`down` event the scope\n *  appends, without the supervisor intercepting `scope.next()`. The decorator is\n *  transparent — it forwards every method verbatim and only reads the down events. */\nfunction wrapJournalForBreaker(journal: SpawnJournal, breaker: IntensityBreaker): SpawnJournal {\n  return {\n    loadTree: (root) => journal.loadTree(root),\n    beginTree: (root, at) => journal.beginTree(root, at),\n    appendEvent: (root, ev: SpawnEvent) => {\n      if (ev.kind === 'settled' && ev.status === 'down') breaker.recordDown(Date.parse(ev.at))\n      return journal.appendEvent(root, ev)\n    },\n  }\n}\n\n// ── Join barrier + result classification ─────────────────────────────────────────\n\n/**\n * Drain the root scope's live set so every still-running/acquiring child is torn down\n * before `run` returns — the join barrier. Abort the cascade controller first (so each\n * child's executor stops cleanly), then pull `next()` to completion so every aborted\n * child's teardown + reconcile runs and its `settled` event is journaled by the scope.\n * A child's own teardown failure is already swallowed inside `runChild`, and the cursor\n * itself never rejects (a failing child is typed into a `down`), so the whole barrier is\n * `allSettled`'d — a stray throw here is NOT the primary error (firstError precedence).\n */\nasync function drainLiveChildren(\n  scope: Scope<unknown>,\n  controller: AbortController,\n): Promise<void> {\n  const hasLive = scope.view.inFlight > 0\n  if (!hasLive) return\n  // Cascade the abort into every live child's executor before draining.\n  if (!controller.signal.aborted) controller.abort()\n  await Promise.allSettled([drainCursor(scope)])\n}\n\nasync function drainCursor(scope: Scope<unknown>): Promise<void> {\n  for (;;) {\n    const settled = await scope.next()\n    if (settled === null) return\n  }\n}\n\nfunction classifyNoWinner(\n  controller: AbortController,\n  pool: BudgetPool,\n  opts: SupervisorOpts,\n  breaker: IntensityBreaker,\n): NoWinnerReason {\n  // A tripped breaker is the most specific cause (children kept dying), so it outranks\n  // the generic abort it raised. Then a caller/handle abort. Then the pool. The residual\n  // bucket is \"ran to completion under budget but produced nothing usable\".\n  if (breaker.tripped()) return 'all-children-down'\n  if (controller.signal.aborted) return 'aborted'\n  if (poolExhausted(pool, opts)) return 'budget-exhausted'\n  return 'all-children-down'\n}\n\nfunction poolExhausted(pool: BudgetPool, opts: SupervisorOpts): boolean {\n  const r = pool.readout()\n  if (r.tokensLeft <= 0) return true\n  if (opts.budget.maxUsd !== undefined && r.usdLeft <= 0) return true\n  if (\n    opts.budget.deadlineMs !== undefined &&\n    r.deadlineMs > 0 &&\n    (opts.now ?? Date.now)() >= r.deadlineMs\n  ) {\n    return true\n  }\n  return false\n}\n\n/**\n * Sum the conserved spend over every journaled `settled` event — the honest per-channel\n * total (input/output/usd/iterations all preserved), read off the same evidence replay\n * reads. Computed AFTER the join barrier so every child's settlement is recorded. Fails\n * loud if the tree was never journaled (the supervisor always `beginTree`s, so a missing\n * tree is a corrupted journal, not a normal path).\n */\nasync function spentTotalFromJournal(journal: SpawnJournal, root: string): Promise<Spend> {\n  const events = await journal.loadTree(root)\n  if (events === undefined) {\n    throw new RuntimeRunStateError(\n      `supervisor: spawn tree '${root}' is missing from the journal after run (corrupted log)`,\n    )\n  }\n  const total: Spend = { iterations: 0, tokens: { input: 0, output: 0 }, usd: 0, ms: 0 }\n  for (const ev of events) {\n    if (ev.kind !== 'settled') continue\n    total.iterations += ev.spent.iterations\n    total.tokens.input += ev.spent.tokens.input\n    total.tokens.output += ev.spent.tokens.output\n    total.usd += ev.spent.usd\n    total.ms += ev.spent.ms\n  }\n  return total\n}\n","/**\n * @experimental\n *\n * The loop-shape registry — the OPEN, content-free extension point for the personify layer.\n *\n * A `LoopShape` is reusable STRUCTURE (how to decompose / fan out / verify / synthesize),\n * parameterized by a persona's CONTENT. The registry lets a caller resolve a composed shape by\n * NAME: register a factory once, then `runPersonified({ shape: '<name>' })` resolves it with zero\n * edits elsewhere. `register` fails loud on a duplicate; `resolve` returns a typed outcome so an\n * unknown name is a named error, never a silent default.\n *\n * No shape is pre-registered: the generic combinators (`pipeline`/`fanout`/`loopUntil`/`panel`/\n * `verify`/`widen`) take spec arguments, so they are not bare zero-arg factories — a caller that\n * wants name-resolution registers its own COMPOSED shape (a combinator already applied to its\n * spec) on a registry instance. The registry carries SHAPE only; the domain lives on the persona.\n */\n\nimport { ValidationError } from '../../errors'\nimport type { LoopShape, ShapeRegistry } from './types'\n\n/**\n * Build a fresh open `ShapeRegistry`. A factory is stored type-erased and re-cast on resolve — the\n * caller asserts the `<Task, D>` it expects, exactly as the executor registry stores its factories.\n */\nexport function createShapeRegistry(): ShapeRegistry {\n  const shapes = new Map<string, LoopShape<unknown, unknown>>()\n  return {\n    register<Task, D>(name: string, factory: LoopShape<Task, D>): void {\n      if (shapes.has(name)) {\n        throw new ValidationError(`shape registry: shape \"${name}\" already registered`)\n      }\n      shapes.set(name, factory as LoopShape<unknown, unknown>)\n    },\n    resolve<Task, D>(name: string) {\n      const factory = shapes.get(name)\n      if (!factory) {\n        return { succeeded: false as const, error: `shape registry: unknown shape \"${name}\"` }\n      }\n      return { succeeded: true as const, value: factory as LoopShape<Task, D> }\n    },\n    names(): string[] {\n      return [...shapes.keys()]\n    },\n  }\n}\n\n/** The default registry `runPersonified` resolves a shape name against. Empty by construction —\n *  a caller registers its own composed shapes; the engine ships no domain shape. */\nexport const builtinShapes: ShapeRegistry = createShapeRegistry()\n\n/** Register a composed shape on the default `builtinShapes` registry — the one-call extension\n *  point a caller invokes so its shape is resolvable by name with zero edits to the engine. */\nexport function registerShape<Task, D>(name: string, factory: LoopShape<Task, D>): void {\n  builtinShapes.register(name, factory)\n}\n","/**\n * @experimental\n *\n * The personify layer impl — `definePersona` (the thin builder) + `runPersonified` (composes\n * the persona + chosen shape onto the keystone `Supervisor`), plus `createShapeContext`, the\n * seam that hands a shape its spawn helpers without it touching the registry.\n *\n * This file adds NO engine: `runPersonified` is `createSupervisor().run(rootAgent, task, …)`\n * where `rootAgent` is the persona's chosen `LoopShape` applied to a `ShapeContext`. All the\n * conserved-budget / journal / abort / typed-result machinery is the keystone's; this layer\n * only wires the persona's CONTENT (root spec + directive + context + seams) into it.\n *\n * One non-obvious invariant it must honor: `createSupervisor().run` builds the root `Scope`\n * with an EMPTY seam bag (`seams: {}`), so the built-in metered runtimes (router/sandbox/cli)\n * cannot read their seams off `ExecutorContext` through the default supervisor path. A persona\n * that supplies raw `seams` is therefore wrapped here into a registry whose resolved factories\n * receive a ctx with the persona seams merged in — so a persona never has to pre-close its\n * factories by hand. A persona may instead supply a fully-built `registry` and skip the wrap.\n */\n\nimport { InMemoryResultBlobStore, InMemorySpawnJournal } from '../../durable/spawn-journal'\nimport { ValidationError } from '../../errors'\nimport { createExecutorRegistry } from '../supervise/runtime'\nimport { createSupervisor } from '../supervise/supervisor'\nimport type {\n  Agent,\n  AgentSpec,\n  Budget,\n  ExecutorContext,\n  ExecutorFactory,\n  ExecutorRegistry,\n  Runtime,\n  SupervisedResult,\n  SupervisorOpts,\n} from '../supervise/types'\nimport { builtinShapes } from './registry'\nimport type {\n  DefinePersonaInput,\n  LoopShape,\n  Outcome,\n  Persona,\n  RunPersonifiedOptions,\n  ShapeBudget,\n  ShapeContext,\n} from './types'\n\n// ── definePersona ─────────────────────────────────────────────────────────────\n\n/**\n * Build a frozen `Persona`. Fails loud on the executors-supplied invariant: a persona with\n * neither a pre-built registry nor a seam bag cannot resolve its built-in runtimes, so it is\n * unrunnable — refuse it at definition time, not at the first spawn. Pure; no I/O.\n */\nexport function definePersona<D = unknown>(input: DefinePersonaInput<D>): Persona<D> {\n  if (!input.executors.registry && !input.executors.seams) {\n    throw new ValidationError(\n      `definePersona(\"${input.name}\"): executors must supply a registry or a seams bag ` +\n        '(built-in runtimes read their seams off ExecutorContext; neither was provided)',\n    )\n  }\n  if (!input.root || typeof input.root !== 'object' || !('harness' in input.root)) {\n    throw new ValidationError(`definePersona(\"${input.name}\"): root must be an AgentSpec`)\n  }\n  return Object.freeze({\n    name: input.name,\n    root: input.root,\n    directive: input.directive,\n    context: input.context,\n    executors: input.executors,\n    ...(input.extensions ? { extensions: input.extensions } : {}),\n  }) as Persona<D>\n}\n\n// ── ShapeContext construction ───────────────────────────────────────────────────\n\n/**\n * Build the `ShapeContext` a `LoopShape` factory consumes. `spawnChild` wraps an `AgentSpec`\n * into a leaf `Agent` carrying it as `executorSpec` (the structural field `scope.spawn`\n * reads); `childSpec` derives a narrower child spec from the persona's root by overriding the\n * profile. The shape never touches the registry — resolution stays single-sourced in the\n * scope/registry the supervisor owns.\n */\nexport function createShapeContext<D>(persona: Persona<D>, budget: ShapeBudget): ShapeContext<D> {\n  return {\n    persona,\n    budget,\n    spawnChild(name, spec): Agent<unknown, Outcome<D>> {\n      // The wrapped agent is SPAWNED, not run — the resolved Executor drives it. `act`\n      // is never invoked by the keystone for a spawned child; it throws if mis-used as a\n      // root (fail loud) rather than silently returning a vacuous outcome.\n      const agent = {\n        name,\n        executorSpec: spec,\n        act(): Promise<Outcome<D>> {\n          throw new ValidationError(\n            `personify: spawned child \"${name}\" was run as a driver; its executorSpec drives a leaf`,\n          )\n        },\n      }\n      return agent as Agent<unknown, Outcome<D>> & { executorSpec: AgentSpec }\n    },\n    childSpec(profile, harness): AgentSpec {\n      return {\n        profile,\n        harness: harness === undefined ? persona.root.harness : harness,\n        ...(persona.root.executor ? { executor: persona.root.executor } : {}),\n      }\n    },\n  }\n}\n\n// ── runPersonified ──────────────────────────────────────────────────────────────\n\n/**\n * Compose the persona + chosen shape onto a fresh keystone `Supervisor`. Resolves the shape\n * (a factory verbatim, or a registered name through `builtinShapes`), applies it to a\n * `ShapeContext`, and runs the resulting root `Agent` to a typed `SupervisedResult<Outcome>`.\n * Fail loud on an unknown shape name or an unresolvable persona registry — never a silent\n * default-shape fallback.\n */\nexport async function runPersonified<Task, D>(\n  options: RunPersonifiedOptions<Task, D>,\n): Promise<SupervisedResult<Outcome<D>>> {\n  const { persona } = options\n  const shape = resolveShape<Task, D>(options.shape)\n  const shapeBudget = resolveShapeBudget(options.budget, options.shapeBudget)\n  const ctx = createShapeContext(persona, shapeBudget)\n  const rootAgent = shape(ctx)\n\n  const executors = personaRegistry(persona)\n  const supervisor = createSupervisor<Task, Outcome<D>>()\n  if (options.handle) supervisor.attach(options.handle)\n\n  const supervisorOpts: SupervisorOpts = {\n    budget: options.budget,\n    runId: options.runId ?? `${persona.name}:${shapeName(options.shape, shape)}`,\n    journal: options.journal ?? new InMemorySpawnJournal(),\n    blobs: options.blobs ?? new InMemoryResultBlobStore(),\n    executors,\n    ...(options.maxDepth !== undefined ? { maxDepth: options.maxDepth } : {}),\n    ...(options.maxRestarts !== undefined ? { maxRestarts: options.maxRestarts } : {}),\n    ...(options.withinMs !== undefined ? { withinMs: options.withinMs } : {}),\n    ...(options.now ? { now: options.now } : {}),\n    ...(options.signal ? { signal: options.signal } : {}),\n  }\n  return supervisor.run(rootAgent, options.task, supervisorOpts)\n}\n\n// ── Resolution helpers ──────────────────────────────────────────────────────────\n\nfunction resolveShape<Task, D>(shape: LoopShape<Task, D> | string): LoopShape<Task, D> {\n  if (typeof shape !== 'string') return shape\n  const resolved = builtinShapes.resolve<Task, D>(shape)\n  if (!resolved.succeeded) {\n    throw new ValidationError(\n      `runPersonified: ${resolved.error} (registered: ${builtinShapes.names().join(', ')})`,\n    )\n  }\n  return resolved.value\n}\n\nfunction shapeName<Task, D>(\n  shape: LoopShape<Task, D> | string,\n  _resolved: LoopShape<Task, D>,\n): string {\n  return typeof shape === 'string' ? shape : shape.name || 'shape'\n}\n\n/**\n * Default the shape's per-child sizing + fanout width from the root budget when the caller\n * omits them. The per-child token ceiling is the root divided across the fanout so the\n * conserved pool can admit a full round; iterations default to the root's. A caller override\n * wins per-field.\n */\nfunction resolveShapeBudget(root: Budget, over?: Partial<ShapeBudget>): ShapeBudget {\n  const fanout = over?.fanout ?? defaultFanout\n  const perChild: Budget = over?.perChild ?? {\n    maxIterations: Math.max(1, Math.floor(root.maxIterations / fanout)),\n    maxTokens: Math.max(1, Math.floor(root.maxTokens / fanout)),\n    ...(root.maxUsd !== undefined ? { maxUsd: root.maxUsd / fanout } : {}),\n    ...(root.deadlineMs !== undefined ? { deadlineMs: root.deadlineMs } : {}),\n  }\n  return { perChild, fanout }\n}\n\nconst defaultFanout = 3\n\n/**\n * Resolve the persona's executor resolution into a single `ExecutorRegistry`. A pre-built\n * `registry` is used verbatim; otherwise the persona's raw `seams` are wrapped so resolved\n * factories receive an `ExecutorContext` with the persona seams merged in — the supervisor\n * threads an empty bag, so this is the one place the persona seams reach the built-ins.\n */\nfunction personaRegistry<D>(persona: Persona<D>): ExecutorRegistry {\n  const { registry, seams } = persona.executors\n  if (registry) return registry\n  if (!seams) {\n    throw new ValidationError(\n      `personify: persona \"${persona.name}\" supplies neither a registry nor seams`,\n    )\n  }\n  return withSeams(createExecutorRegistry(), seams)\n}\n\n/**\n * Wrap a registry so every resolved `ExecutorFactory` receives a ctx whose `seams` are\n * the persona seams merged over whatever the scope threaded (the scope threads `{}`, so the\n * persona seams win). A BYO `spec.executor` still resolves to a trivial factory that ignores\n * ctx — so this wrap is transparent for BYO and only matters for the metered built-ins.\n */\nfunction withSeams(\n  base: ExecutorRegistry,\n  seams: Readonly<Record<string, unknown>>,\n): ExecutorRegistry {\n  return {\n    register<Out>(runtime: Runtime, factory: ExecutorFactory<Out>): void {\n      base.register(runtime, factory)\n    },\n    resolve<Out>(spec: AgentSpec) {\n      const resolved = base.resolve<Out>(spec)\n      if (!resolved.succeeded) return resolved\n      const inner = resolved.value\n      const wrapped: ExecutorFactory<Out> = (s, ctx) => inner(s, mergeSeams(ctx, seams))\n      return { succeeded: true, value: wrapped }\n    },\n  }\n}\n\nfunction mergeSeams(\n  ctx: ExecutorContext,\n  seams: Readonly<Record<string, unknown>>,\n): ExecutorContext {\n  return { signal: ctx.signal, seams: { ...seams, ...ctx.seams } }\n}\n","/**\n * @experimental\n *\n * Trajectory trace + cost ledger — the post-hoc tree reconstructor (§4 of `wave-types`).\n *\n * `trajectoryReport` rebuilds the WHOLE realized spawn tree from the durable\n * `SpawnJournal` (+ optionally the `ResultBlobStore` for `done` artifacts): every node\n * (driver AND leaf), the real parent/child edges, each node's terminal status, its OWN\n * conserved `Spend`, and the `Spend` ROLLED UP over its subtree. Roll-up is a post-order\n * fold over the parent edges: a node's `rolledUpSpend` is its own spend plus every\n * descendant's, so a driver is charged for the fanout it caused — the root's roll-up is\n * the whole run's conserved total (tokens + usd + iterations + ms).\n *\n * `equalKOnCost` compares separate runs (arms) on that conserved COST, not on raw\n * iteration COUNT. The sandbox executor reports tokens/usd INCLUSIVE of a leaf's internal\n * sub-agent fanout, so charging an arm by `total.tokens`/`total.usd` (not by how many\n * `next()` cursors it logged) closes the leaf-fanout confound: a treatment leaf that fanned\n * out internally pays for it in cost, where a per-iteration count would hide it. The\n * within-run conserved pool already guarantees `Σk` equal by construction; this check is the\n * CROSS-run analogue the pool cannot reach — proving equal compute before any win is claimed.\n *\n * Pure over the journal/blobs — no live agent calls; safe to run on a finished run's log.\n */\n\nimport type {\n  DefaultVerdict,\n  NodeId,\n  ResultBlobStore,\n  SpawnEvent,\n  SpawnJournal,\n  Spend,\n} from '../supervise/types'\nimport { addTokenUsage, zeroTokenUsage } from '../util'\nimport type {\n  EqualKArm,\n  EqualKOnCostOptions,\n  EqualKVerdict,\n  TrajectoryNode,\n  TrajectoryReport,\n  TrajectoryReportOptions,\n} from './wave-types'\n\nconst defaultEqualKTolerance = 0.05\n\n/**\n * Reconstruct the whole spawn tree for `root` with per-node + rolled-up `Spend`. Reads the\n * journal for structure + spend and, when `withOutputs`, the blob store for each `done`\n * node's artifact. Fail loud on a tree that was never journaled, a settle/cancel for an\n * un-spawned node (a corrupted log), or — under `withOutputs` — a `done` node whose blob the\n * store cannot rehydrate (a silent gap would mis-cost or mis-evidence the tree).\n */\nexport async function trajectoryReport(\n  journal: SpawnJournal,\n  blobs: ResultBlobStore,\n  root: NodeId,\n  options: TrajectoryReportOptions = {},\n): Promise<TrajectoryReport> {\n  const events = await journal.loadTree(root)\n  if (events === undefined) {\n    throw new Error(`trajectoryReport: no journaled tree for root '${root}'`)\n  }\n\n  // Spawns (ordinal seq) create the nodes; settlements/cancellations (cursor seq) close\n  // them. The two seq namespaces overlap, so create every node from its `spawned` event\n  // first, then apply settlements/cancellations — mirrors `materializeTreeView`.\n  const spawns = events.filter(isSpawned).sort(bySeq)\n  const closes = events.filter((ev) => ev.kind !== 'spawned').sort(bySeq)\n\n  const nodes = new Map<NodeId, MutableNode>()\n  for (const ev of spawns) {\n    nodes.set(ev.id, {\n      id: ev.id,\n      parent: ev.parent,\n      label: ev.label,\n      runtime: ev.runtime,\n      status: 'pending',\n      ownSpend: zeroSpend(),\n      children: [],\n    })\n  }\n  for (const ev of closes) {\n    const node = requireNode(nodes, ev.id, root)\n    if (ev.kind === 'cancelled') {\n      node.status = 'cancelled'\n      continue\n    }\n    node.status = ev.status === 'done' ? 'done' : 'failed'\n    node.ownSpend = ev.spent\n    node.verdict = ev.verdict\n    node.outRef = ev.outRef\n  }\n\n  if (!nodes.has(root)) {\n    throw new Error(\n      `trajectoryReport: root '${root}' has no spawned event in its journaled tree (corrupted log)`,\n    )\n  }\n\n  // Wire the realized parent/child edges in spawn order, then roll spend up the tree.\n  for (const ev of spawns) {\n    if (ev.parent === undefined) continue\n    requireNode(nodes, ev.parent, root).children.push(ev.id)\n  }\n  const rolledUp = rollUpSpend(nodes, root)\n\n  if (options.withOutputs) {\n    await attachOutputs(nodes, blobs)\n  }\n\n  // Emit in spawn order so the node list reads as the realized tree, root first.\n  const ordered = spawns.map((ev) => nodes.get(ev.id)).filter(isNode)\n  const reported: TrajectoryNode[] = ordered.map((node) =>\n    freezeNode(node, requireSpend(rolledUp, node.id, root)),\n  )\n\n  return {\n    root,\n    nodes: reported,\n    total: requireSpend(rolledUp, root, root),\n    statusCounts: countStatuses(reported),\n  }\n}\n\n/**\n * Assert the arms are comparable at EQUAL conserved COST (tokens + usd), NOT raw iteration\n * count. Compares each arm's root-rolled-up `total` on the two conserved channels: an arm is\n * within-tolerance when the per-channel spread (max − min across arms) over the median is\n * `≤ tolerance`. Pure over the reports — no I/O. Fails loud on an empty arm list (nothing to\n * compare) so a vacuous \"equal\" is never returned.\n */\nexport function equalKOnCost(\n  arms: ReadonlyArray<EqualKArm>,\n  options: EqualKOnCostOptions = {},\n): EqualKVerdict {\n  if (arms.length === 0) {\n    throw new Error('equalKOnCost: no arms to compare')\n  }\n  const tolerance = options.tolerance ?? defaultEqualKTolerance\n\n  const armCosts = arms.map((arm) => ({\n    label: arm.label,\n    tokens: arm.report.total.tokens.input + arm.report.total.tokens.output,\n    usd: arm.report.total.usd,\n    iterations: arm.report.total.iterations,\n  }))\n\n  const tokenValues = armCosts.map((a) => a.tokens)\n  const usdValues = armCosts.map((a) => a.usd)\n  const spread = {\n    tokens: spreadOf(tokenValues),\n    usd: spreadOf(usdValues),\n  }\n  const withinTolerance =\n    fractionalSpread(tokenValues) <= tolerance && fractionalSpread(usdValues) <= tolerance\n\n  return {\n    withinTolerance,\n    arms: armCosts,\n    spread,\n    tolerance,\n  }\n}\n\n// ── Tree fold internals ────────────────────────────────────────────────────────\n\ninterface MutableNode {\n  id: NodeId\n  parent?: NodeId\n  label: string\n  runtime: string\n  status: TrajectoryNode['status']\n  ownSpend: Spend\n  children: NodeId[]\n  verdict?: DefaultVerdict\n  output?: unknown\n  outRef?: string\n}\n\n/**\n * Post-order fold: a node's rolled-up spend is its own spend plus every child's rolled-up\n * spend. Iterative (an explicit stack) so a deep tree never overflows the call stack; a node\n * is finalized only after all its children are, so the parent edges are honored exactly.\n */\nfunction rollUpSpend(nodes: Map<NodeId, MutableNode>, root: NodeId): Map<NodeId, Spend> {\n  const rolled = new Map<NodeId, Spend>()\n  const stack: { id: NodeId; expanded: boolean }[] = [{ id: root, expanded: false }]\n  while (stack.length > 0) {\n    const frame = stack.pop()\n    if (frame === undefined) continue\n    const node = requireNode(nodes, frame.id, root)\n    if (!frame.expanded) {\n      stack.push({ id: frame.id, expanded: true })\n      for (const child of node.children) stack.push({ id: child, expanded: false })\n      continue\n    }\n    const sum = cloneSpend(node.ownSpend)\n    for (const child of node.children) addSpend(sum, requireSpend(rolled, child, root))\n    rolled.set(frame.id, sum)\n  }\n  return rolled\n}\n\n/**\n * Rehydrate each `done` node's artifact from the blob store. Fail loud on a `done` node whose\n * blob the store cannot resolve — a missing payload under `withOutputs` is a corrupted store,\n * not an absent output (a `down`/`cancelled` node legitimately has none).\n */\nasync function attachOutputs(\n  nodes: Map<NodeId, MutableNode>,\n  blobs: ResultBlobStore,\n): Promise<void> {\n  for (const node of nodes.values()) {\n    if (node.status !== 'done' || node.outRef === undefined) continue\n    const out = await blobs.get(node.outRef)\n    if (out === undefined) {\n      throw new Error(\n        `trajectoryReport: blob store has no artifact for outRef '${node.outRef}' (node '${node.id}')`,\n      )\n    }\n    node.output = out\n  }\n}\n\nfunction freezeNode(node: MutableNode, rolledUpSpend: Spend): TrajectoryNode {\n  return {\n    id: node.id,\n    parent: node.parent,\n    children: [...node.children],\n    label: node.label,\n    runtime: node.runtime,\n    status: node.status,\n    ownSpend: node.ownSpend,\n    rolledUpSpend,\n    verdict: node.verdict,\n    output: node.output,\n    outRef: node.outRef,\n  }\n}\n\nfunction countStatuses(\n  reported: ReadonlyArray<TrajectoryNode>,\n): Readonly<Record<TrajectoryNode['status'], number>> {\n  const counts: Record<TrajectoryNode['status'], number> = {\n    done: 0,\n    failed: 0,\n    cancelled: 0,\n    pending: 0,\n  }\n  for (const node of reported) counts[node.status] += 1\n  return counts\n}\n\n// ── Spend arithmetic (single-sourced on `addTokenUsage`) ─────────────────────────\n\nfunction zeroSpend(): Spend {\n  return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 }\n}\n\nfunction cloneSpend(spend: Spend): Spend {\n  return {\n    iterations: spend.iterations,\n    tokens: { input: spend.tokens.input, output: spend.tokens.output },\n    usd: spend.usd,\n    ms: spend.ms,\n  }\n}\n\n/** Add `delta` into `acc` in place across every conserved channel. */\nfunction addSpend(acc: Spend, delta: Spend): void {\n  acc.iterations += delta.iterations\n  addTokenUsage(acc.tokens, delta.tokens)\n  acc.usd += delta.usd\n  acc.ms += delta.ms\n}\n\n// ── Cross-arm spread ─────────────────────────────────────────────────────────────\n\nfunction spreadOf(values: ReadonlyArray<number>): number {\n  if (values.length === 0) return 0\n  return Math.max(...values) - Math.min(...values)\n}\n\n/**\n * Fractional spread on one channel: `(max − min) / median`. A zero-median channel (every arm\n * spent zero on it) is trivially equal — spread is also zero, so it never trips the tolerance.\n */\nfunction fractionalSpread(values: ReadonlyArray<number>): number {\n  const spread = spreadOf(values)\n  if (spread === 0) return 0\n  const median = medianOf(values)\n  if (median === 0) {\n    throw new Error(\n      'equalKOnCost: arms have a non-zero cost spread on a zero-median channel; cannot express it as a fraction',\n    )\n  }\n  return spread / median\n}\n\nfunction medianOf(values: ReadonlyArray<number>): number {\n  if (values.length === 0) {\n    throw new Error('equalKOnCost: cannot take the median of an empty channel')\n  }\n  const sorted = [...values].sort((a, b) => a - b)\n  const mid = Math.floor(sorted.length / 2)\n  const hi = sorted[mid] as number\n  if (sorted.length % 2 !== 0) return hi\n  const lo = sorted[mid - 1] as number\n  return (lo + hi) / 2\n}\n\n// ── Guards + narrowers ───────────────────────────────────────────────────────────\n\nfunction isSpawned(ev: SpawnEvent): ev is Extract<SpawnEvent, { kind: 'spawned' }> {\n  return ev.kind === 'spawned'\n}\n\nfunction isNode(node: MutableNode | undefined): node is MutableNode {\n  return node !== undefined\n}\n\nfunction bySeq(a: SpawnEvent, b: SpawnEvent): number {\n  return a.seq - b.seq\n}\n\nfunction requireNode(nodes: Map<NodeId, MutableNode>, id: NodeId, root: NodeId): MutableNode {\n  const node = nodes.get(id)\n  if (!node) {\n    throw new Error(\n      `trajectoryReport: tree '${root}' references node '${id}' with no prior spawn (corrupted log)`,\n    )\n  }\n  return node\n}\n\nfunction requireSpend(rolled: Map<NodeId, Spend>, id: NodeId, root: NodeId): Spend {\n  const spend = rolled.get(id)\n  if (!spend) {\n    throw new Error(\n      `trajectoryReport: node '${id}' was never rolled up in tree '${root}' (unreachable from root)`,\n    )\n  }\n  return spend\n}\n","/**\n * promotionGate — the statistical promotion decision over a holdout benchmark: does the\n * candidate strategy beat the incumbent on held-out tasks by a margin the task noise\n * cannot fake? The statistics are the substrate's (`heldoutSignificance`): a SEEDED\n * paired bootstrap over per-task (candidate − incumbent) deltas — deterministic verdict,\n * a minimum-evidence floor, and the CI lower bound must clear `deltaThreshold`. A raw\n * h1>h0 point comparison on m≈8 holdout tasks certifies false champions at near\n * coin-flip rates; this gate is the instrument-grade replacement.\n */\nimport { heldoutSignificance } from '@tangle-network/agent-eval/campaign'\nimport type { BenchmarkReport } from './run-benchmark'\n\nexport interface PromotionGateOptions {\n  /** The HOLDOUT report — must carry per-task cells for both strategy names. */\n  report: BenchmarkReport\n  /** The incumbent champion's strategy name. */\n  incumbent: string\n  /** The challenger's strategy name. */\n  candidate: string\n  /** 'superiority' (default): the candidate must score significantly BETTER.\n   *  'non-inferiority': the candidate must prove its score is not worse than the\n   *  incumbent by more than `scoreTolerance` AND its cost savings are significant —\n   *  the gate for \"same quality, cheaper\" claims. */\n  mode?: 'superiority' | 'non-inferiority'\n  /** non-inferiority: the score CI lower bound must clear −scoreTolerance. Default 0.05. */\n  scoreTolerance?: number\n  /** The CI lower bound on the paired lift must EXCEED this (score scale). Default 0. */\n  deltaThreshold?: number\n  /** Minimum paired tasks before significance can be claimed. Default 6 — below that\n   *  the bootstrap CI is too wide to separate a real lift from the per-task noise. */\n  minPairedTasks?: number\n  /** Bootstrap statistic over the paired deltas. Default 'mean'. */\n  statistic?: 'mean' | 'median'\n  /** Fixed by the substrate by default — the same report always yields the same verdict. */\n  seed?: number\n  resamples?: number\n}\n\nexport interface PromotionVerdict {\n  promoted: boolean\n  reason:\n    | 'identical-champion'\n    | 'few-tasks'\n    | 'no-margin'\n    | 'significant'\n    | 'non-inferior-and-cheaper'\n    | 'non-inferiority-unproven'\n    | 'not-cheaper'\n  mode: 'superiority' | 'non-inferiority'\n  /** Paired tasks that carried both strategies' cells. */\n  n: number\n  /** Paired (candidate − incumbent) lift across the holdout tasks. */\n  lift: { mean: number; median: number; low: number; high: number }\n  /** non-inferiority mode: paired (incumbent − candidate) cost SAVINGS per task (usd) —\n   *  positive means the candidate is cheaper; significant iff the CI low clears zero. */\n  costSavings?: { mean: number; median: number; low: number; high: number }\n  /** Paired (candidate − incumbent) wall-clock per task (ms) — negative = the candidate\n   *  is FASTER. Informational in every mode (never gates); the latency answer to \"what\n   *  does this win actually cost the user?\". */\n  latency?: { mean: number; median: number; low: number; high: number }\n}\n\nexport function promotionGate(opts: PromotionGateOptions): PromotionVerdict {\n  const mode = opts.mode ?? 'superiority'\n  if (opts.candidate === opts.incumbent) {\n    return {\n      promoted: false,\n      reason: 'identical-champion',\n      mode,\n      n: 0,\n      lift: { mean: 0, median: 0, low: 0, high: 0 },\n    }\n  }\n  const before: number[] = []\n  const after: number[] = []\n  const incUsd: number[] = []\n  const candUsd: number[] = []\n  const incMs: number[] = []\n  const candMs: number[] = []\n  const cellIds: string[] = []\n  for (const row of opts.report.perTask) {\n    const inc = row.cells?.[opts.incumbent]\n    const cand = row.cells?.[opts.candidate]\n    if (!inc || !cand) continue\n    before.push(inc.score)\n    after.push(cand.score)\n    incUsd.push(inc.usd)\n    candUsd.push(cand.usd)\n    incMs.push(inc.ms)\n    candMs.push(cand.ms)\n    cellIds.push(row.taskId)\n  }\n  if (before.length === 0) {\n    throw new Error(\n      `promotionGate: no holdout task carried cells for both \"${opts.incumbent}\" and \"${opts.candidate}\" — the report must come from a run that included both strategies`,\n    )\n  }\n  const sig = heldoutSignificance(\n    { before, after, cellIds },\n    {\n      deltaThreshold: opts.deltaThreshold ?? 0,\n      minProductiveRuns: opts.minPairedTasks ?? 6,\n      statistic: opts.statistic ?? 'mean',\n      ...(opts.seed !== undefined ? { seed: opts.seed } : {}),\n      ...(opts.resamples !== undefined ? { resamples: opts.resamples } : {}),\n    },\n  )\n  const lift = {\n    mean: sig.bootstrap.mean,\n    median: sig.bootstrap.median,\n    low: sig.bootstrap.low,\n    high: sig.bootstrap.high,\n  }\n  const latSig = heldoutSignificance(\n    { before: incMs, after: candMs, cellIds },\n    {\n      deltaThreshold: 0,\n      minProductiveRuns: 1,\n      statistic: opts.statistic ?? 'mean',\n      ...(opts.seed !== undefined ? { seed: opts.seed } : {}),\n      ...(opts.resamples !== undefined ? { resamples: opts.resamples } : {}),\n    },\n  )\n  const latency = {\n    mean: latSig.bootstrap.mean,\n    median: latSig.bootstrap.median,\n    low: latSig.bootstrap.low,\n    high: latSig.bootstrap.high,\n  }\n  if (mode === 'superiority') {\n    if (sig.fewRuns) return { promoted: false, reason: 'few-tasks', mode, n: sig.n, lift, latency }\n    return sig.significant\n      ? { promoted: true, reason: 'significant', mode, n: sig.n, lift, latency }\n      : { promoted: false, reason: 'no-margin', mode, n: sig.n, lift, latency }\n  }\n  // non-inferiority: (a) score not worse than −scoreTolerance, proven (CI low clears\n  // −tolerance); (b) cost SAVINGS (incumbent − candidate, usd/task) significantly > 0.\n  const tolerance = opts.scoreTolerance ?? 0.05\n  const scoreSig = heldoutSignificance(\n    { before, after, cellIds },\n    {\n      deltaThreshold: -tolerance,\n      minProductiveRuns: opts.minPairedTasks ?? 6,\n      statistic: opts.statistic ?? 'mean',\n      ...(opts.seed !== undefined ? { seed: opts.seed } : {}),\n      ...(opts.resamples !== undefined ? { resamples: opts.resamples } : {}),\n    },\n  )\n  const costSig = heldoutSignificance(\n    { before: candUsd, after: incUsd, cellIds },\n    {\n      deltaThreshold: 0,\n      minProductiveRuns: opts.minPairedTasks ?? 6,\n      statistic: opts.statistic ?? 'mean',\n      ...(opts.seed !== undefined ? { seed: opts.seed } : {}),\n      ...(opts.resamples !== undefined ? { resamples: opts.resamples } : {}),\n    },\n  )\n  const costSavings = {\n    mean: costSig.bootstrap.mean,\n    median: costSig.bootstrap.median,\n    low: costSig.bootstrap.low,\n    high: costSig.bootstrap.high,\n  }\n  if (scoreSig.fewRuns)\n    return { promoted: false, reason: 'few-tasks', mode, n: scoreSig.n, lift, costSavings, latency }\n  if (!scoreSig.significant)\n    return {\n      promoted: false,\n      reason: 'non-inferiority-unproven',\n      mode,\n      n: scoreSig.n,\n      lift,\n      costSavings,\n      latency,\n    }\n  if (!costSig.significant)\n    return {\n      promoted: false,\n      reason: 'not-cheaper',\n      mode,\n      n: scoreSig.n,\n      lift,\n      costSavings,\n      latency,\n    }\n  return {\n    promoted: true,\n    reason: 'non-inferior-and-cheaper',\n    mode,\n    n: scoreSig.n,\n    lift,\n    costSavings,\n    latency,\n  }\n}\n","/**\n * runBenchmark — the packaged optimization suite. Define a domain by implementing an\n * `Environment` (open / tools / call / score / close); get the optimization strategies\n * compared, scored by your own deployable check, with a paired-bootstrap report — free.\n *\n * The mental model: you have a TASK + a deployable CHECK + a compute BUDGET. A strategy\n * is how you spend the budget to beat the check. Two built-ins:\n *\n *   sample  — N independent attempts, keep the best-verifying one.   (best-of-N / resample)\n *   refine  — attempt → a critic reads the trace → steer the next → repeat. (iterate-with-feedback)\n *\n * Both run at equal budget through the Supervisor's conserved pool; the headline is the\n * paired lift of refine over sample. Author your own strategy with `defineStrategy`.\n */\n\nimport { pairedBootstrap, paretoFrontier } from '@tangle-network/agent-eval'\nimport type { RuntimeHooks } from '../runtime-hooks'\nimport {\n  type AgenticOptions,\n  type AgenticSurface,\n  type AgenticTask,\n  refine,\n  runAgentic,\n  type Strategy,\n  sample,\n} from './strategy'\n\n/** A checkable task domain — implement these 5 hooks and the suite does the rest. The\n *  same seam as `AgenticSurface`; `Environment` is the RL/gym-standard name for it. */\nexport type Environment = AgenticSurface\n\nexport interface BenchmarkConfig {\n  /** The task domain (5 hooks). */\n  environment: Environment\n  /** The tasks to score across. */\n  tasks: AgenticTask[]\n  /** The worker: model + router + (optional) the critic's instruction (the steerer knob). */\n  worker: AgenticOptions\n  /** Which strategies to compare. Pass the built-ins (`refine`, `sample`) or your own.\n   *  Default: [sample, refine]. */\n  strategies?: Strategy[]\n  /** Shots (refine) / width (sample) — the equal compute budget per strategy. Default 3. */\n  budget?: number\n  /** Tasks scored in parallel. Default 3. */\n  concurrency?: number\n  /** Progress hook — fires as each task settles (the live-monitoring seam: append to a\n   *  progress file, render a tree, stream to a dashboard). `done` counts settled tasks. */\n  onTask?: (row: BenchmarkTaskRow, done: number, total: number) => void\n  /** Lifecycle observability — every spawn/settle of every cell's shots/analysts streams\n   *  here live (the watchdog/route-auditor seam, passed through to `runAgentic`). */\n  hooks?: RuntimeHooks\n}\n\nexport interface BenchmarkLift {\n  /** Mean of paired deltas (refine − sample). */\n  mean: number\n  low: number\n  high: number\n  n: number\n}\n\n/** One strategy's outcome on one task — the per-task cell an optimizer consumes. */\nexport interface BenchmarkCell {\n  score: number\n  resolved: boolean\n  /** The progress curve (refine: score per shot; sample: best-so-far per rollout). */\n  progression: number[]\n  usd: number\n  ms: number\n  tokens: { input: number; output: number }\n}\n\nexport interface BenchmarkTaskRow {\n  taskId: string\n  /** Per-strategy cells; absent when the task errored before completing all strategies. */\n  cells?: Record<string, BenchmarkCell>\n  /** Per-strategy failures on this task: the strategy competed, threw, and scored an\n   *  honest zero — it loses, it does not poison the row. The message is kept so a later\n   *  generation's author can see WHY a candidate died. */\n  errors?: Record<string, string>\n  /** Why the task was excluded (infra/setup failure) — never silently dropped. */\n  error?: string\n}\n\nexport interface BenchmarkStrategySummary {\n  /** Mean verifier score (0..1). */\n  score: number\n  /** Fraction of tasks fully resolved. */\n  resolved: number\n  /** Mean cost vector per task. */\n  usd: number\n  ms: number\n}\n\nexport interface BenchmarkReport {\n  n: number\n  excluded: number\n  /** Per-strategy means (keyed by strategy.name). */\n  perStrategy: Record<string, BenchmarkStrategySummary>\n  /** The full per-task × per-strategy table — the LOSSES an optimizer (GEPA, a\n   *  strategy-author, an operator) consumes. Includes errored tasks with the reason. */\n  perTask: BenchmarkTaskRow[]\n  /** The non-dominated strategies on (score ↑, $/task ↓) — collapse-last, per the canon:\n   *  a strategy that ties on score at half the cost WINS and a scalar would hide it. */\n  pareto: string[]\n  /** The headline when both `refine` and `sample` ran: paired-bootstrap lift of refine over sample. */\n  refineVsSample?: BenchmarkLift\n}\n\n/** Bounded-concurrency map preserving order. */\nasync function pool<T, R>(\n  items: readonly T[],\n  limit: number,\n  fn: (item: T, i: number) => Promise<R>,\n): Promise<R[]> {\n  const out: R[] = new Array(items.length)\n  let next = 0\n  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {\n    while (next < items.length) {\n      const i = next\n      next += 1\n      out[i] = await fn(items[i] as T, i)\n    }\n  })\n  await Promise.all(workers)\n  return out\n}\n\n/** Run the requested strategies over the tasks, scored by the Environment's own check.\n *  Resilient: a task whose rollouts fail (transient infra) is excluded from the stats but\n *  reported in `perTask` with the error — never silently dropped. */\nexport async function runBenchmark(cfg: BenchmarkConfig): Promise<BenchmarkReport> {\n  const strategies = cfg.strategies ?? [sample, refine]\n  const budget = cfg.budget ?? 3\n  const concurrency = cfg.concurrency ?? 3\n\n  let settled = 0\n  const perTask = await pool(cfg.tasks, concurrency, async (task): Promise<BenchmarkTaskRow> => {\n    const cells: Record<string, BenchmarkCell> = {}\n    const errors: Record<string, string> = {}\n    let row: BenchmarkTaskRow\n    try {\n      // Per-strategy isolation: one strategy throwing (a broken authored candidate, a\n      // hallucinated tool name) must not destroy the other strategies' cells for the\n      // task. The thrower scores an honest zero — it competed, it failed, it loses.\n      for (const s of strategies) {\n        try {\n          const r = await runAgentic({\n            ...cfg.worker,\n            surface: cfg.environment,\n            task,\n            strategy: s,\n            budget,\n            ...(cfg.hooks ? { hooks: cfg.hooks } : {}),\n          })\n          cells[s.name] = {\n            score: r.score,\n            resolved: r.resolved,\n            progression: r.progression,\n            usd: r.usd,\n            ms: r.ms,\n            tokens: r.tokens,\n          }\n        } catch (e) {\n          errors[s.name] = e instanceof Error ? e.message.slice(0, 300) : String(e)\n          cells[s.name] = {\n            score: 0,\n            resolved: false,\n            progression: [],\n            usd: 0,\n            ms: 0,\n            tokens: { input: 0, output: 0 },\n          }\n        }\n      }\n      row = {\n        taskId: task.id,\n        cells,\n        ...(Object.keys(errors).length > 0 ? { errors } : {}),\n      }\n    } catch (e) {\n      row = { taskId: task.id, error: e instanceof Error ? e.message.slice(0, 300) : String(e) }\n    }\n    settled += 1\n    cfg.onTask?.(row, settled, cfg.tasks.length)\n    return row\n  })\n\n  const ok = perTask.filter(\n    (r): r is BenchmarkTaskRow & { cells: Record<string, BenchmarkCell> } => !!r.cells,\n  )\n  const mean = (xs: number[]) => (xs.length ? xs.reduce((s, x) => s + x, 0) / xs.length : 0)\n  const perStrategy: Record<string, BenchmarkStrategySummary> = {}\n  for (const s of strategies) {\n    const cells = ok.map((r) => r.cells[s.name]).filter((c): c is BenchmarkCell => !!c)\n    perStrategy[s.name] = {\n      score: mean(cells.map((c) => c.score)),\n      resolved: mean(cells.map((c) => (c.resolved ? 1 : 0))),\n      usd: mean(cells.map((c) => c.usd)),\n      ms: mean(cells.map((c) => c.ms)),\n    }\n  }\n\n  const frontier = paretoFrontier(\n    Object.entries(perStrategy).map(([name, v]) => ({ name, score: v.score, usd: v.usd })),\n    [\n      { name: 'score', direction: 'maximize', value: (c) => c.score },\n      { name: 'usd', direction: 'minimize', value: (c) => c.usd },\n    ],\n  ).frontier.map((c) => c.name)\n\n  const report: BenchmarkReport = {\n    n: ok.length,\n    excluded: perTask.length - ok.length,\n    perStrategy,\n    perTask,\n    pareto: frontier,\n  }\n  const names = strategies.map((s) => s.name)\n  if (names.includes('refine') && names.includes('sample') && ok.length >= 2) {\n    const b = pairedBootstrap(\n      ok.map((r) => r.cells.sample?.score ?? 0),\n      ok.map((r) => r.cells.refine?.score ?? 0),\n    )\n    report.refineVsSample = { mean: b.mean, low: b.low, high: b.high, n: b.n }\n  }\n  return report\n}\n\n/** Pretty-print a report — the \"free optimization\" verdict, with the cost vector. */\nexport function printBenchmarkReport(report: BenchmarkReport): void {\n  const pct = (x: number) => `${(x * 100).toFixed(1)}%`\n  const pp = (x: number) => `${x >= 0 ? '+' : ''}${(x * 100).toFixed(1)}pp`\n  console.log(\n    `\\n=== benchmark · n=${report.n}${report.excluded ? ` (excluded ${report.excluded})` : ''} ===`,\n  )\n  console.log(\n    `  ${'strategy'.padEnd(16)} ${'score'.padStart(7)} ${'resolved'.padStart(9)} ${'$/task'.padStart(8)} ${'s/task'.padStart(7)}`,\n  )\n  for (const [s, v] of Object.entries(report.perStrategy))\n    console.log(\n      `  ${(report.pareto.includes(s) ? `${s} *` : s).padEnd(16)} ${pct(v.score).padStart(7)} ${pct(v.resolved).padStart(9)} ${`$${v.usd.toFixed(3)}`.padStart(8)} ${(v.ms / 1000).toFixed(0).padStart(6)}s`,\n    )\n  if (report.pareto.length) console.log(`  * = on the (score, $) Pareto frontier`)\n  for (const row of report.perTask)\n    if (row.error) console.log(`  ⚠ ${row.taskId}: ${row.error.slice(0, 120)}`)\n  const l = report.refineVsSample\n  if (l) {\n    const sig = l.low > 0 ? 'SIGNIF +' : l.high < 0 ? 'SIGNIF -' : 'n.s.'\n    console.log(`  refine − sample: ${pp(l.mean)}  CI [${pp(l.low)}, ${pp(l.high)}]  (${sig})`)\n  }\n}\n","/**\n * The general agentic primitive — sequential (depth) and parallel (breadth) over a shared,\n * checkable artifact, driven through the keystone Supervisor as one recursive `Agent.act`.\n *\n * The domain lives behind ONE seam — `AgenticSurface` (open an artifact, list tools, call a tool,\n * score the artifact, close it). EnterpriseOps implements it (seed a gym DB, MCP tools, SQL\n * verifier); Commit0/AppWorld/terminal-bench implement it the same way (a repo workspace, shell\n * tools, the test suite). The drivers below are domain-blind: they run over any surface.\n *\n * Two shapes, the agent's POMDP rollout as the unit:\n *  - DEPTH   one persistent artifact carried across shots. Each shot the agent works the tool loop;\n *            between shots a trace-analyst (selector≠judge: reads the trajectory, never the score)\n *            steers the resumed session toward what's unfinished. shot n stands on shot n-1's\n *            artifact state + history. This is continuation — long-horizon, same artifact.\n *  - BREADTH K independent artifacts, each a fresh rollout, the deployable verifier picks the best.\n *\n * Both are an `Agent` whose `act` spawns leaf shots through `scope.spawn` and reacts via\n * `scope.next()` — so the conserved budget pool meters them (equal-k by construction), the journal\n * records the tree, and the same primitive nests. `runAgentic` runs the chosen driver through\n * `createSupervisor().run`. The leaf (one shot over a handle) is resolved per-spawn from a\n * surface-closed registry — the open `Executor` seam, not bespoke per-benchmark glue.\n */\n\nimport { createChatClient, estimateCost, isModelPriced } from '@tangle-network/agent-eval'\nimport { InMemoryResultBlobStore, InMemorySpawnJournal } from '../durable/spawn-journal'\nimport type { RuntimeHooks } from '../runtime-hooks'\nimport { observe } from './observe'\nimport type { Outcome } from './personify/types'\nimport type { Corpus } from './personify/wave-types'\nimport { createSupervisor } from './supervise/supervisor'\nimport type {\n  Agent,\n  AgentSpec,\n  Budget,\n  Executor,\n  ExecutorContext,\n  ExecutorFactory,\n  ExecutorRegistry,\n  ExecutorResult,\n  Scope,\n  Settled,\n} from './supervise/types'\n\n// ── The general surface seam (the only thing a new benchmark implements) ─────────\n\nexport interface AgenticTask {\n  readonly id: string\n  readonly systemPrompt: string\n  readonly userPrompt: string\n  /** Opaque domain payload the surface reads (EOPS: servers/verifiers/tools). Drivers never read it. */\n  readonly meta?: Record<string, unknown>\n}\n\nexport interface ArtifactHandle {\n  readonly id: string\n  readonly surface: string\n  /** Opaque per-artifact context the surface stashes (EOPS: the seeded gym server + db id). */\n  readonly ctx?: unknown\n}\n\nexport interface AgenticTool {\n  readonly type: 'function'\n  readonly function: { name: string; description?: string; parameters: Record<string, unknown> }\n}\n\nexport interface SurfaceScore {\n  passes: number\n  total: number\n  /** Checks excluded as malformed (data defect, not the agent). `total === 0` ⇒ unscoreable. */\n  errored: number\n}\n\n/** A stateful, checkable environment an agent operates over with tools. Open behind one interface. */\nexport interface AgenticSurface {\n  readonly name: string\n  open(task: AgenticTask): Promise<ArtifactHandle>\n  tools(task: AgenticTask, handle: ArtifactHandle): Promise<AgenticTool[]>\n  call(handle: ArtifactHandle, name: string, args: Record<string, unknown>): Promise<string>\n  score(task: AgenticTask, handle: ArtifactHandle): Promise<SurfaceScore>\n  close(handle: ArtifactHandle): Promise<void>\n}\n\nexport interface AgenticOptions {\n  routerBaseUrl: string\n  routerKey: string\n  model: string\n  temperature?: number\n  /** Completion cap per worker turn — REQUIRED for thinking models (they burn unbounded\n   *  budgets on reasoning and return empty content without it). Omitted ⇒ provider default. */\n  maxTokens?: number\n  /** Turns the agent may take within ONE shot before the driver intervenes. */\n  innerTurns?: number\n  /** The depth STEERER's analyst instruction (observe()'s system prompt). The knob a\n   *  prompt optimizer (GEPA) tunes — the analyst IS the steerer. Omitted ⇒ the default. */\n  analystInstruction?: string\n  /** The critic's model — lets the analyst be a stronger (or cheaper) model than the\n   *  worker. Omitted ⇒ the worker's `model`. */\n  analystModel?: string\n  /** Across-run learning: when set, the analyst's observe() pass appends trace-derived\n   *  facts here (the flywheel write side). Priming (the read side) is the caller's move —\n   *  query the corpus and fold facts into the task's systemPrompt before runAgentic. */\n  corpus?: Corpus\n  /** Tags written onto learned facts (and used by the caller's priming query). */\n  corpusTags?: string[]\n}\n\n// ── The unit: one agentic shot (a bounded tool loop) over a handle ───────────────\n\ntype Msg = Record<string, unknown>\ninterface ToolCall {\n  id: string\n  function: { name: string; arguments: string }\n}\n\ninterface ShotTask {\n  task: AgenticTask\n  handle?: ArtifactHandle // present ⇒ DEPTH (shared artifact); absent ⇒ BREADTH (open own)\n  messages?: Msg[] // carried conversation (depth); fresh when absent\n  steer?: string // analyst-derived steer injected before this shot (depth)\n  persona?: ShotPersona // role override — multi-agent loops give each shot its own hat\n  tools?: string[] // restrict THIS shot to these domain tools (names); unknown names throw\n  /** analyst leaf only: a RAW instruction — the analyst answers it over the trajectory\n   *  directly (no findings schema). The verdict-capable channel. */\n  rawInstruction?: string\n}\n\ninterface ShotOut {\n  messages: Msg[]\n  completions: number\n  toolCalls: number\n  toolErrors: number\n  /** Real router usage summed over the shot's turns; zeros only when the provider omits usage. */\n  tokens: { input: number; output: number }\n}\n\nconst taskNudge =\n  'Use the available tools to bring the artifact to the required final state. Address EVERY distinct ' +\n  'change the request implies. After each tool result, check what remains and continue. Re-read the ' +\n  'values you set to confirm they took. Reply DONE only once every required change is made and verified.'\n\n/** One shot: run the agent's tool loop (≤ innerTurns) over the handle, mutating the artifact via\n *  `surface.call`, carrying `messages`. Returns the updated conversation + counts. */\nasync function runShot(\n  surface: AgenticSurface,\n  _task: AgenticTask,\n  handle: ArtifactHandle,\n  tools: AgenticTool[],\n  messages: Msg[],\n  opts: AgenticOptions,\n  modelOverride?: string,\n): Promise<ShotOut> {\n  const innerTurns = opts.innerTurns ?? 4\n  let completions = 0\n  let toolCalls = 0\n  let toolErrors = 0\n  const tokens = { input: 0, output: 0 }\n  for (let t = 0; t < innerTurns; t += 1) {\n    const res = await fetch(`${opts.routerBaseUrl.replace(/\\/$/, '')}/chat/completions`, {\n      method: 'POST',\n      headers: { 'content-type': 'application/json', authorization: `Bearer ${opts.routerKey}` },\n      body: JSON.stringify({\n        model: modelOverride ?? opts.model,\n        messages,\n        tools,\n        tool_choice: 'auto',\n        temperature: opts.temperature ?? 0.7,\n        ...(opts.maxTokens ? { max_tokens: opts.maxTokens } : {}),\n      }),\n    })\n    if (!res.ok) throw new Error(`router ${res.status}: ${(await res.text()).slice(0, 200)}`)\n    completions += 1\n    const data = (await res.json()) as {\n      choices?: Array<{ message?: { content?: string; tool_calls?: ToolCall[] } }>\n      usage?: { prompt_tokens?: number; completion_tokens?: number }\n    }\n    if (typeof data.usage?.prompt_tokens === 'number') tokens.input += data.usage.prompt_tokens\n    if (typeof data.usage?.completion_tokens === 'number')\n      tokens.output += data.usage.completion_tokens\n    const msg = data.choices?.[0]?.message\n    if (!msg) break\n    const calls = msg.tool_calls ?? []\n    messages.push({\n      role: 'assistant',\n      content: msg.content ?? '',\n      ...(calls.length ? { tool_calls: calls } : {}),\n    })\n    if (calls.length === 0) break\n    for (const call of calls) {\n      toolCalls += 1\n      let args: Record<string, unknown> = {}\n      try {\n        args = JSON.parse(call.function.arguments || '{}')\n      } catch {\n        toolErrors += 1\n      }\n      let out: string\n      try {\n        out = await surface.call(handle, call.function.name, args)\n        if (out.startsWith('ERROR:')) toolErrors += 1\n      } catch (e) {\n        toolErrors += 1\n        out = `ERROR: ${e instanceof Error ? e.message : String(e)}`\n      }\n      messages.push({ role: 'tool', tool_call_id: call.id, content: out })\n    }\n  }\n  return { messages, completions, toolCalls, toolErrors, tokens }\n}\n\n/** The trace-analyst (selector≠judge): reads ONLY the trajectory + task, never the score. */\n/** The depth STEERER, on the CANONICAL analyst: agent-eval's `observe()` (makeFinding +\n *  ChatClient + the derived_from_judge firewall) reads the agent's tool-call trajectory\n *  (behavior, never the score) and returns findings; we steer on their recommended_actions.\n *  The trajectory (calls + RESULTS) rides in `output` so the analyst sees what actually\n *  happened, not just tool names. No actionable findings ⇒ COMPLETE (depth self-terminates). */\ninterface AnalyzeOut {\n  steer: string\n  tokens: { input: number; output: number }\n}\n\n/** The firewall's input shape: the trajectory as compacted text — calls, results,\n *  assistant text. NEVER scores, NEVER check internals. Shared by both analyst channels. */\nfunction compactTrajectory(messages: Msg[]): string {\n  return messages\n    .filter((m) => m.role === 'assistant' || m.role === 'tool')\n    .map((m) => {\n      if (m.role === 'tool') return `RESULT ${String(m.content).slice(0, 280)}`\n      const calls = (m.tool_calls as ToolCall[] | undefined)\n        ?.map((c) => `${c.function.name}(${c.function.arguments})`)\n        .join(', ')\n      return calls ? `CALL ${calls}` : `SAY ${String(m.content).slice(0, 200)}`\n    })\n    .join('\\n')\n    .slice(0, 7000)\n}\n\n/** The RAW analyst channel: the firewalled critic answers `instruction` over the\n *  trajectory directly — no findings schema, no recommended-action extraction. The\n *  channel for verdict-shaped steering (budget controllers, calibrated predictions)\n *  whose output format the findings protocol would strip. Same firewall as analyze():\n *  trajectory in, never scores. */\nasync function consultAnalyst(\n  task: AgenticTask,\n  messages: Msg[],\n  instruction: string,\n  opts: AgenticOptions,\n): Promise<AnalyzeOut> {\n  const trajectory = compactTrajectory(messages)\n  const analystModel = opts.analystModel ?? opts.model\n  const chat = createChatClient({\n    transport: 'router',\n    apiKey: opts.routerKey,\n    baseUrl: opts.routerBaseUrl,\n    defaultModel: analystModel,\n  })\n  const res = await chat.chat({\n    model: analystModel,\n    temperature: 0.2,\n    maxTokens: 1024,\n    messages: [\n      { role: 'system', content: instruction },\n      {\n        role: 'user',\n        content: `TASK: ${task.userPrompt.slice(0, 1500)}\\n\\nTRAJECTORY:\\n${trajectory}`,\n      },\n    ],\n  })\n  const usage = (\n    res as {\n      usage?: {\n        promptTokens?: number\n        prompt_tokens?: number\n        completionTokens?: number\n        completion_tokens?: number\n      }\n    }\n  ).usage\n  return {\n    steer: res.content.trim(),\n    tokens: {\n      input: usage?.promptTokens ?? usage?.prompt_tokens ?? 0,\n      output: usage?.completionTokens ?? usage?.completion_tokens ?? 0,\n    },\n  }\n}\n\nasync function analyze(\n  task: AgenticTask,\n  messages: Msg[],\n  opts: AgenticOptions,\n): Promise<AnalyzeOut> {\n  const trajectory = compactTrajectory(messages)\n  const analystModel = opts.analystModel ?? opts.model\n  const inner = createChatClient({\n    transport: 'router',\n    apiKey: opts.routerKey,\n    baseUrl: opts.routerBaseUrl,\n    defaultModel: analystModel,\n  })\n  // The critic's calls are REAL spend — capture usage so the cost vector bills them\n  // (an unbilled critic makes every steering-vs-sampling cost comparison dishonest).\n  const tokens = { input: 0, output: 0 }\n  const chat: typeof inner = {\n    ...inner,\n    chat: async (req, callOpts) => {\n      const res = await inner.chat(req, callOpts)\n      const u = (\n        res as {\n          usage?: {\n            promptTokens?: number\n            completionTokens?: number\n            prompt_tokens?: number\n            completion_tokens?: number\n          }\n        }\n      ).usage\n      if (u) {\n        tokens.input += u.promptTokens ?? u.prompt_tokens ?? 0\n        tokens.output += u.completionTokens ?? u.completion_tokens ?? 0\n      }\n      return res\n    },\n  }\n  const obs = await observe(\n    {\n      task: task.userPrompt,\n      output: trajectory,\n      trace: messages,\n      outcome: 'failed',\n      runId: task.id,\n    },\n    {\n      chat,\n      model: analystModel,\n      ...(opts.analystInstruction ? { analystInstruction: opts.analystInstruction } : {}),\n      ...(opts.corpus ? { corpus: opts.corpus, tags: opts.corpusTags ?? [] } : {}),\n    },\n  )\n  // The steer = the analyst's recommended actions for the agent. Empty ⇒ nothing left to do.\n  const steer = obs.findings\n    .map((f) => f.recommended_action)\n    .filter((a): a is string => typeof a === 'string' && a.trim().length > 0)\n    .join('\\n')\n    .trim()\n  return { steer: steer || 'COMPLETE', tokens }\n}\n\n// ── Leaf executors (one shot / one analyst), resolved per-spawn from the surface ──\n\ninterface ShotResult {\n  messages: Msg[]\n  score: number\n  passes: number\n  total: number\n  completions: number\n  toolErrors: number\n}\n\n/** Resolve a shot: if `handle` given, operate on the SHARED artifact (depth); else open+score+close\n *  an OWN artifact (breadth). Always scores the artifact's final state as the deployable verdict. */\nfunction shotExecutor(surface: AgenticSurface, opts: AgenticOptions): Executor<unknown> {\n  let artifact: ExecutorResult<unknown> | undefined\n  return {\n    runtime: 'agentic-shot',\n    async execute(task: unknown): Promise<ExecutorResult<unknown>> {\n      const t = task as ShotTask\n      const own = !t.handle\n      const handle = t.handle ?? (await surface.open(t.task))\n      try {\n        const allTools = await surface.tools(t.task, handle)\n        // Tool SELECTION is a strategy decision (which of the domain's tools this shot\n        // sees) — restriction-only: a strategy can focus a shot, never grant a tool the\n        // domain didn't offer. Unknown names fail loud (an authored typo must not\n        // silently become an unrestricted shot).\n        let tools = allTools\n        if (t.tools) {\n          const known = new Set(allTools.map((tool) => tool.function.name))\n          const unknown = t.tools.filter((name) => !known.has(name))\n          if (unknown.length > 0) {\n            throw new Error(\n              `shot tools: unknown tool name(s) ${unknown.join(', ')} — domain offers: ${[...known].join(', ')}`,\n            )\n          }\n          const want = new Set(t.tools)\n          tools = allTools.filter((tool) => want.has(tool.function.name))\n        }\n        // An EMPTY messages array means \"fresh\" too — an authored body passing\n        // `messages: []` must not silently blank the worker's system/task prompt.\n        const messages: Msg[] = t.messages?.length\n          ? t.messages\n          : [\n              { role: 'system', content: t.persona?.systemPrompt ?? t.task.systemPrompt },\n              { role: 'user', content: `${t.task.userPrompt}\\n\\n${taskNudge}` },\n            ]\n        // On a CARRIED conversation, a persona switch arrives as a role hand-off message.\n        if (t.messages?.length && t.persona?.systemPrompt) {\n          messages.push({\n            role: 'user',\n            content: `[hand-off] You are now acting as: ${t.persona.systemPrompt}`,\n          })\n        }\n        if (t.steer) messages.push({ role: 'user', content: t.steer })\n        const shot = await runShot(surface, t.task, handle, tools, messages, opts, t.persona?.model)\n        const s = await surface.score(t.task, handle)\n        const score = s.total > 0 ? s.passes / s.total : 0\n        const out: ShotResult = {\n          messages: shot.messages,\n          score,\n          passes: s.passes,\n          total: s.total,\n          completions: shot.completions,\n          toolErrors: shot.toolErrors,\n        }\n        artifact = {\n          outRef: `shot:${handle.id}:${shot.completions}:${s.passes}/${s.total}`,\n          out,\n          verdict: { valid: s.total > 0 && s.passes === s.total, score },\n          // Real usage to the conserved pool: tokens from the router responses; usd only\n          // when the model is in the price table (never a fabricated number).\n          spent: {\n            iterations: shot.completions,\n            tokens: shot.tokens,\n            usd: isModelPriced(opts.model)\n              ? estimateCost(shot.tokens.input, shot.tokens.output, opts.model)\n              : 0,\n            ms: 0,\n          },\n        }\n        return artifact\n      } finally {\n        if (own) await surface.close(handle)\n      }\n    },\n    teardown: () => Promise.resolve({ destroyed: true }),\n    resultArtifact() {\n      if (!artifact) throw new Error('shotExecutor: resultArtifact before execute')\n      return artifact\n    },\n  }\n}\n\nfunction analystExecutor(opts: AgenticOptions): Executor<unknown> {\n  let artifact: ExecutorResult<unknown> | undefined\n  return {\n    runtime: 'agentic-analyst',\n    async execute(task: unknown): Promise<ExecutorResult<unknown>> {\n      const t = task as { task: AgenticTask; messages: Msg[]; rawInstruction?: string }\n      const { steer, tokens } = t.rawInstruction\n        ? await consultAnalyst(t.task, t.messages, t.rawInstruction, opts)\n        : await analyze(t.task, t.messages, opts)\n      const analystModel = opts.analystModel ?? opts.model\n      artifact = {\n        outRef: `analyst:${steer.length}`,\n        out: steer,\n        spent: {\n          iterations: 1,\n          tokens,\n          usd: isModelPriced(analystModel)\n            ? estimateCost(tokens.input, tokens.output, analystModel)\n            : 0,\n          ms: 0,\n        },\n      }\n      return artifact\n    },\n    teardown: () => Promise.resolve({ destroyed: true }),\n    resultArtifact() {\n      if (!artifact) throw new Error('analystExecutor: resultArtifact before execute')\n      return artifact\n    },\n  }\n}\n\n/** Registry dispatching on the child's role tag — fresh executor per spawn (no shared-instance race). */\nfunction agenticRegistry(surface: AgenticSurface, opts: AgenticOptions): ExecutorRegistry {\n  return {\n    register() {\n      throw new Error('agenticRegistry: register unsupported')\n    },\n    resolve<Out>(spec: AgentSpec) {\n      const role = (spec.profile.metadata as { role?: string } | undefined)?.role\n      const factory: ExecutorFactory<Out> = (_s: AgentSpec, _ctx: ExecutorContext) =>\n        (role === 'analyst' ? analystExecutor(opts) : shotExecutor(surface, opts)) as Executor<Out>\n      return { succeeded: true as const, value: factory }\n    },\n  }\n}\n\nfunction leaf(name: string, role: 'shot' | 'analyst'): Agent<unknown, Outcome<unknown>> {\n  const agent = {\n    name,\n    executorSpec: { profile: { name, metadata: { role } }, harness: null } as unknown as AgentSpec,\n    act(): Promise<Outcome<unknown>> {\n      throw new Error(`agentic: spawned leaf \"${name}\" run as a driver`)\n    },\n  }\n  return agent as Agent<unknown, Outcome<unknown>>\n}\n\n/** Drain exactly one settlement (the just-spawned child). */\nasync function drainOne(scope: Scope<Outcome<unknown>>): Promise<Settled<Outcome<unknown>>> {\n  const s = await scope.next()\n  if (!s) throw new Error('agentic: spawned child never settled')\n  return s\n}\n\n// ── The result + the two drivers (domain-blind Agents run by the Supervisor) ─────\n\nexport interface AgenticRunResult {\n  /** The strategy name (built-in 'depth'/'breadth' or a custom strategy's name). */\n  mode: string\n  score: number\n  resolved: boolean\n  completions: number\n  /** DEPTH: score after each shot — the progress-over-rounds curve. BREADTH: best-so-far per rollout. */\n  progression: number[]\n  shots: number\n  /** The cost vector, stamped by `runAgentic` from the Supervisor's conserved pool: real\n   *  router tokens, priced usd (0 when the model is unpriced — never fabricated), wall ms. */\n  usd: number\n  ms: number\n  tokens: { input: number; output: number }\n}\n\nconst perChild = (innerTurns: number): Budget => ({\n  maxIterations: innerTurns + 1,\n  maxTokens: 1_000_000,\n})\n\n/** DEPTH: one persistent artifact, carried across analyst-steered shots. */\nexport function depthDriver(\n  surface: AgenticSurface,\n  task: AgenticTask,\n  opts: AgenticOptions,\n  cfg: { maxShots: number },\n): Agent<unknown, Outcome<unknown>> {\n  const innerTurns = opts.innerTurns ?? 4\n  let pendingSteer: string | undefined // analyst-derived steer carried between shots\n  return {\n    name: 'depth',\n    async act(_t, scope): Promise<Outcome<unknown>> {\n      const handle = await surface.open(task)\n      const progression: number[] = []\n      let messages: Msg[] | undefined\n      let completions = 0\n      let shots = 0\n      try {\n        for (shots = 0; shots < cfg.maxShots; shots += 1) {\n          const child = leaf(`shot:${shots}`, 'shot')\n          const steer = shots === 0 ? undefined : pendingSteer\n          const res = scope.spawn(child, { task, handle, messages, steer } as ShotTask, {\n            budget: perChild(innerTurns),\n            label: `shot:${shots}`,\n          })\n          if (!res.ok) break\n          const settled = await drainOne(scope)\n          if (settled.kind === 'down') break\n          const out = settled.out as unknown as ShotResult\n          messages = out.messages\n          completions += out.completions\n          progression.push(out.score)\n          if (out.score >= 1 || shots === cfg.maxShots - 1) break\n          // Analyst reads the trajectory (firewalled) → steer the resumed session.\n          const aChild = leaf(`analyst:${shots}`, 'analyst')\n          const aRes = scope.spawn(\n            aChild,\n            { task, messages },\n            { budget: perChild(1), label: `analyst:${shots}` },\n          )\n          if (!aRes.ok) break\n          const aSettled = await drainOne(scope)\n          completions += 1\n          if (aSettled.kind === 'down') break\n          const findings = aSettled.out as unknown as string\n          if (/^\\s*COMPLETE\\b/i.test(findings)) break\n          pendingSteer = `A reviewer flagged unfinished items:\\n${findings}\\n\\nAddress each with the tools, verify they took, then continue.`\n        }\n        const final = await surface.score(task, handle)\n        const score = final.total > 0 ? final.passes / final.total : 0\n        return {\n          kind: 'done',\n          deliverable: {\n            mode: 'depth',\n            score,\n            resolved: final.total > 0 && final.passes === final.total,\n            completions,\n            progression,\n            shots: shots + 1,\n          },\n        }\n      } finally {\n        await surface.close(handle)\n      }\n    },\n  }\n}\n\n/** BREADTH: K independent rollouts (each own artifact), verifier picks the best. */\nexport function breadthDriver(\n  _surface: AgenticSurface,\n  task: AgenticTask,\n  opts: AgenticOptions,\n  cfg: { width: number },\n): Agent<unknown, Outcome<unknown>> {\n  const innerTurns = opts.innerTurns ?? 4\n  return {\n    name: 'breadth',\n    async act(_t, scope): Promise<Outcome<unknown>> {\n      let opened = 0\n      for (let k = 0; k < cfg.width; k += 1) {\n        const res = scope.spawn(leaf(`rollout:${k}`, 'shot'), { task } as ShotTask, {\n          budget: perChild(innerTurns),\n          label: `rollout:${k}`,\n        })\n        if (res.ok) opened += 1\n      }\n      if (opened === 0) return { kind: 'blocked', blockers: ['breadth: pool admitted no rollout'] }\n      let best = -1\n      let bestResolved = false\n      let completions = 0\n      const progression: number[] = []\n      for (let s = await scope.next(); s !== null; s = await scope.next()) {\n        if (s.kind === 'down') continue\n        const out = s.out as unknown as ShotResult\n        completions += out.completions\n        if (out.score > best) best = out.score\n        if (out.total > 0 && out.passes === out.total) bestResolved = true\n        progression.push(best)\n      }\n      if (best < 0) return { kind: 'blocked', blockers: ['breadth: every rollout went down'] }\n      return {\n        kind: 'done',\n        deliverable: {\n          mode: 'breadth',\n          score: best,\n          resolved: bestResolved,\n          completions,\n          progression,\n          shots: opened,\n        },\n      }\n    },\n  }\n}\n\n/**\n * A Strategy is HOW you spend the compute budget to beat the Environment's check — it\n * builds the driver `Agent` the Supervisor runs. This is the OPEN extension point: a dev\n * authors their own by implementing `driver()` to return an Agent whose `act()` spawns\n * shots/analysts via `scope.spawn` / `scope.next` / `scope.send`. The two built-ins are\n * the reference implementations to copy:\n *   sample — K INDEPENDENT attempts, keep the best-verifying (best-of-N / resample).\n *   refine — attempt → observe() reads the trace → steer the next → repeat (iterate).\n * (A multi-agent \"team\" is just a Strategy whose driver spawns several different agents.)\n */\nexport interface Strategy {\n  readonly name: string\n  driver(\n    surface: AgenticSurface,\n    task: AgenticTask,\n    opts: AgenticOptions,\n    budget: number,\n  ): Agent<unknown, Outcome<unknown>>\n}\n\nexport const sample: Strategy = {\n  name: 'sample',\n  driver: (surface, task, opts, budget) => breadthDriver(surface, task, opts, { width: budget }),\n}\nexport const refine: Strategy = {\n  name: 'refine',\n  driver: (surface, task, opts, budget) => depthDriver(surface, task, opts, { maxShots: budget }),\n}\n\n// ── The composable LEGO: author a strategy in ~15 lines from two steps ───────────\n//\n// A strategy body gets `shot()` (run one worker attempt over an artifact) and\n// `critique()` (the firewalled analyst reads the trace → a steer). Compose them — no\n// Supervisor/Scope ceremony. This is the skillifiable unit: an agent can emit a\n// `defineStrategy(name, body)` of a few step-calls; it can't reliably emit a 70-line\n// driver. (depthDriver/breadthDriver are the hand-written reference impls; refine/sample\n// stay on them — proven — while NEW strategies are authored compactly here.)\n\n/** A role for one shot — multi-agent loops (researcher + engineer, a panel of k\n *  researchers) give each shot its own system prompt and optionally its own model. */\nexport interface ShotPersona {\n  /** Replaces the task's systemPrompt for a FRESH shot; on a carried conversation it is\n   *  injected as a hand-off message (the transcript's earlier roles stay intact). */\n  systemPrompt?: string\n  /** Per-shot model override (e.g. a stronger model for the engineer shot). */\n  model?: string\n}\n\nexport interface ShotSpec {\n  /** present ⇒ continue this artifact (depth); absent ⇒ the shot opens a fresh one (sample/restart). */\n  handle?: ArtifactHandle\n  messages?: Msg[]\n  steer?: string\n  persona?: ShotPersona\n  /** Restrict THIS shot to a subset of the domain's tools (by name) — focus a shot on\n   *  the relevant capabilities. Restriction-only; unknown names throw. Omitted ⇒ all. */\n  tools?: string[]\n}\nexport interface StrategyResult {\n  score: number\n  resolved: boolean\n  completions: number\n  progression: number[]\n  shots: number\n}\n/** Artifact lifecycle a strategy may manage itself — open/close ONLY. Raw `call`/`score`\n *  are withheld: scores reach the body solely through `shot()`'s ShotResult (the\n *  harness-verified channel), so a body cannot peek the check or fabricate around it. */\nexport interface StrategyArtifacts {\n  readonly name: string\n  open(task: AgenticTask): Promise<ArtifactHandle>\n  close(handle: ArtifactHandle): Promise<void>\n}\n\n/** What a strategy body composes with: the artifact lifecycle, the budget, and the two steps. */\nexport interface StrategyCtx {\n  /** Open/close artifacts the body manages itself (e.g. one persistent handle for depth). */\n  readonly surface: StrategyArtifacts\n  readonly task: AgenticTask\n  readonly opts: AgenticOptions\n  readonly budget: number\n  readonly scope: Scope<Outcome<unknown>>\n  /** Run ONE worker shot; its harness-scored result, or null if it went down. */\n  shot(spec?: ShotSpec): Promise<ShotResult | null>\n  /** The firewalled critic reads the trajectory → a steer string, or null on COMPLETE/down. */\n  critique(messages: Msg[]): Promise<string | null>\n  /** The RAW analyst channel: the firewalled critic answers `instruction` over the\n   *  trajectory verbatim — no findings extraction, so verdict-shaped formats\n   *  (CONTINUE/STOP decisions, calibrated predictions) survive. Same firewall:\n   *  trajectory in, never scores. Null when the analyst went down. */\n  consult(messages: Msg[], instruction: string): Promise<string | null>\n  /** The tools THIS artifact's task actually offers (names + descriptions only — never\n   *  the implementations). Tool sets vary per task on heterogeneous domains; a strategy\n   *  that restricts shots MUST select from this list, never from hardcoded names. */\n  listTools(handle: ArtifactHandle): Promise<Array<{ name: string; description?: string }>>\n}\n\n/** Author a Strategy from the composable steps — the open, compact way. */\nexport function defineStrategy(\n  name: string,\n  run: (ctx: StrategyCtx) => Promise<StrategyResult>,\n): Strategy {\n  return {\n    name,\n    driver: (surface, task, opts, budget) => ({\n      name,\n      async act(_t, scope): Promise<Outcome<unknown>> {\n        let seq = 0\n        const innerTurns = opts.innerTurns ?? 4\n        // HARNESS-VERIFIED scoring: the deliverable score is computed HERE from the shots\n        // the harness actually brokered + scored via surface.score() — NEVER the value the\n        // (possibly authored / adversarial) body returns. An authored strategy cannot\n        // fabricate a win; it can only report what its real shots achieved. Keep-best.\n        let verifiedBest = 0\n        let verifiedResolved = false\n        // Close is IDEMPOTENT by construction for the body: authored code double-closes\n        // (often as a floating promise inside a finally), and a second close must be a\n        // no-op rather than a domain error that escapes as an unhandled rejection and\n        // kills the whole benchmark run. A close failure on a LIVE handle still throws.\n        const openHandles = new Set<string>()\n        const ctx: StrategyCtx = {\n          // Narrowed to open/close — the body gets no raw call()/score() access.\n          surface: {\n            name: surface.name,\n            open: async (t) => {\n              const h = await surface.open(t)\n              openHandles.add(h.id)\n              return h\n            },\n            close: async (h) => {\n              if (!h || !openHandles.has(h.id)) return\n              openHandles.delete(h.id)\n              await surface.close(h)\n            },\n          },\n          task,\n          opts,\n          budget,\n          scope,\n          async shot(spec) {\n            const child = leaf(`shot:${seq}`, 'shot')\n            seq += 1\n            const res = scope.spawn(\n              child,\n              {\n                task,\n                handle: spec?.handle,\n                messages: spec?.messages,\n                steer: spec?.steer,\n                persona: spec?.persona,\n                tools: spec?.tools,\n              } as ShotTask,\n              { budget: perChild(innerTurns), label: child.name },\n            )\n            if (!res.ok) return null\n            const settled = await drainOne(scope)\n            if (settled.kind === 'down') return null\n            const out = settled.out as unknown as ShotResult\n            if (out.score > verifiedBest) verifiedBest = out.score\n            if (out.total > 0 && out.passes === out.total) verifiedResolved = true\n            return out\n          },\n          async listTools(handle) {\n            const tools = await surface.tools(task, handle)\n            return tools.map((t) => ({\n              name: t.function.name,\n              ...(t.function.description ? { description: t.function.description } : {}),\n            }))\n          },\n          async critique(messages) {\n            const child = leaf(`analyst:${seq}`, 'analyst')\n            seq += 1\n            const res = scope.spawn(\n              child,\n              { task, messages },\n              { budget: perChild(1), label: child.name },\n            )\n            if (!res.ok) return null\n            const settled = await drainOne(scope)\n            if (settled.kind === 'down') return null\n            const findings = settled.out as unknown as string\n            return /^\\s*COMPLETE\\b/i.test(findings) ? null : findings\n          },\n          async consult(messages, instruction) {\n            const child = leaf(`analyst:${seq}`, 'analyst')\n            seq += 1\n            const res = scope.spawn(\n              child,\n              { task, messages, rawInstruction: instruction },\n              { budget: perChild(1), label: child.name },\n            )\n            if (!res.ok) return null\n            const settled = await drainOne(scope)\n            if (settled.kind === 'down') return null\n            return settled.out as unknown as string\n          },\n        }\n        const r = await run(ctx)\n        // Override the body's self-reported score/resolved with the harness-verified\n        // values. The body's progression/completions/shots are advisory (display only) —\n        // but NORMALIZED: an authored body that omits them must not poison downstream\n        // consumers (losses tables, anytime curves) with undefined.\n        return {\n          kind: 'done',\n          deliverable: {\n            mode: name,\n            ...r,\n            progression: Array.isArray(r.progression) ? r.progression : [],\n            completions: typeof r.completions === 'number' ? r.completions : 0,\n            shots: typeof r.shots === 'number' ? r.shots : 0,\n            score: verifiedBest,\n            resolved: verifiedResolved,\n          },\n        }\n      },\n    }),\n  }\n}\n\n/** A NEW strategy, authored from the steps (~20 lines): refine, but when a steered shot\n *  fails to improve the score it ABANDONS that line and restarts fresh (branch-when-stuck)\n *  — the widen/MCTS idea the depth-stuck failure motivated. Scored keep-best (the best\n *  checkpoint across all lines), the deployable metric. This is the \"experts build BETTER\n *  optimizations\" path: a new technique, compact, with zero Supervisor ceremony. */\nexport const adaptiveRefine = defineStrategy(\n  'adaptiveRefine',\n  async ({ surface, task, budget, shot, critique }) => {\n    let handle = await surface.open(task)\n    const progression: number[] = []\n    let messages: Msg[] | undefined\n    let steer: string | undefined\n    let completions = 0\n    let best = -1\n    let shots = 0\n    try {\n      for (shots = 0; shots < budget; shots += 1) {\n        const out = await shot({ handle, messages, steer })\n        if (!out) break\n        completions += out.completions\n        progression.push(out.score)\n        if (out.score >= 1) break\n        if (out.score <= best) {\n          // Stuck: steering isn't improving this line — abandon it, restart fresh.\n          await surface.close(handle)\n          handle = await surface.open(task)\n          messages = undefined\n          steer = undefined\n          continue\n        }\n        best = out.score\n        messages = out.messages\n        const findings = await critique(out.messages)\n        completions += 1\n        if (!findings) break\n        steer = `A reviewer flagged unfinished items:\\n${findings}\\n\\nAddress each with the tools, verify they took, then continue.`\n      }\n      const score = progression.length ? Math.max(...progression) : 0\n      return { score, resolved: score >= 1, completions, progression, shots }\n    } finally {\n      await surface.close(handle)\n    }\n  },\n)\n\n/** The explore-then-exploit MIX: spend ⌈budget/2⌉ on independent samples (kept open),\n *  then refine the best-verifying line with the remaining budget. Sample's basin escape +\n *  refine's accumulation — the third built-in, authored from the public steps. */\nexport const sampleThenRefine = defineStrategy(\n  'sampleThenRefine',\n  async ({ surface, task, budget, shot, critique }) => {\n    const explore = Math.max(1, Math.ceil(budget / 2))\n    const open = new Set<ArtifactHandle>()\n    const progression: number[] = []\n    let completions = 0\n    let shots = 0\n    try {\n      // Explore: independent lines on handles we own (kept open so the best can continue).\n      let best: { handle: ArtifactHandle; out: ShotResult } | undefined\n      for (let i = 0; i < explore; i += 1) {\n        const handle = await surface.open(task)\n        open.add(handle)\n        const out = await shot({ handle })\n        if (!out) continue\n        shots += 1\n        completions += out.completions\n        progression.push(out.score)\n        if (!best || out.score > best.out.score) best = { handle, out }\n        if (out.score >= 1) break\n      }\n      if (!best) return { score: 0, resolved: false, completions, progression, shots }\n      // Exploit: close the losers, refine the winner with the remaining budget.\n      for (const h of [...open]) {\n        if (h !== best.handle) {\n          await surface.close(h)\n          open.delete(h)\n        }\n      }\n      let messages = best.out.messages\n      let topScore = best.out.score\n      for (let i = explore; i < budget && topScore < 1; i += 1) {\n        const findings = await critique(messages)\n        completions += 1\n        if (!findings) break\n        const out = await shot({\n          handle: best.handle,\n          messages,\n          steer: `A reviewer flagged unfinished items:\\n${findings}\\n\\nAddress each with the tools, verify they took, then continue.`,\n        })\n        if (!out) break\n        shots += 1\n        completions += out.completions\n        progression.push(out.score)\n        messages = out.messages\n        if (out.score > topScore) topScore = out.score\n      }\n      const score = progression.length ? Math.max(...progression) : 0\n      return { score, resolved: score >= 1, completions, progression, shots }\n    } finally {\n      for (const h of open) await surface.close(h)\n    }\n  },\n)\n\nexport interface RunAgenticOptions extends AgenticOptions {\n  surface: AgenticSurface\n  task: AgenticTask\n  /** Lifecycle observability — every spawn/settle (shots, analysts) streams here live.\n   *  The seam online watchdogs/route-auditors subscribe to. */\n  hooks?: RuntimeHooks\n  /** A Strategy (the open way) — author/pass your own. Overrides `mode` when present. */\n  strategy?: Strategy\n  /** Built-in shorthand: 'depth'→refine, 'breadth'→sample. Default 'depth'. */\n  mode?: 'depth' | 'breadth'\n  /** budget: refine→max shots; sample→rollout width. */\n  budget: number\n  rootBudget?: Budget\n}\n\n/** Run a Strategy through the keystone Supervisor — `Agent.act` over a conserved-budget Scope. */\nexport async function runAgentic(opts: RunAgenticOptions): Promise<AgenticRunResult> {\n  const strategy: Strategy = opts.strategy ?? (opts.mode === 'breadth' ? sample : refine)\n  const driver = strategy.driver(opts.surface, opts.task, opts, opts.budget)\n  const supervisor = createSupervisor<unknown, Outcome<unknown>>()\n  const root: Budget = opts.rootBudget ?? {\n    maxIterations: opts.budget * ((opts.innerTurns ?? 4) + 2),\n    maxTokens: 1_000_000_000,\n  }\n  const started = Date.now()\n  const result = await supervisor.run(driver, undefined, {\n    budget: root,\n    runId: `agentic:${strategy.name}:${opts.task.id}`,\n    journal: new InMemorySpawnJournal(),\n    blobs: new InMemoryResultBlobStore(),\n    executors: agenticRegistry(opts.surface, opts),\n    maxDepth: 3,\n    ...(opts.hooks ? { hooks: opts.hooks } : {}),\n  })\n  if (result.kind !== 'winner' || result.out.kind !== 'done') {\n    const reason =\n      result.kind === 'winner'\n        ? `blocked: ${(result.out as { blockers?: string[] }).blockers?.join('; ')}`\n        : `no-winner: ${result.reason}`\n    throw new Error(`runAgentic(${strategy.name}) produced no result — ${reason}`)\n  }\n  // Drivers deliver the strategy outcome; the cost vector is stamped here from the\n  // conserved pool's aggregate (every shot reported real usage into it) + wall clock.\n  const core = result.out.deliverable as Omit<AgenticRunResult, 'usd' | 'ms' | 'tokens'>\n  return {\n    ...core,\n    usd: result.spentTotal.usd,\n    tokens: result.spentTotal.tokens,\n    ms: Date.now() - started,\n  }\n}\n","/**\n * `openSandboxRun` — the ONE harness-agnostic seam for running an agent in a\n * sandbox over a persistent artifact: run it, stream it, RESUME the same session\n * across turns. Domain-agnostic: a coding agent, a research agent, a tax/legal\n * agent — all flow through this; the domain lives only in the `Deliverable<Out>`\n * the caller supplies, never in a per-domain copy of this function.\n *\n * It is a thin facade (NOT a new layer) over code that already exists and is\n * already hardened:\n *   - `acquireSandbox` — cold-start / 502-503-504 / gateway-timeout recovery,\n *   - `buildBackendOptions` — the harness IS `backend.type` (opencode / codex /\n *     claude-code / kimi-code / hermes / pi); the only \"which agent\" knob,\n *   - `createSandboxLineage` — `start` mints a session; `resume` continues the\n *     SAME server-side session with a fail-loud `assertSessionLive`.\n *\n * The one genuinely-new piece is {@link Deliverable}: it widens the pure\n * `OutputAdapter.parse(events)` to ALSO admit a post-turn read off the box FS —\n * the structural gap that made the bench gates hand-roll `box.fs.read`, because a\n * large produced file (a git diff, a generated document) truncates in the chat\n * stream and a pure events-parser cannot reach the workspace. Per the SDK, a\n * RELATIVE `deliverable.path` resolves from the workspace root and an ABSOLUTE one\n * (e.g. `/tmp/solution.patch`) reads the container filesystem directly — both are\n * valid; pick the one the agent actually wrote to. Avoid `..` traversal segments.\n *\n * What this deliberately does NOT do (so it stays a facade, not slop): no custom\n * reconnect/replay (the SDK + platform own per-session buffering + `Last-Event-ID`);\n * no fork verb (platform CRIU is probe-gated and currently absent — fork lives in\n * `SandboxLineage.fork` behind the capability probe, surfaced only if it returns).\n * It is also distinct from `runLoop`: `runLoop` is the multi-round, driver-driven\n * kernel (fresh box per round, events deliverable); this is a SINGLE rollout +\n * artifact-or-events deliverable + resume over ONE persistent box.\n */\n\nimport type { SandboxEvent, SandboxInstance } from '@tangle-network/sandbox'\nimport type { RuntimeHooks, RuntimeHookTarget } from '../runtime-hooks'\nimport { notifyRuntimeHookEvent } from '../runtime-hooks'\nimport { probeSandboxCapabilities } from './sandbox-capabilities'\nimport { createSandboxLineage, type SandboxLineageHandle } from './sandbox-lineage'\nimport type { AgentRunSpec, SandboxClient } from './types'\nimport { randomSuffix, sleep, throwIfAborted } from './util'\n\n/**\n * @experimental\n * How a typed deliverable `Out` is materialized from a finished turn.\n * - `events`   — pure parse over the event array (identical to `OutputAdapter`).\n * - `artifact` — read a file off the box AFTER the turn drains, then map it (+ the\n *                events). For diffs/codebases/documents that don't fit the chat\n *                stream. `path` relative ⇒ workspace root; absolute ⇒ container FS.\n */\nexport type Deliverable<Out> =\n  | { kind: 'events'; fromEvents: (events: SandboxEvent[]) => Out }\n  | { kind: 'artifact'; path: string; fromArtifact: (raw: string, events: SandboxEvent[]) => Out }\n\n/**\n * @experimental\n * One finished turn over the artifact. A failed FS read is surfaced in `readError`\n * (never masked as an empty deliverable) so a caller distinguishes \"agent produced\n * nothing\" from a transport/FS fault.\n */\nexport interface TurnResult<Out> {\n  out: Out\n  events: SandboxEvent[]\n  readError?: string\n}\n\n/** @experimental A live run over ONE persistent artifact (box + session). Close it\n *  when done — `close()` tears the box down. */\nexport interface SandboxRun<Out> {\n  readonly box: SandboxInstance\n  readonly sessionId: string\n  /** First turn over the fresh box (mints the session). Throws if already started. */\n  start(prompt: string): Promise<TurnResult<Out>>\n  /** Continue THE SAME session over THE SAME artifact — a resumed turn/rollout. */\n  resume(prompt: string): Promise<TurnResult<Out>>\n  close(): Promise<void>\n}\n\n/** @experimental */\nexport interface OpenSandboxRunOptions {\n  /** Profile + sandbox env/overrides. `sandboxOverrides.backend.type` is the harness. */\n  agentRun: AgentRunSpec<string>\n  signal: AbortSignal\n  /** Optional execution-scoped observers. Hook failures never fail the run. */\n  hooks?: RuntimeHooks\n  /** Stable run id for trace joins. Defaults to a short runtime-minted id. */\n  runId?: string\n  /** Optional benchmark/scenario id carried into emitted hook events. */\n  scenarioId?: string\n  /** Test seam for deterministic hook timestamps. Defaults to `Date.now`. */\n  now?: () => number\n  /** Bounds box-creation bursts inside lineage fanout. Default from lineage. */\n  maxConcurrency?: number\n  /** Base backoff (ms) for retrying a transient artifact `fs.read` failure; the i-th\n   *  retry waits `readRetryDelayMs * i`. Default 1000. Set 0 to disable the wait (tests). */\n  readRetryDelayMs?: number\n}\n\n/**\n * @experimental\n * Open a sandbox run. Harness-agnostic: the harness lives in\n * `options.agentRun.sandboxOverrides.backend.type`, so opencode/codex/claude-code/\n * kimi-code all flow through this one entrypoint with identical env/auth wiring.\n */\nexport async function openSandboxRun<Out>(\n  client: SandboxClient,\n  options: OpenSandboxRunOptions,\n  deliverable: Deliverable<Out>,\n): Promise<SandboxRun<Out>> {\n  const runId = options.runId ?? `sandbox-run-${randomSuffix()}`\n  const now = options.now ?? Date.now\n  const capabilities = await probeSandboxCapabilities(client)\n  const lineage = createSandboxLineage(client, capabilities, {\n    ...(options.maxConcurrency !== undefined ? { maxConcurrency: options.maxConcurrency } : {}),\n  })\n  let handle: SandboxLineageHandle | undefined\n  let started = false\n  let runStartedAt: number | undefined\n  let failed = false\n  let turnCount = 0\n\n  function emit(event: {\n    target: RuntimeHookTarget\n    phase: 'before' | 'after' | 'error'\n    timestamp: number\n    stepIndex?: number\n    payload?: Record<string, unknown>\n  }): void {\n    notifyRuntimeHookEvent(\n      options.hooks,\n      {\n        id: `${runId}:${event.target}:${event.phase}${\n          event.stepIndex === undefined ? '' : `:${event.stepIndex}`\n        }`,\n        runId,\n        scenarioId: options.scenarioId,\n        target: event.target,\n        phase: event.phase,\n        timestamp: event.timestamp,\n        stepIndex: event.stepIndex,\n        payload: event.payload,\n        metadata: { producer: 'openSandboxRun' },\n      },\n      { signal: options.signal },\n    )\n  }\n\n  const runPayload = (): Record<string, unknown> => ({\n    agentName: options.agentRun.name ?? options.agentRun.profile.name ?? 'agent',\n    profileName: options.agentRun.profile.name,\n    backendType: backendType(options.agentRun),\n    deliverableKind: deliverable.kind,\n    ...(deliverable.kind === 'artifact' ? { deliverablePath: deliverable.path } : {}),\n    ...(handle ? { sessionId: handle.sessionId, sandboxId: handle.box.id } : {}),\n  })\n\n  const turnPayload = (\n    prompt: string,\n    turnKind: 'start' | 'resume',\n    startedAt: number,\n    result?: TurnResult<Out>,\n    error?: unknown,\n  ): Record<string, unknown> => ({\n    ...runPayload(),\n    turnKind,\n    promptChars: prompt.length,\n    promptHash: hashText(prompt),\n    ...(result !== undefined || error !== undefined\n      ? { durationMs: Math.max(0, now() - startedAt) }\n      : {}),\n    ...(result\n      ? {\n          eventCount: result.events.length,\n          eventTypes: eventTypeCounts(result.events),\n          ...(result.readError !== undefined ? { readError: result.readError } : {}),\n        }\n      : {}),\n    ...(error !== undefined ? { error: errorMessage(error) } : {}),\n  })\n\n  // `box` is passed in (not read from the closed-over `handle`) so the invariant\n  // is type-level, not call-order discipline.\n  async function settle(\n    box: SandboxInstance,\n    events: AsyncIterable<SandboxEvent>,\n  ): Promise<TurnResult<Out>> {\n    const collected: SandboxEvent[] = []\n    for await (const ev of events) collected.push(ev)\n    if (deliverable.kind === 'events') {\n      return { out: deliverable.fromEvents(collected), events: collected }\n    }\n    throwIfAborted(options.signal)\n    let raw = ''\n    let readError: string | undefined\n    // The data plane can transiently 404 a just-written artifact (write not yet\n    // flushed, or an edge-read blip) — retry a few times with backoff before\n    // declaring the deliverable empty, so a transient read failure is not recorded\n    // as \"the agent produced nothing\".\n    const readAttempts = 4\n    const readDelayMs = options.readRetryDelayMs ?? 1000\n    for (let attempt = 0; attempt < readAttempts; attempt += 1) {\n      throwIfAborted(options.signal)\n      try {\n        raw = await box.fs.read(deliverable.path)\n        readError = undefined\n        break\n      } catch (err) {\n        readError = err instanceof Error ? err.message : String(err)\n        if (attempt < readAttempts - 1 && readDelayMs > 0)\n          await sleep(readDelayMs * (attempt + 1), options.signal)\n      }\n    }\n    return {\n      out: deliverable.fromArtifact(raw, collected),\n      events: collected,\n      ...(readError !== undefined ? { readError } : {}),\n    }\n  }\n\n  return {\n    get box(): SandboxInstance {\n      if (!handle) throw new Error('openSandboxRun: box unavailable before start()')\n      return handle.box\n    },\n    get sessionId(): string {\n      if (!handle) throw new Error('openSandboxRun: sessionId unavailable before start()')\n      return handle.sessionId\n    },\n    async start(prompt) {\n      if (started)\n        throw new Error(\n          'openSandboxRun: start() already called — use resume() to continue the session',\n        )\n      started = true\n      runStartedAt = now()\n      emit({\n        target: 'agent.run',\n        phase: 'before',\n        timestamp: runStartedAt,\n        payload: { ...runPayload(), turnCount: 0 },\n      })\n      const stepIndex = turnCount\n      const turnStartedAt = now()\n      emit({\n        target: 'agent.turn',\n        phase: 'before',\n        timestamp: turnStartedAt,\n        stepIndex,\n        payload: turnPayload(prompt, 'start', turnStartedAt),\n      })\n      // lineage.start uses only spec.profile + sandboxOverrides (the prompt is passed\n      // directly, not via taskToPrompt), so the task type is irrelevant here.\n      try {\n        const r = await lineage.start(\n          options.agentRun as AgentRunSpec<unknown>,\n          prompt,\n          options.signal,\n        )\n        handle = r.handle\n        const result = await settle(handle.box, r.events)\n        turnCount += 1\n        emit({\n          target: 'agent.turn',\n          phase: 'after',\n          timestamp: now(),\n          stepIndex,\n          payload: turnPayload(prompt, 'start', turnStartedAt, result),\n        })\n        return result\n      } catch (error) {\n        failed = true\n        emit({\n          target: 'agent.turn',\n          phase: 'error',\n          timestamp: now(),\n          stepIndex,\n          payload: turnPayload(prompt, 'start', turnStartedAt, undefined, error),\n        })\n        emit({\n          target: 'agent.run',\n          phase: 'error',\n          timestamp: now(),\n          payload: { ...runPayload(), turnCount, error: errorMessage(error) },\n        })\n        throw error\n      }\n    },\n    async resume(prompt) {\n      if (!handle) throw new Error('openSandboxRun: resume() called before start()')\n      const stepIndex = turnCount\n      const turnStartedAt = now()\n      emit({\n        target: 'agent.turn',\n        phase: 'before',\n        timestamp: turnStartedAt,\n        stepIndex,\n        payload: turnPayload(prompt, 'resume', turnStartedAt),\n      })\n      try {\n        const result = await settle(\n          handle.box,\n          await lineage.continue(handle, prompt, options.signal),\n        )\n        turnCount += 1\n        emit({\n          target: 'agent.turn',\n          phase: 'after',\n          timestamp: now(),\n          stepIndex,\n          payload: turnPayload(prompt, 'resume', turnStartedAt, result),\n        })\n        return result\n      } catch (error) {\n        failed = true\n        emit({\n          target: 'agent.turn',\n          phase: 'error',\n          timestamp: now(),\n          stepIndex,\n          payload: turnPayload(prompt, 'resume', turnStartedAt, undefined, error),\n        })\n        emit({\n          target: 'agent.run',\n          phase: 'error',\n          timestamp: now(),\n          payload: { ...runPayload(), turnCount, error: errorMessage(error) },\n        })\n        throw error\n      }\n    },\n    async close() {\n      await lineage.teardown()\n      if (runStartedAt !== undefined) {\n        emit({\n          target: 'agent.run',\n          phase: 'after',\n          timestamp: now(),\n          payload: {\n            ...runPayload(),\n            turnCount,\n            status: failed ? 'error' : 'completed',\n            durationMs: Math.max(0, now() - runStartedAt),\n          },\n        })\n      }\n    },\n  }\n}\n\nfunction backendType<Task>(spec: AgentRunSpec<Task>): unknown {\n  const backend = spec.sandboxOverrides?.backend as { type?: unknown } | undefined\n  return backend?.type\n}\n\nfunction eventTypeCounts(events: SandboxEvent[]): Record<string, number> {\n  const counts: Record<string, number> = {}\n  for (const event of events) counts[event.type] = (counts[event.type] ?? 0) + 1\n  return counts\n}\n\nfunction hashText(value: string): string {\n  let hash = 2166136261\n  for (let i = 0; i < value.length; i += 1) {\n    hash ^= value.charCodeAt(i)\n    hash = Math.imul(hash, 16777619)\n  }\n  return (hash >>> 0).toString(16).padStart(8, '0')\n}\n\nfunction errorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error)\n}\n","/**\n * authorStrategy — the agent-authored layer as a package primitive (software-3.0): an\n * LLM reads a benchmark's per-task LOSSES + the defineStrategy contract and writes a NEW\n * optimization strategy as code; the caller gates it like any human-built candidate\n * (runBenchmark + a frozen holdout).\n *\n * Structurally safe by construction: the authored body composes shot()/critique() and\n * spends through the Supervisor's conserved pool — it can be wrong, but it cannot\n * Goodhart the check (it never sees the verifiers) and it cannot win by overspending.\n *\n * The authored module is written to `outDir` and dynamically imported — run under a\n * TS-capable loader (tsx) since models often emit type annotations.\n */\n\nimport { mkdirSync, writeFileSync } from 'node:fs'\nimport { join } from 'node:path'\nimport type { ChatClient } from '@tangle-network/agent-eval'\nimport type { Strategy } from './strategy'\n\n/** The compressed consumable a skill carries: everything an author needs to emit a loop. */\nexport const strategyAuthorContract = `\nYou author an OPTIMIZATION STRATEGY for an agentic loop system. A strategy decides how to\nspend a compute budget to beat a task's deployable check. You compose exactly two steps:\n\n  shot(spec?: { handle?, messages?, steer?, persona?, tools? }): Promise<ShotResult | null>\n    Runs ONE worker attempt (a bounded tool loop) over an artifact.\n    - omit handle  => the shot opens its OWN fresh artifact and closes it after (a sample).\n    - pass handle  => the shot CONTINUES that artifact (state accumulates across shots).\n    - messages     => the carried conversation (pass the previous ShotResult.messages to continue).\n    - steer        => a corrective instruction injected before the shot.\n    - persona      => { systemPrompt?, model? } — give THIS shot its own role and/or model\n      (multi-agent strategies: a researcher shot then an engineer shot, a panel of k\n      personas over one budget). On a fresh shot the systemPrompt replaces the task's; on\n      a carried conversation it arrives as a hand-off message. Same conserved budget.\n    - tools        => string[] — restrict THIS shot to a subset of the task's tools by\n      name (focus an explore shot on read-only tools, an execute shot on write tools).\n      Restriction-only; unknown names make the shot fail. ALWAYS select from\n      await listTools(handle) — never hardcode. Omitted => the shot sees every tool.\n    ShotResult = { messages, score (0..1 on the task's check), passes, total, completions, toolErrors }\n    Returns null if the attempt failed infra-wise.\n\n  critique(messages): Promise<string | null>\n    A firewalled trace-analyst reads the attempt's trajectory and returns ONE corrective\n    instruction (or null when it judges the work complete). Costs ~1 completion.\n\n  consult(messages, instruction): Promise<string | null>\n    The RAW analyst channel: the same firewalled critic answers YOUR instruction over the\n    trajectory verbatim (no reformatting) — use it when you need a specific reply format\n    (a decision, a prediction). Costs ~1 completion.\n\n  surface.open(task) / surface.close(handle)\n    Open a persistent artifact you manage yourself (remember to close in a finally).\n    close is idempotent — closing an already-closed handle is a safe no-op.\n\n  listTools(handle): Promise<Array<{ name, description? }>>\n    The tools THIS task actually offers. TOOL SETS VARY PER TASK — if you restrict a\n    shot with \\`tools\\`, you MUST pick names from await listTools(handle); hardcoding\n    names from an example kills your shots on every task whose tools differ.\n\nRules:\n- ALWAYS await every shot/critique/surface call — a floating promise that rejects\n  crashes the whole benchmark run.\n- Stay within ~budget total shots; every shot/critique spends from a conserved pool.\n- For a FRESH attempt OMIT \\`messages\\` entirely (never pass \\`[]\\` — an empty array is a\n  fresh conversation too, but be explicit). To CONTINUE, pass the previous\n  ShotResult.messages unchanged.\n- Return { score, resolved, completions, progression, shots } — score = the BEST checkpoint\n  you reached (keep-best, never final-state), progression = score after each shot.\n- The module must be EXACTLY this shape (no other imports, no commentary outside code):\n\nimport { defineStrategy } from '@tangle-network/agent-runtime/loops'\nexport default defineStrategy('your-strategy-name', async ({ surface, task, budget, shot, critique, listTools }) => {\n  // your composition (listTools comes from the destructured context — it is NOT a global)\n})\n`\n\nexport interface AuthorStrategyOptions {\n  /** The model-call seam (agent-eval `createChatClient`). */\n  chat: ChatClient\n  model?: string\n  /** A NAMED fallback author tried once when the primary call fails or returns no code\n   *  block (thinking models time out at the edge on long authoring prompts, or return\n   *  empty content without `maxTokens`). Opt-in — absent means the primary's failure\n   *  propagates. */\n  fallbackModel?: string\n  /** The contract text shown to the author. Default `strategyAuthorContract`. The\n   *  meta-optimization coordinate: a GEPA/skill loop can evolve this text and gate each\n   *  variant on the same frozen holdout as any strategy. */\n  contract?: string\n  /** The environment the losses came from (orientation only — never the verifiers). */\n  environmentName: string\n  /** The per-task losses table (e.g. JSON.stringify(report.perTask)) — the gradient. */\n  lossesJson: string\n  /** The budget the strategy must respect (shots/width). */\n  budget: number\n  /** Where the authored module file is written (created if missing). */\n  outDir: string\n  temperature?: number\n  /** Completion cap — required by thinking-model authors that stream reasoning first. */\n  maxTokens?: number\n  signal?: AbortSignal\n}\n\n/** Static CONTRACT lint over an authored strategy module — the module-boundary\n *  enforcement of the harness's two measurement invariants:\n *    - author blindness: the only import allowed is the loops surface. A body that could\n *      reach the filesystem, network, or process could read or mutate verifier/artifact\n *      state outside the brokered shots, and the harness-verified score would stop\n *      meaning \"what the shots achieved\".\n *    - conserved dose: no out-of-band compute (fetch/require/eval) — every unit a\n *      strategy spends is metered by the Supervisor's pool, which is what makes\n *      equal-budget comparisons between strategies valid.\n *  A lint, not a sandbox: its job is keeping the benchmark numbers interpretable. */\nexport function assertStrategyContract(code: string): void {\n  const allowedImport =\n    /^\\s*import\\s+\\{[^}]*\\}\\s+from\\s+['\"]@tangle-network\\/agent-runtime\\/loops['\"]/\n  for (const line of code.split('\\n')) {\n    if (/^\\s*import\\s/.test(line) && !allowedImport.test(line)) {\n      throw new Error(`authored code rejected: foreign import — ${line.trim().slice(0, 120)}`)\n    }\n  }\n  const banned: Array<[RegExp, string]> = [\n    [/\\brequire\\s*\\(/, 'require()'],\n    [/\\bimport\\s*\\(/, 'dynamic import()'],\n    [/\\beval\\s*\\(/, 'eval()'],\n    [/new\\s+Function\\s*\\(/, 'new Function()'],\n    [/\\bprocess\\s*[.[]/, 'process access'],\n    [/\\bglobalThis\\s*[.[]/, 'globalThis access'],\n    [/\\bfetch\\s*\\(/, 'network access'],\n    [/child_process|node:fs|node:net|node:http|worker_threads/, 'node builtin access'],\n  ]\n  for (const [re, what] of banned) {\n    if (re.test(code)) throw new Error(`authored code rejected: ${what}`)\n  }\n}\n\nexport interface AuthoredStrategy {\n  strategy: Strategy\n  file: string\n  code: string\n}\n\n/** One authoring attempt: chat with the given model, extract the fenced module. Throws\n *  when the reply carries no code block. */\nasync function requestAuthoredCode(\n  opts: AuthorStrategyOptions,\n  model: string | undefined,\n): Promise<string> {\n  const res = await opts.chat.chat(\n    {\n      ...(model ? { model } : {}),\n      ...(opts.temperature !== undefined ? { temperature: opts.temperature } : {}),\n      ...(opts.maxTokens !== undefined ? { maxTokens: opts.maxTokens } : {}),\n      messages: [\n        {\n          role: 'system',\n          content:\n            'You are a senior engineer authoring optimization strategies for agent loops. Output exactly one fenced ```ts code block and nothing else.',\n        },\n        {\n          role: 'user',\n          content: `${opts.contract ?? strategyAuthorContract}\\n\\nBASELINE RESULTS on the \"${opts.environmentName}\" environment (budget=${opts.budget}):\\n${opts.lossesJson}\\n\\nAuthor ONE new strategy that you expect to beat the baselines on THIS environment at the same budget. Use the losses to target the observed failure mode. Output only the module code block.`,\n        },\n      ],\n    },\n    { ...(opts.signal ? { signal: opts.signal } : {}) },\n  )\n  const match = res.content.match(/```(?:ts|typescript)?\\s*\\n([\\s\\S]*?)```/)\n  if (!match?.[1]) {\n    throw new Error(\n      `authorStrategy: no code block in the author's reply (model=${model ?? 'default'}): ${res.content.slice(0, 300)}`,\n    )\n  }\n  return match[1]\n}\n\n/** Author + load a strategy from losses. Throws when the author emits no loadable module;\n *  with `fallbackModel` set, the named fallback gets one attempt first. */\nexport async function authorStrategy(opts: AuthorStrategyOptions): Promise<AuthoredStrategy> {\n  let code: string\n  try {\n    code = await requestAuthoredCode(opts, opts.model)\n  } catch (primaryError) {\n    if (!opts.fallbackModel) throw primaryError\n    code = await requestAuthoredCode(opts, opts.fallbackModel)\n  }\n  assertStrategyContract(code)\n  mkdirSync(opts.outDir, { recursive: true })\n  const file = join(opts.outDir, `authored-${Date.now()}.mts`)\n  writeFileSync(file, code)\n  const mod = (await import(`file://${file}`)) as { default?: Strategy }\n  if (!mod.default || typeof mod.default.driver !== 'function' || !mod.default.name) {\n    throw new Error(`authorStrategy: ${file} does not export a default Strategy`)\n  }\n  return { strategy: mod.default, file, code }\n}\n","/**\n * runStrategyEvolution — the multi-generation strategy search: per generation the system\n * authors a POPULATION of candidate strategies from the current tournament's losses,\n * plays them against the incumbent at equal budget, and advances a champion; one final\n * promotion decision runs on a NEVER-BEFORE-USED holdout slice through `promotionGate`.\n *\n * Measurement invariants (the reasons this design is shaped the way it is):\n *  - The author sees TRAIN losses only. The holdout slice is drawn fresh (disjoint task\n *    offsets) after all authoring is done — one promotion decision, one untouched slice,\n *    so adaptive reuse of evaluation data never enters the verdict.\n *  - Every tournament runs at the same per-strategy budget through the conserved pool;\n *    candidates cannot win by overspending.\n *  - Champion selection within the search is a SEARCH policy (configurable, default\n *    cost-aware: ties on score go to the cheapest strategy — a scalar hides a strategy\n *    that ties at half the cost). The promotion verdict never comes from search\n *    selection; it comes from the gate on the fresh slice.\n *  - Every authored artifact's description length (gzip bits) is recorded, so the\n *    artifact-complexity-vs-holdout-gap relation is analyzable from any run's report.\n *\n * Lineage fields (`parent`, `generation`) are recorded on every archive node so a\n * descendant-productivity parent-selection policy can be added without changing the\n * report schema; the v1 search authors from the latest tournament's losses.\n */\n\nimport { existsSync, readFileSync, writeFileSync } from 'node:fs'\nimport { gzipSync } from 'node:zlib'\nimport type { ChatClient } from '@tangle-network/agent-eval'\nimport type { RuntimeHooks } from '../runtime-hooks'\nimport { type PromotionVerdict, promotionGate } from './promotion-gate'\nimport {\n  type BenchmarkReport,\n  type BenchmarkTaskRow,\n  type Environment,\n  runBenchmark,\n} from './run-benchmark'\nimport {\n  type AgenticOptions,\n  type AgenticTask,\n  refine,\n  type Strategy,\n  sample,\n  sampleThenRefine,\n} from './strategy'\nimport { authorStrategy, strategyAuthorContract } from './strategy-author'\n\nexport interface EvolutionAuthor {\n  /** The model-call seam (agent-eval `createChatClient`). */\n  chat: ChatClient\n  model?: string\n  fallbackModel?: string\n  temperature?: number\n  maxTokens?: number\n}\n\nexport type ChampionPolicy = 'score' | 'costAware'\n\nexport interface StrategyEvolutionConfig {\n  environment: Environment\n  /** Task supply by DISJOINT slice: `(offset, n)` must return n tasks unique to that\n   *  offset range. Train draws [0, trainN); the holdout draws [trainN + holdoutOffset,\n   *  …) — tasks the search never touched. */\n  tasks: (offset: number, n: number) => Promise<AgenticTask[]>\n  trainN: number\n  holdoutN: number\n  /** Extra offset past the train slice for the holdout draw (rotate across runs). */\n  holdoutOffset?: number\n  worker: AgenticOptions\n  author: EvolutionAuthor\n  /** Rollouts (sample) / shots (refine) per strategy per task. Default 3. */\n  budget?: number\n  concurrency?: number\n  /** Author→tournament rounds after gen0. Default 2. */\n  generations?: number\n  /** Authored candidates per generation. Default 2. */\n  populationSize?: number\n  /** The gen0 field. Default [sample, refine, sampleThenRefine]. */\n  baselines?: Strategy[]\n  /** What \"better\" means for PROMOTION. 'score' (default): the candidate must beat the\n   *  incumbent's score (superiority gate). 'cost': the candidate must prove score\n   *  NON-INFERIORITY (not worse by more than `scoreTolerance`) plus significant cost\n   *  savings — the \"same quality, cheaper\" objective. The author is told the objective\n   *  and sees per-task spend either way. */\n  objective?: 'score' | 'cost'\n  /** Cost objective: the score CI lower bound must clear −scoreTolerance. Default 0.05. */\n  scoreTolerance?: number\n  /** Search-side champion selection. Default 'costAware'. */\n  champion?: ChampionPolicy\n  /** Score band treated as a tie under 'costAware'. Default 0.01. */\n  championEpsilon?: number\n  /** Where authored modules are written. */\n  outDir: string\n  /** Promotion-gate evidence floor (paired holdout tasks). */\n  minPairedTasks?: number\n  /** BAND-AWARE scoring — concentrate the measurement where lift is possible.\n   *  Holdout: draw `holdoutPoolN` candidate tasks and run `baselines[0]` once at the run\n   *  budget as an INDEPENDENT reference screen; keep tasks scoring ≤ `maxRefScore`\n   *  (headroom exists) and take the first `holdoutN`. Band membership is decided before\n   *  either finalist touches a task and both finalists then face the SAME tasks — the\n   *  estimand becomes \"paired lift on headroom tasks\", pre-registered by this config.\n   *  Train: champion selection ignores zero-spread tasks (every field strategy scored\n   *  identically — zero selection information, pure noise dilution). */\n  band?: {\n    holdoutPoolN: number\n    /** Keep holdout tasks where the reference scores ≤ this. Default 0.99 — drop only\n     *  tasks the reference already solves fully (no headroom, a candidate can only tie). */\n    maxRefScore?: number\n  }\n  /** What the author learns from a tournament. 'exact' (default) = scores + progressions\n   *  per task; 'binary' = pass/fail only — the leakage-bounded channel (one bit per cell\n   *  per generation reaches the author from the evaluation data). */\n  lossesDetail?: 'exact' | 'binary'\n  /** Reproducer certification (arXiv:2606.11045): when the final champion is AUTHORED,\n   *  compress it to a short natural-language summary, have a fresh author re-implement\n   *  from the summary alone (no losses, no code), and score the reproduction on the same\n   *  holdout. A reproduction gap is an overfitting signal (their detector: 100%\n   *  sensitivity / 91% specificity in the ML-agent setting) — recorded on the report,\n   *  never gate-blocking in v1. */\n  reproducerCheck?: {\n    /** Word budget for the strategy summary. Default 64. */\n    summaryMaxWords?: number\n    /** Reproduction counts as faithful when reproducedScore ≥ championScore − tolerance.\n     *  Default 0.05. */\n    tolerance?: number\n  }\n  /** Endurance: write the run state after every completed phase; with `resume`, a\n   *  restart skips completed phases (authored modules re-imported from their files).\n   *  Worst case after a mid-run death is re-paying ONE phase, never the run. */\n  checkpoint?: {\n    path: string\n    resume?: boolean\n  }\n  /** Called before each benchmark phase (gen0, gen1…, band-screen, holdout, reproduce).\n   *  The seam for environment recycling — no artifacts span phases, so a runner may\n   *  recreate a wedge-prone environment container here. */\n  onPhase?: (phase: string) => Promise<void>\n  onTask?: (phase: string, row: BenchmarkTaskRow, done: number, total: number) => void\n  hooks?: RuntimeHooks\n}\n\n/** The on-disk phase ledger — everything needed to skip completed phases on resume. */\ninterface EvolutionCheckpoint {\n  gen0?: BenchmarkReport\n  gen0Champion?: ChampionPick\n  generations: EvolutionGeneration[]\n  archive: EvolutionArchiveNode[]\n  trajectory: Array<{ generation: number; champion: string; score: number; usd: number }>\n  holdout?: BenchmarkReport\n  verdict?: PromotionVerdict\n  band?: EvolutionBandInfo\n}\n\nexport interface ChampionPick {\n  name: string\n  score: number\n  usd: number\n}\n\nexport interface EvolutionCandidate {\n  name: string\n  file?: string\n  gzipBits?: number\n  codeChars?: number\n  /** Present when this author attempt failed (recorded, never silent). */\n  error?: string\n}\n\nexport interface EvolutionGeneration {\n  generation: number\n  candidates: EvolutionCandidate[]\n  report: BenchmarkReport\n  champion: ChampionPick\n}\n\nexport interface EvolutionArchiveNode {\n  name: string\n  source: 'baseline' | 'authored'\n  generation: number\n  /** The champion whose tournament losses this candidate was authored from. */\n  parent?: string\n  gzipBits?: number\n  file?: string\n  /** Latest measured tournament result — 0 until the node's first tournament settles\n   *  (an authored node is created before its generation's benchmark runs). */\n  score: number\n  usd: number\n}\n\nexport interface ReproductionCheck {\n  /** The compressed strategy description the reproducer implemented from. */\n  summary: string\n  reproducedName: string\n  file?: string\n  championHoldoutScore: number\n  reproducedHoldoutScore: number\n  /** champion − reproduced (positive = the reproduction fell short). */\n  gap: number\n  /** reproducedScore ≥ championScore − tolerance. A failed reproduction is an\n   *  overfitting signal: the champion's win did not fit through the summary. */\n  reproducible: boolean\n  /** Infra failure during reproduction (distinct from a semantic reproduction failure). */\n  error?: string\n}\n\nexport interface EvolutionBandInfo {\n  /** Tasks screened by the reference on the holdout pool. */\n  screened: number\n  /** Tasks kept (reference score ≤ maxRefScore) before truncating to holdoutN. */\n  inBand: number\n  /** Reference scores per screened task (the screening record). */\n  refScores: Array<{ taskId: string; score: number }>\n}\n\nexport interface EvolutionReport {\n  gen0: BenchmarkReport\n  gen0Champion: ChampionPick\n  generations: EvolutionGeneration[]\n  archive: EvolutionArchiveNode[]\n  finalChampion: ChampionPick\n  holdout: BenchmarkReport\n  verdict: PromotionVerdict\n  /** Present when band screening ran — the verdict's estimand is then \"paired lift on\n   *  headroom tasks\" (band membership fixed by the reference screen, pre-registered). */\n  band?: EvolutionBandInfo\n  /** Present when reproducerCheck ran (final champion was authored). */\n  reproduction?: ReproductionCheck\n  /** SEARCH TELEMETRY, not evidence: each entry is that generation's own train-slice\n   *  re-measurement, so cross-generation deltas mix true drift with run-to-run variance\n   *  (entries are unpaired across generations). The only evidence-grade comparison in\n   *  this report is `verdict` — both finalists measured fresh, paired, on the holdout. */\n  trajectory: Array<{ generation: number; champion: string; score: number; usd: number }>\n}\n\n/** Strategy means recomputed over the DISCRIMINATING tasks only — tasks where the field\n *  strategies did not all score identically. Zero-spread tasks (everyone 1.0, everyone\n *  0.0, everyone tied) carry no selection information; averaging over them dilutes real\n *  differences toward zero. Search-side denoising only — the gate never uses this. */\nexport function discriminatingMeans(\n  report: BenchmarkReport,\n  fieldOrder: string[],\n): Record<string, { score: number; usd: number }> | null {\n  const rows = report.perTask.filter((r) => {\n    if (!r.cells) return false\n    const scores = fieldOrder.map((n) => r.cells?.[n]?.score).filter((s) => s !== undefined)\n    if (scores.length < fieldOrder.length) return false\n    return Math.max(...scores) - Math.min(...scores) > 0\n  })\n  if (rows.length === 0) return null\n  const out: Record<string, { score: number; usd: number }> = {}\n  for (const name of fieldOrder) {\n    const cells = rows.map((r) => r.cells?.[name]).filter((c) => !!c)\n    out[name] = {\n      score: cells.reduce((s, c) => s + c.score, 0) / cells.length,\n      usd: cells.reduce((s, c) => s + c.usd, 0) / cells.length,\n    }\n  }\n  return out\n}\n\n/** The champion pick over a means table. 'score' takes the best mean score (ties →\n *  field order). 'costAware' treats scores within `epsilon` of the best as tied and\n *  takes the cheapest — the (score, $) Pareto rule collapsed to one pick. */\nexport function pickChampion(\n  means: Record<string, { score: number; usd: number }>,\n  fieldOrder: string[],\n  policy: ChampionPolicy,\n  epsilon: number,\n): ChampionPick {\n  const entries = fieldOrder\n    .map((name) => ({ name, summary: means[name] }))\n    .filter((e): e is { name: string; summary: NonNullable<typeof e.summary> } => !!e.summary)\n  if (entries.length === 0)\n    throw new Error('pickChampion: the means table carries none of the field strategies')\n  const best = Math.max(...entries.map((e) => e.summary.score))\n  const pick =\n    policy === 'score'\n      ? entries.find((e) => e.summary.score === best)\n      : entries\n          .filter((e) => e.summary.score >= best - epsilon)\n          .sort((a, b) => a.summary.usd - b.summary.usd || b.summary.score - a.summary.score)[0]\n  if (!pick) throw new Error('pickChampion: empty pick (unreachable)')\n  return { name: pick.name, score: pick.summary.score, usd: pick.summary.usd }\n}\n\n/** Search-side champion selection over a tournament report. */\nexport function selectChampion(\n  report: BenchmarkReport,\n  fieldOrder: string[],\n  policy: ChampionPolicy,\n  epsilon: number,\n): ChampionPick {\n  return pickChampion(report.perStrategy, fieldOrder, policy, epsilon)\n}\n\nconst fieldSummary = (archive: EvolutionArchiveNode[]): string =>\n  archive\n    .map(\n      (n) =>\n        `- ${n.name} (${n.source}, gen ${n.generation}, last score ${(n.score * 100).toFixed(0)}%)`,\n    )\n    .join('\\n')\n\n/** The author-visible losses: EVERY train task in compact form (score/resolved/\n *  progression per cell). A pretty-printed prefix slice would hide the tail tasks from\n *  the author and bias which failure modes it can target; the hard cap stays only as a\n *  guard against enormous fields. */\nconst compactLosses = (report: BenchmarkReport, detail: 'exact' | 'binary'): string => {\n  const r2 = (x: number) => Math.round(x * 100) / 100\n  const rows = report.perTask.map((row) =>\n    row.cells\n      ? {\n          task: row.taskId,\n          ...(row.errors\n            ? {\n                errors: Object.fromEntries(\n                  Object.entries(row.errors).map(([n, msg]) => [n, msg.slice(0, 100)]),\n                ),\n              }\n            : {}),\n          cells: Object.fromEntries(\n            Object.entries(row.cells).map(([name, c]) => [\n              name,\n              // 'binary' is the leakage-bounded channel: the author learns pass/fail per\n              // task and nothing else — the per-generation leak from the evaluation data\n              // is capped at one bit per cell (arXiv:2606.11045 measured that exploration\n              // survives this; whether AUTHORING does is the E1-coarse A/B).\n              detail === 'binary'\n                ? { resolved: c.resolved, usd: Math.round(c.usd * 10000) / 10000 }\n                : {\n                    score: r2(c.score),\n                    resolved: c.resolved,\n                    usd: Math.round(c.usd * 10000) / 10000,\n                    progression: (c.progression ?? []).map(r2),\n                  },\n            ]),\n          ),\n        }\n      : { task: row.taskId, error: row.error?.slice(0, 80) },\n  )\n  return JSON.stringify(rows).slice(0, 12000)\n}\n\n/** Rename a strategy AND the deliverable's mode label its driver closes over — report\n *  keys and observability labels must never diverge for a renamed candidate. */\nfunction renameStrategy(orig: Strategy, unique: string): Strategy {\n  if (orig.name === unique) return orig\n  return {\n    name: unique,\n    driver: (s, t, o, b) => {\n      const agent = orig.driver(s, t, o, b)\n      return {\n        ...agent,\n        name: unique,\n        act: async (task, scope) => {\n          const out = await agent.act(task, scope)\n          if (out.kind !== 'done') return out\n          const deliverable = { ...(out.deliverable as Record<string, unknown>), mode: unique }\n          return { ...out, deliverable }\n        },\n      }\n    },\n  }\n}\n\nexport async function runStrategyEvolution(cfg: StrategyEvolutionConfig): Promise<EvolutionReport> {\n  const budget = cfg.budget ?? 3\n  const concurrency = cfg.concurrency ?? 3\n  const generations = cfg.generations ?? 2\n  const populationSize = cfg.populationSize ?? 2\n  const baselines = cfg.baselines ?? [sample, refine, sampleThenRefine]\n  const policy = cfg.champion ?? 'costAware'\n  // FUNNEL ALIGNMENT: the search-side tie band must be no stricter than the promotion\n  // criterion, or the gate never sees the candidates it was designed to judge. Under the\n  // cost objective the gate accepts score within −scoreTolerance; a candidate that the\n  // gate would promote must therefore be able to DISPLACE in search at that same band.\n  const epsilon =\n    cfg.championEpsilon ?? (cfg.objective === 'cost' ? (cfg.scoreTolerance ?? 0.05) : 0.01)\n  const byName = new Map<string, Strategy>(baselines.map((s) => [s.name, s]))\n  const codeByName = new Map<string, string>()\n\n  // Endurance: the phase ledger. Resume refuses a checkpoint from a different design\n  // (silently mixing configs would corrupt every downstream comparison).\n  const fingerprint = {\n    trainN: cfg.trainN,\n    holdoutN: cfg.holdoutN,\n    budget,\n    generations,\n    populationSize,\n  }\n  let ckpt: EvolutionCheckpoint | undefined\n  if (cfg.checkpoint?.resume && existsSync(cfg.checkpoint.path)) {\n    const raw = JSON.parse(readFileSync(cfg.checkpoint.path, 'utf8')) as EvolutionCheckpoint & {\n      fingerprint?: typeof fingerprint\n    }\n    if (JSON.stringify(raw.fingerprint) !== JSON.stringify(fingerprint)) {\n      throw new Error(\n        `evolution resume: checkpoint design mismatch — checkpoint ${JSON.stringify(raw.fingerprint)} vs config ${JSON.stringify(fingerprint)}; delete ${cfg.checkpoint.path} or match the config`,\n      )\n    }\n    ckpt = raw\n  }\n  const save = (state: EvolutionCheckpoint): void => {\n    if (cfg.checkpoint)\n      writeFileSync(cfg.checkpoint.path, JSON.stringify({ ...state, fingerprint }, null, 1))\n  }\n\n  const bench = async (phase: string, tasks: AgenticTask[], strategies: Strategy[]) => {\n    await cfg.onPhase?.(phase)\n    return runBenchmark({\n      environment: cfg.environment,\n      tasks,\n      worker: cfg.worker,\n      strategies,\n      budget,\n      concurrency,\n      ...(cfg.onTask\n        ? { onTask: (row, done, total) => cfg.onTask?.(phase, row, done, total) }\n        : {}),\n      ...(cfg.hooks ? { hooks: cfg.hooks } : {}),\n    })\n  }\n\n  const train = await cfg.tasks(0, cfg.trainN)\n  // One probe round-trip lists the domain's tools so the author can write tool-focused\n  // shots (shot({tools})) — names + descriptions, never the implementations.\n  const probeTask = train[0]\n  if (!probeTask) throw new Error('runStrategyEvolution: empty train slice')\n  const probe = await cfg.environment.open(probeTask)\n  let toolCatalog: string\n  try {\n    const tools = await cfg.environment.tools(probeTask, probe)\n    toolCatalog = tools\n      .map(\n        (t) =>\n          `- ${t.function.name}${t.function.description ? ` — ${t.function.description.slice(0, 120)}` : ''}`,\n      )\n      .join('\\n')\n  } finally {\n    await cfg.environment.close(probe)\n  }\n  const gen0 = ckpt?.gen0 ?? (await bench('gen0', train, baselines))\n  const archive: EvolutionArchiveNode[] = ckpt?.archive\n    ? [...ckpt.archive]\n    : baselines.map((s) => ({\n        name: s.name,\n        source: 'baseline' as const,\n        generation: 0,\n        score: gen0.perStrategy[s.name]?.score ?? 0,\n        usd: gen0.perStrategy[s.name]?.usd ?? 0,\n      }))\n  const gen0Champion =\n    ckpt?.gen0Champion ??\n    selectChampion(\n      gen0,\n      baselines.map((s) => s.name),\n      policy,\n      epsilon,\n    )\n\n  const generationRows: EvolutionGeneration[] = ckpt?.generations ? [...ckpt.generations] : []\n  const trajectory = ckpt?.trajectory\n    ? [...ckpt.trajectory]\n    : [\n        {\n          generation: 0,\n          champion: gen0Champion.name,\n          score: gen0Champion.score,\n          usd: gen0Champion.usd,\n        },\n      ]\n  // Re-import resumed authored modules from their files (the collision rename re-applied\n  // so report keys stay stable across the restart).\n  for (const row of generationRows) {\n    for (const c of row.candidates) {\n      if (!c.file || c.error) continue\n      const mod = (await import(`file://${c.file}`)) as { default?: Strategy }\n      if (!mod.default || typeof mod.default.driver !== 'function') {\n        throw new Error(\n          `evolution resume: ${c.file} no longer exports a Strategy — cannot restore \"${c.name}\"`,\n        )\n      }\n      byName.set(c.name, renameStrategy(mod.default, c.name))\n      codeByName.set(c.name, readFileSync(c.file, 'utf8'))\n    }\n  }\n  let authoredOk = generationRows.reduce(\n    (n, row) => n + row.candidates.filter((c) => !c.error).length,\n    0,\n  )\n  const lastRow = generationRows[generationRows.length - 1]\n  let incumbent = lastRow ? lastRow.champion : gen0Champion\n  let latestReport = lastRow ? lastRow.report : gen0\n  if (!ckpt) save({ gen0, gen0Champion, generations: generationRows, archive, trajectory })\n\n  for (let g = generationRows.length + 1; g <= generations; g += 1) {\n    const lossesJson = compactLosses(latestReport, cfg.lossesDetail ?? 'exact')\n    const candidates: EvolutionCandidate[] = []\n    const newStrategies: Strategy[] = []\n    for (let i = 0; i < populationSize; i += 1) {\n      const objectiveNote =\n        cfg.objective === 'cost'\n          ? `\\n\\nYOUR OBJECTIVE: match or exceed the incumbent's SCORE while spending LESS (the losses include usd per task). Promotion requires proven score non-inferiority PLUS significant cost savings — a strategy that ties the score at half the cost WINS; a cheaper strategy that loses score by more than ${((cfg.scoreTolerance ?? 0.05) * 100).toFixed(0)}pp LOSES.`\n          : ''\n      const contract = `${strategyAuthorContract}${objectiveNote}\\n\\nEXAMPLE TOOLS FROM ONE TASK (tool sets VARY per task on this domain — a strategy MUST select tool names from await listTools(handle) at runtime; hardcoding these example names will zero your score on most tasks):\\n${toolCatalog}\\n\\nSTRATEGIES ALREADY IN THE TOURNAMENT (author something MEANINGFULLY different — a new composition, not a rename):\\n${fieldSummary(archive)}\\n\\nYou are authoring candidate ${i + 1} of ${populationSize} this generation; explore a distinct region of the strategy space from your siblings.`\n      try {\n        const authored = await authorStrategy({\n          chat: cfg.author.chat,\n          ...(cfg.author.model ? { model: cfg.author.model } : {}),\n          ...(cfg.author.fallbackModel ? { fallbackModel: cfg.author.fallbackModel } : {}),\n          ...(cfg.author.temperature !== undefined ? { temperature: cfg.author.temperature } : {}),\n          ...(cfg.author.maxTokens !== undefined ? { maxTokens: cfg.author.maxTokens } : {}),\n          contract,\n          environmentName: cfg.environment.name,\n          lossesJson,\n          budget,\n          outDir: cfg.outDir,\n        })\n        // A name collision with the archive would silently overwrite a report cell —\n        // disambiguate the strategy key. The defineStrategy driver closes over the\n        // ORIGINAL name for its deliverable's `mode` label, so the wrapper must rename\n        // the returned agent AND its deliverable or observability labels diverge from\n        // the report keys.\n        const unique = byName.has(authored.strategy.name)\n          ? `${authored.strategy.name}-g${g}c${i + 1}`\n          : authored.strategy.name\n        const strategy: Strategy = renameStrategy(authored.strategy, unique)\n        byName.set(unique, strategy)\n        codeByName.set(unique, authored.code)\n        newStrategies.push(strategy)\n        archive.push({\n          name: unique,\n          source: 'authored',\n          generation: g,\n          parent: incumbent.name,\n          gzipBits: gzipSync(Buffer.from(authored.code)).length * 8,\n          file: authored.file,\n          score: 0,\n          usd: 0,\n        })\n        candidates.push({\n          name: unique,\n          file: authored.file,\n          gzipBits: gzipSync(Buffer.from(authored.code)).length * 8,\n          codeChars: authored.code.length,\n        })\n        authoredOk += 1\n      } catch (e) {\n        candidates.push({\n          name: `(author-failed g${g}c${i + 1})`,\n          error: e instanceof Error ? e.message.slice(0, 300) : String(e),\n        })\n      }\n    }\n\n    const incumbentStrategy = byName.get(incumbent.name)\n    if (!incumbentStrategy)\n      throw new Error(`evolution: incumbent \"${incumbent.name}\" missing from the field`)\n    const field = [incumbentStrategy, ...newStrategies]\n    const report = await bench(`gen${g}`, train, field)\n    for (const node of archive) {\n      const cell = report.perStrategy[node.name]\n      if (cell) {\n        node.score = cell.score\n        node.usd = cell.usd\n      }\n    }\n    // With banding on, the champion is picked over the DISCRIMINATING tasks (any\n    // zero-spread task carries no selection information). Falls back to full means\n    // when every task tied — a degenerate generation, not an error.\n    const fieldNames = field.map((s) => s.name)\n    const means = cfg.band\n      ? (discriminatingMeans(report, fieldNames) ?? report.perStrategy)\n      : report.perStrategy\n    const champion = pickChampion(means, fieldNames, policy, epsilon)\n    generationRows.push({ generation: g, candidates, report, champion })\n    trajectory.push({\n      generation: g,\n      champion: champion.name,\n      score: champion.score,\n      usd: champion.usd,\n    })\n    incumbent = champion\n    latestReport = report\n    save({ gen0, gen0Champion, generations: generationRows, archive, trajectory })\n  }\n\n  if (authoredOk === 0) {\n    throw new Error(\n      'runStrategyEvolution: every author attempt failed across all generations — no search happened; see the candidates[].error entries',\n    )\n  }\n\n  // The promotion decision: ONE fresh slice the search never touched, drawn after all\n  // authoring is done. The gate, not the search policy, owns this verdict.\n  const holdoutOffset = cfg.trainN + (cfg.holdoutOffset ?? 0)\n  let holdoutTasks: AgenticTask[] = []\n  let bandInfo: EvolutionBandInfo | undefined\n  if (ckpt?.holdout && ckpt.verdict) {\n    // Gate already settled before the restart. Reconstruct the exact gate tasks only if\n    // the reproducer still needs to bench on them.\n    bandInfo = ckpt.band\n    if (cfg.reproducerCheck && codeByName.has(incumbent.name)) {\n      const pool = await cfg.tasks(holdoutOffset, cfg.band?.holdoutPoolN ?? cfg.holdoutN)\n      const gateIds = new Set(ckpt.holdout.perTask.map((r) => r.taskId))\n      holdoutTasks = pool.filter((t) => gateIds.has(t.id))\n    }\n  } else if (cfg.band) {\n    // Reference screening: baselines[0] runs once over the pool; tasks it already fully\n    // solves carry no headroom (a candidate can only tie there) and are dropped. The\n    // screen is independent of both finalists' gate runs — band membership is fixed\n    // before either touches a task, and both then face the SAME kept tasks.\n    const maxRef = cfg.band.maxRefScore ?? 0.99\n    const reference = baselines[0]\n    if (!reference)\n      throw new Error('evolution band: baselines[0] required as the screening reference')\n    const pool = await cfg.tasks(holdoutOffset, cfg.band.holdoutPoolN)\n    const screen = await bench('band-screen', pool, [reference])\n    const refScores = screen.perTask\n      .filter((r) => r.cells?.[reference.name])\n      .map((r) => ({ taskId: r.taskId, score: r.cells?.[reference.name]?.score ?? 0 }))\n    const inBandIds = new Set(refScores.filter((r) => r.score <= maxRef).map((r) => r.taskId))\n    const kept = pool.filter((t) => inBandIds.has(t.id))\n    if (kept.length < cfg.holdoutN) {\n      throw new Error(\n        `evolution band: only ${kept.length}/${cfg.holdoutN} holdout tasks have headroom (pool ${cfg.band.holdoutPoolN}, reference \"${reference.name}\" ≤ ${maxRef}) — widen holdoutPoolN or raise maxRefScore`,\n      )\n    }\n    holdoutTasks = kept.slice(0, cfg.holdoutN)\n    bandInfo = { screened: refScores.length, inBand: kept.length, refScores }\n  } else {\n    holdoutTasks = await cfg.tasks(holdoutOffset, cfg.holdoutN)\n  }\n  let holdout: BenchmarkReport\n  let verdict: PromotionVerdict\n  if (ckpt?.holdout && ckpt.verdict) {\n    holdout = ckpt.holdout\n    verdict = ckpt.verdict\n  } else {\n    const finalists = [...new Set([gen0Champion.name, incumbent.name])]\n      .map((n) => byName.get(n))\n      .filter((s): s is Strategy => !!s)\n    holdout = await bench('holdout', holdoutTasks, finalists)\n    verdict = promotionGate({\n      report: holdout,\n      incumbent: gen0Champion.name,\n      candidate: incumbent.name,\n      ...(cfg.objective === 'cost'\n        ? {\n            mode: 'non-inferiority' as const,\n            ...(cfg.scoreTolerance !== undefined ? { scoreTolerance: cfg.scoreTolerance } : {}),\n          }\n        : {}),\n      ...(cfg.minPairedTasks !== undefined ? { minPairedTasks: cfg.minPairedTasks } : {}),\n    })\n    save({\n      gen0,\n      gen0Champion,\n      generations: generationRows,\n      archive,\n      trajectory,\n      holdout,\n      verdict,\n      ...(bandInfo ? { band: bandInfo } : {}),\n    })\n  }\n\n  let reproduction: ReproductionCheck | undefined\n  const championCode = codeByName.get(incumbent.name)\n  if (cfg.reproducerCheck && championCode) {\n    const words = cfg.reproducerCheck.summaryMaxWords ?? 64\n    const tolerance = cfg.reproducerCheck.tolerance ?? 0.05\n    const championHoldoutScore = holdout.perStrategy[incumbent.name]?.score ?? 0\n    try {\n      const summaryRes = await cfg.author.chat.chat({\n        ...(cfg.author.model ? { model: cfg.author.model } : {}),\n        temperature: 0.2,\n        maxTokens: 512,\n        messages: [\n          {\n            role: 'system',\n            content: `Summarize the optimization strategy implemented by this code in at most ${words} words. Describe the COMPOSITION (shots, critique, artifact handling, restarts, stopping) — not the code. Output only the summary.`,\n          },\n          { role: 'user', content: championCode },\n        ],\n      })\n      const summary = summaryRes.content.trim()\n      // The reproducer sees the summary and the contract — never the losses, never the\n      // original code. If its implementation matches the champion on the SAME holdout,\n      // the champion's win fits through the summary and cannot be holdout-specific.\n      const reproduced = await authorStrategy({\n        chat: cfg.author.chat,\n        ...(cfg.author.model ? { model: cfg.author.model } : {}),\n        ...(cfg.author.fallbackModel ? { fallbackModel: cfg.author.fallbackModel } : {}),\n        ...(cfg.author.maxTokens !== undefined ? { maxTokens: cfg.author.maxTokens } : {}),\n        temperature: 0.2,\n        contract: `${strategyAuthorContract}\\n\\nIMPLEMENT EXACTLY THIS STRATEGY (a colleague's description — do not invent a different approach):\\n${summary}`,\n        environmentName: cfg.environment.name,\n        lossesJson: '[]',\n        budget,\n        outDir: cfg.outDir,\n      })\n      const reproStrategy: Strategy = {\n        name: `${incumbent.name}-reproduced`,\n        driver: reproduced.strategy.driver,\n      }\n      const reproReport = await bench('reproduce', holdoutTasks, [reproStrategy])\n      const reproducedHoldoutScore = reproReport.perStrategy[reproStrategy.name]?.score ?? 0\n      reproduction = {\n        summary,\n        reproducedName: reproStrategy.name,\n        file: reproduced.file,\n        championHoldoutScore,\n        reproducedHoldoutScore,\n        gap: championHoldoutScore - reproducedHoldoutScore,\n        reproducible: reproducedHoldoutScore >= championHoldoutScore - tolerance,\n      }\n    } catch (e) {\n      reproduction = {\n        summary: '',\n        reproducedName: '',\n        championHoldoutScore,\n        reproducedHoldoutScore: 0,\n        gap: championHoldoutScore,\n        reproducible: false,\n        error: e instanceof Error ? e.message.slice(0, 300) : String(e),\n      }\n    }\n  }\n\n  return {\n    gen0,\n    gen0Champion,\n    generations: generationRows,\n    archive,\n    finalChampion: incumbent,\n    holdout,\n    verdict,\n    ...(bandInfo ? { band: bandInfo } : {}),\n    ...(reproduction ? { reproduction } : {}),\n    trajectory,\n  }\n}\n","/**\n * createVerifierEnvironment — ANY checkable task as an `Environment`, no tool surface\n * required. The generalization piece: EOPS/commit0-style domains have tools that mutate\n * an external artifact, but math problems, legal drafts, creative briefs, GTM copy, and\n * QA tasks have a different shape — the artifact IS the worker's answer, and the domain\n * is defined by one function: the deployable check over that answer.\n *\n *   const gsm8k = createVerifierEnvironment({\n *     name: 'gsm8k',\n *     check: (task, answer) => ({\n *       passes: extractFinalNumber(answer) === task.meta?.answer ? 1 : 0,\n *       total: 1,\n *       errored: 0,\n *     }),\n *   })\n *   await runBenchmark({ environment: gsm8k, tasks, worker })   // sample vs refine on math\n *\n * The worker gets one built-in tool — `submit_answer` — plus any read-only domain tools\n * the caller adds (a calculator, a retrieval call, a style guide lookup). Every\n * submission is kept; `score()` checks the BEST submission (keep-best is the measured\n * law: workers reach correct answers then revise past them). The refine strategy's\n * critic reads the submission trajectory like any other trace, so iterate-with-feedback\n * works unchanged on answer domains.\n *\n * The check can be graded (passes/total expresses partial credit — rubric points,\n * sub-answers, unit-test counts), and MUST be deployable (computable without an oracle\n * at serve time): exact/numeric match, schema validation, a compiled rubric — not a\n * peek at held-out labels the production system wouldn't have.\n */\n\nimport type { Environment } from './run-benchmark'\nimport type { AgenticTask, AgenticTool, ArtifactHandle, SurfaceScore } from './strategy'\n\nexport interface VerifierEnvironmentOptions {\n  name: string\n  /** The deployable check over a submitted answer. Graded via passes/total. */\n  check(task: AgenticTask, answer: string): Promise<SurfaceScore> | SurfaceScore\n  /** Extra domain tools (read-only helpers: calculator, retrieval, style lookup). */\n  extraTools?: AgenticTool[]\n  /** Executes the extra tools. Required when `extraTools` is set. */\n  callExtra?(\n    task: AgenticTask,\n    name: string,\n    args: Record<string, unknown>,\n  ): Promise<string> | string\n}\n\ninterface AnswerState {\n  task: AgenticTask\n  submissions: string[]\n}\n\nconst submitTool: AgenticTool = {\n  type: 'function',\n  function: {\n    name: 'submit_answer',\n    description:\n      'Submit your answer for evaluation. You may submit more than once — the best-scoring submission counts. Submit the COMPLETE final answer, not a fragment.',\n    parameters: {\n      type: 'object',\n      properties: { answer: { type: 'string', description: 'The complete final answer.' } },\n      required: ['answer'],\n    },\n  },\n}\n\nexport function createVerifierEnvironment(opts: VerifierEnvironmentOptions): Environment {\n  if (opts.extraTools?.length && !opts.callExtra) {\n    throw new Error(`${opts.name}: extraTools requires callExtra`)\n  }\n  const states = new Map<string, AnswerState>()\n  let seq = 0\n\n  return {\n    name: opts.name,\n\n    async open(task) {\n      seq += 1\n      const handle: ArtifactHandle = { id: `${opts.name}-${seq}`, surface: opts.name }\n      states.set(handle.id, { task, submissions: [] })\n      return handle\n    },\n\n    async tools() {\n      return [submitTool, ...(opts.extraTools ?? [])]\n    },\n\n    async call(handle, name, args) {\n      const state = states.get(handle.id)\n      if (!state) return 'ERROR: workspace closed'\n      if (name === 'submit_answer') {\n        const answer = String(args.answer ?? '').trim()\n        if (!answer) return 'ERROR: empty answer'\n        state.submissions.push(answer)\n        return `submission ${state.submissions.length} recorded`\n      }\n      if (opts.callExtra && opts.extraTools?.some((t) => t.function.name === name)) {\n        try {\n          return await opts.callExtra(state.task, name, args)\n        } catch (e) {\n          return `ERROR: ${e instanceof Error ? e.message : String(e)}`\n        }\n      }\n      return `ERROR: unknown tool ${name}`\n    },\n\n    // Keep-best across submissions — the measured law (workers reach correct answers,\n    // then revise past them; final-state scoring undersells every strategy).\n    async score(task, handle) {\n      const state = states.get(handle.id)\n      if (!state || state.submissions.length === 0) return { passes: 0, total: 1, errored: 0 }\n      let best: SurfaceScore = { passes: 0, total: 1, errored: 0 }\n      const ratio = (s: SurfaceScore) => (s.total > 0 ? s.passes / s.total : 0)\n      for (const answer of state.submissions) {\n        const s = await opts.check(task, answer)\n        if (ratio(s) > ratio(best)) best = s\n      }\n      return best\n    },\n\n    async close(handle) {\n      states.delete(handle.id)\n    },\n  }\n}\n","/**\n * createWaterfallCollector — 100% trajectory observability from the lifecycle stream:\n * every spawn/settle (shots, analysts, nested agents) becomes one timed, billed span.\n * The sum of spans IS the run's cost story — what each step cost in dollars, tokens,\n * and wall-clock, rendered as a text waterfall or exported as structured rows for any\n * chart. Attach the collector's `hooks` to `runAgentic`/`runBenchmark`; spans accumulate\n * across every task the hooks observe.\n */\nimport type { RuntimeHookEvent, RuntimeHooks } from '../runtime-hooks'\n\nexport interface WaterfallSpan {\n  id: string\n  /** The spawn label (`shot:0`, `analyst:1`, a nested agent's label) — the row name. */\n  label: string\n  runId: string\n  parentId?: string\n  startMs: number\n  endMs?: number\n  status: 'running' | 'done' | 'down'\n  usd: number\n  tokens: { input: number; output: number }\n  score?: number\n}\n\nexport interface WaterfallReport {\n  spans: WaterfallSpan[]\n  /** Wall-clock of the observed window (first spawn → last settle). */\n  totalMs: number\n  totalUsd: number\n  totalTokens: { input: number; output: number }\n  /** Rollup by label prefix (the part before ':') — shots vs analysts vs anything else. */\n  byKind: Record<\n    string,\n    { count: number; ms: number; usd: number; tokens: { input: number; output: number } }\n  >\n}\n\ninterface SpawnPayload {\n  childId?: string\n  label?: string\n}\ninterface SettlePayload {\n  childId?: string\n  status?: string\n  score?: number\n  spent?: { usd?: number; tokens?: { input?: number; output?: number } }\n}\n\nexport interface WaterfallCollector {\n  /** Attach these to RunAgenticOptions.hooks / BenchmarkConfig.hooks. */\n  hooks: RuntimeHooks\n  report(): WaterfallReport\n  /** The text waterfall — one row per span, bars scaled to the observed window. */\n  render(opts?: { width?: number; maxRows?: number }): string\n  reset(): void\n}\n\nexport function createWaterfallCollector(): WaterfallCollector {\n  let spans = new Map<string, WaterfallSpan>()\n\n  const onEvent = (event: RuntimeHookEvent): void => {\n    if (event.target === 'agent.spawn') {\n      const p = (event.payload ?? {}) as SpawnPayload\n      const id = p.childId ?? event.id\n      spans.set(id, {\n        id,\n        label: p.label ?? id,\n        runId: event.runId,\n        ...(event.parentId !== undefined ? { parentId: event.parentId } : {}),\n        startMs: event.timestamp,\n        status: 'running',\n        usd: 0,\n        tokens: { input: 0, output: 0 },\n      })\n      return\n    }\n    if (event.target === 'agent.child') {\n      const p = (event.payload ?? {}) as SettlePayload\n      const id = p.childId\n      if (!id) return\n      const span = spans.get(id)\n      if (!span) return\n      span.endMs = event.timestamp\n      span.status = p.status === 'down' ? 'down' : 'done'\n      span.usd = p.spent?.usd ?? 0\n      span.tokens = {\n        input: p.spent?.tokens?.input ?? 0,\n        output: p.spent?.tokens?.output ?? 0,\n      }\n      if (typeof p.score === 'number') span.score = p.score\n    }\n  }\n\n  const report = (): WaterfallReport => {\n    const all = [...spans.values()].sort((a, b) => a.startMs - b.startMs)\n    const start = all[0]?.startMs ?? 0\n    const end = Math.max(start, ...all.map((s) => s.endMs ?? s.startMs))\n    const byKind: WaterfallReport['byKind'] = {}\n    let totalUsd = 0\n    const totalTokens = { input: 0, output: 0 }\n    for (const s of all) {\n      totalUsd += s.usd\n      totalTokens.input += s.tokens.input\n      totalTokens.output += s.tokens.output\n      const kind = s.label.includes(':') ? (s.label.split(':')[0] as string) : s.label\n      const k = (byKind[kind] ??= { count: 0, ms: 0, usd: 0, tokens: { input: 0, output: 0 } })\n      k.count += 1\n      k.ms += (s.endMs ?? s.startMs) - s.startMs\n      k.usd += s.usd\n      k.tokens.input += s.tokens.input\n      k.tokens.output += s.tokens.output\n    }\n    return { spans: all, totalMs: end - start, totalUsd, totalTokens, byKind }\n  }\n\n  const render = (opts?: { width?: number; maxRows?: number }): string => {\n    const { spans: all, totalMs, totalUsd, byKind } = report()\n    if (all.length === 0) return '(no spans observed)'\n    const width = opts?.width ?? 48\n    const maxRows = opts?.maxRows ?? 60\n    const start = all[0]?.startMs ?? 0\n    const scale = totalMs > 0 ? width / totalMs : 0\n    const lines: string[] = []\n    const labelWidth = Math.min(24, Math.max(...all.map((s) => s.label.length)) + 1)\n    for (const s of all.slice(0, maxRows)) {\n      const offset = Math.round((s.startMs - start) * scale)\n      const dur = (s.endMs ?? s.startMs) - s.startMs\n      const len = Math.max(1, Math.round(dur * scale))\n      const bar = `${' '.repeat(Math.min(offset, width))}${(s.status === 'down' ? '░' : '█').repeat(Math.max(1, Math.min(len, width - Math.min(offset, width) + 1)))}`\n      const mark =\n        s.status === 'down'\n          ? ' DOWN'\n          : s.score !== undefined\n            ? ` ${(s.score * 100).toFixed(0)}%`\n            : ''\n      lines.push(\n        `${s.label.padEnd(labelWidth)}|${bar.padEnd(width + 1)}| ${(dur / 1000).toFixed(1)}s $${s.usd.toFixed(4)} ${s.tokens.input}/${s.tokens.output}tok${mark}`,\n      )\n    }\n    if (all.length > maxRows) lines.push(`… ${all.length - maxRows} more spans`)\n    lines.push('—'.repeat(labelWidth + width + 2))\n    for (const [kind, k] of Object.entries(byKind)) {\n      lines.push(\n        `${kind.padEnd(labelWidth)} ×${k.count}  ${(k.ms / 1000).toFixed(1)}s busy  $${k.usd.toFixed(4)}  ${k.tokens.input}/${k.tokens.output}tok`,\n      )\n    }\n    lines.push(\n      `TOTAL${' '.repeat(labelWidth - 5)} ${(totalMs / 1000).toFixed(1)}s wall  $${totalUsd.toFixed(4)}`,\n    )\n    return lines.join('\\n')\n  }\n\n  return {\n    hooks: { onEvent },\n    report,\n    render,\n    reset: () => {\n      spans = new Map()\n    },\n  }\n}\n","/** Command runner seam. Host code can use `localShell`; sandbox code can wrap `box.exec`. */\nexport type Shell = (\n  args: ReadonlyArray<string>,\n  cwd?: string,\n) => Promise<{ stdout: string; stderr: string; code: number }>\n\nexport type WorkspaceCommit =\n  | { readonly ok: true; readonly rev: string }\n  | { readonly ok: false; readonly conflict: string }\n\nexport interface Workspace {\n  readonly ref: string\n  materialize(dir: string): Promise<void>\n  commit(dir: string, message: string): Promise<WorkspaceCommit>\n  head(): Promise<string>\n}\n\nexport function localShell(): Shell {\n  return async (args, cwd) => {\n    const { execFile } = await import('node:child_process')\n    const [bin, ...rest] = args\n    return new Promise((resolve) => {\n      execFile(\n        bin ?? '',\n        rest,\n        { cwd, encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024 },\n        (err: Error | null, stdout: string, stderr: string) => {\n          resolve({\n            stdout: stdout ?? '',\n            stderr: stderr ?? '',\n            code: err ? ((err as { code?: number }).code ?? 1) : 0,\n          })\n        },\n      )\n    })\n  }\n}\n\nexport interface GitWorkspaceOptions {\n  readonly ref: string\n  readonly shell?: Shell\n  readonly branch?: string\n  readonly noHooks?: boolean\n}\n\nexport function gitWorkspace(opts: GitWorkspaceOptions): Workspace {\n  const shell = opts.shell ?? localShell()\n  const branch = opts.branch ?? 'main'\n  const cfg = opts.noHooks === false ? [] : ['-c', 'core.hooksPath=/dev/null']\n  const ident = ['-c', 'user.email=workspace@tangle.local', '-c', 'user.name=workspace']\n\n  const run = async (args: string[], cwd?: string): Promise<string> => {\n    const res = await shell(['git', ...cfg, ...ident, ...args], cwd)\n    if (res.code !== 0) {\n      throw new Error(\n        `git ${args.join(' ')} failed (${res.code}): ${tail(res.stderr || res.stdout)}`,\n      )\n    }\n    return res.stdout\n  }\n\n  return {\n    ref: opts.ref,\n    materialize: (dir) => run(['clone', '--branch', branch, opts.ref, dir]).then(() => {}),\n    async commit(dir, message) {\n      await run(['add', '-A'], dir)\n      const status = await run(['status', '--porcelain'], dir)\n      if (!status.trim()) return { ok: true, rev: (await run(['rev-parse', 'HEAD'], dir)).trim() }\n      await run(['commit', '-m', message], dir)\n      const pull = await shell(['git', ...cfg, ...ident, 'pull', '--rebase', 'origin', branch], dir)\n      if (pull.code !== 0) {\n        await shell(['git', ...cfg, 'rebase', '--abort'], dir).catch(() => {})\n        return { ok: false, conflict: tail(pull.stderr || pull.stdout) }\n      }\n      const push = await shell(['git', ...cfg, ...ident, 'push', 'origin', branch], dir)\n      if (push.code !== 0) return { ok: false, conflict: tail(push.stderr || push.stdout) }\n      return { ok: true, rev: (await run(['rev-parse', 'HEAD'], dir)).trim() }\n    },\n    async head() {\n      const out = await run(['ls-remote', opts.ref, `refs/heads/${branch}`])\n      return out.split(/\\s+/)[0] ?? ''\n    },\n  }\n}\n\n/** A jj-backed `Workspace` (Jujutsu, colocated with git for the durable remote).\n *  Same port, same `Shell` — a drop-in for `gitWorkspace`. jj suits agent loops:\n *  no staging area, and a first-class operation log (native resume/undo). Live use\n *  requires `jj` on the `Shell`'s host. */\nexport function jjWorkspace(opts: GitWorkspaceOptions): Workspace {\n  const shell = opts.shell ?? localShell()\n  const branch = opts.branch ?? 'main'\n  // jj reads its author identity from config, not per-call flags like git's `-c\n  // user.*`; inject it via --config-toml so a throwaway clone is self-contained\n  // (parallels gitWorkspace's `ident`). Global flags must precede the subcommand.\n  const ident = [\n    '--config-toml',\n    'user.name=\"workspace\"',\n    '--config-toml',\n    'user.email=\"workspace@tangle.local\"',\n  ]\n\n  const jj = async (args: string[], cwd?: string): Promise<string> => {\n    const res = await shell(['jj', ...ident, ...args], cwd)\n    if (res.code !== 0) {\n      throw new Error(\n        `jj ${args.join(' ')} failed (${res.code}): ${tail(res.stderr || res.stdout)}`,\n      )\n    }\n    return res.stdout\n  }\n\n  return {\n    ref: opts.ref,\n    // Colocated clone: jj manages history, git holds the durable remote.\n    materialize: (dir) => jj(['git', 'clone', '--colocate', opts.ref, dir]).then(() => {}),\n    async commit(dir, message) {\n      // jj auto-snapshots the working copy; describe the change, then open a fresh\n      // empty change so the next commit doesn't amend this one. A rejected push is\n      // surfaced as a typed blocker (conflicts are first-class in jj, not aborted).\n      await jj(['describe', '-m', message], dir)\n      await jj(['new'], dir)\n      const push = await shell(['jj', ...ident, 'git', 'push', '--branch', branch], dir)\n      if (push.code !== 0) return { ok: false, conflict: tail(push.stderr || push.stdout) }\n      const rev = (await jj(['log', '--no-graph', '-r', '@-', '-T', 'commit_id'], dir)).trim()\n      return { ok: true, rev }\n    },\n    async head() {\n      const out = await shell(['git', 'ls-remote', opts.ref, `refs/heads/${branch}`])\n      return out.stdout.split(/\\s+/)[0] ?? ''\n    },\n  }\n}\n\nfunction tail(s: string): string {\n  return s.slice(-400)\n}\n"],"mappings":"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","names":["analyze","sleep","box","sessionId","TEARDOWN_TIMEOUT_MS","pool","spawn","zeroSpend","pool","isAsyncIterable","isAbortError","totalTokens","stableStringify","isNoEntError","estimateCost","isModelPriced","zeroSpend","isModelPriced","estimateCost","f","c","pool","fanout","perChild","zeroSpend","requireNode","median","estimateCost","isModelPriced","isModelPriced","estimateCost","drainOne","settle","writeFileSync","writeFileSync","pool","totalTokens"]}