@tangle-network/agent-runtime 0.93.2 → 0.94.1

package/dist/{chunk-3D2RHC4K.js → chunk-WIPGQ4GT.js}

@@ -70,4 +70,4 @@ export {
   InMemoryResultBlobStore,
   InMemorySpawnJournal
 };
-//# sourceMappingURL=chunk-3D2RHC4K.js.map
+//# sourceMappingURL=chunk-WIPGQ4GT.js.map

package/dist/{chunk-3D2RHC4K.js.map → chunk-WIPGQ4GT.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/durable/spawn-journal.ts"],"sourcesContent":["/**\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 * @experimental\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  // `spawned` (ordinal namespace) and `metered` (informational spend, no settlement order) live\n  // outside the cursor-uniqueness namespace replay relies on.\n  if (ev.kind === 'spawned' || ev.kind === 'metered') return\n  if (events.some((e) => e.kind !== 'spawned' && e.kind !== 'metered' && 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 === 'metered') continue // a spend record, not a settlement — irrelevant to replay\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, then adds each\n * `metered` event's driver-inference spend onto its node in a separate additive pass — 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\n    .filter((ev) => ev.kind !== 'spawned' && ev.kind !== 'metered')\n    .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  // Driver inference: a separate pass so it accumulates ONTO the settled child-work base (no\n  // dependence on metered-vs-settled seq order) without touching node status.\n  for (const ev of events) {\n    if (ev.kind !== 'metered') continue\n    const node = requireNode(nodes, ev.id)\n    node.spent = addJournalSpend(node.spent, ev.spend)\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\n/** Add a `metered` spend record onto a node's accumulated spend (per channel). */\nfunction addJournalSpend(a: Spend, b: Spend): Spend {\n  return {\n    iterations: a.iterations + b.iterations,\n    tokens: { input: a.tokens.input + b.tokens.input, output: a.tokens.output + b.tokens.output },\n    usd: a.usd + b.usd,\n    ms: a.ms + b.ms,\n  }\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"],"mappings":";AAsBA,SAAS,kBAAkB;AA0BpB,SAAS,eAAe,UAA2B;AACxD,QAAM,MAAM,WAAW,QAAQ,EAAE,OAAO,gBAAgB,QAAQ,GAAG,OAAO,EAAE,OAAO,KAAK;AACxF,SAAO,UAAU,GAAG;AACtB;AAEA,SAAS,gBAAgB,OAAwB;AAC/C,MAAI,UAAU,QAAQ,OAAO,UAAU,SAAU,QAAO,KAAK,UAAU,KAAK,KAAK;AACjF,MAAI,MAAM,QAAQ,KAAK,EAAG,QAAO,IAAI,MAAM,IAAI,eAAe,EAAE,KAAK,GAAG,CAAC;AACzE,QAAM,UAAU,OAAO,QAAQ,KAAgC,EAC5D,OAAO,CAAC,CAAC,EAAE,CAAC,MAAM,MAAM,MAAS,EACjC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAO,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAE;AAClD,SAAO,IAAI,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,KAAK,UAAU,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,EAAE,EAAE,KAAK,GAAG,CAAC;AAC5F;AASO,IAAM,0BAAN,MAAyD;AAAA,EAC7C,QAAQ,oBAAI,IAAqB;AAAA,EAElD,MAAM,IAAI,QAAgB,UAAkC;AAC1D,yBAAqB,QAAQ,QAAQ;AACrC,SAAK,MAAM,IAAI,QAAQ,QAAQ;AAAA,EACjC;AAAA,EAEA,MAAM,IAAI,QAA8C;AACtD,WAAO,KAAK,MAAM,IAAI,MAAM,IAAI,KAAK,MAAM,IAAI,MAAM,IAAI;AAAA,EAC3D;AACF;AAwCA,SAAS,qBAAqB,QAAgB,UAAyB;AACrE,QAAM,WAAW,eAAe,QAAQ;AACxC,MAAI,WAAW,UAAU;AACvB,UAAM,IAAI;AAAA,MACR,gBAAgB,MAAM,+CAA+C,QAAQ;AAAA,IAE/E;AAAA,EACF;AACF;AAWO,IAAM,uBAAN,MAAmD;AAAA,EACvC,QAAQ,oBAAI,IAAuD;AAAA,EAEpF,MAAM,SAAS,MAAiD;AAC9D,UAAM,OAAO,KAAK,MAAM,IAAI,IAAI;AAChC,QAAI,CAAC,KAAM,QAAO;AAClB,WAAO,KAAK,OAAO,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,EAAE;AAAA,EAC5C;AAAA,EAEA,MAAM,UAAU,MAAc,IAA2B;AACvD,UAAM,WAAW,KAAK,MAAM,IAAI,IAAI;AACpC,QAAI,UAAU;AACZ,UAAI,SAAS,YAAY,IAAI;AAC3B,cAAM,IAAI;AAAA,UACR,eAAe,IAAI,sBAAsB,SAAS,OAAO,gCAAgC,EAAE;AAAA,QAC7F;AAAA,MACF;AACA;AAAA,IACF;AACA,SAAK,MAAM,IAAI,MAAM,EAAE,SAAS,IAAI,QAAQ,CAAC,EAAE,CAAC;AAAA,EAClD;AAAA,EAEA,MAAM,YAAY,MAAc,IAA+B;AAC7D,UAAM,OAAO,KAAK,MAAM,IAAI,IAAI;AAChC,QAAI,CAAC,MAAM;AACT,YAAM,IAAI,MAAM,8CAA8C,IAAI,yBAAyB;AAAA,IAC7F;AACA,oBAAgB,MAAM,KAAK,QAAQ,EAAE;AACrC,SAAK,OAAO,KAAK,EAAE,GAAG,GAAG,CAAC;AAAA,EAC5B;AACF;AA2GA,SAAS,gBAAgB,MAAc,QAAsB,IAAsB;AAGjF,MAAI,GAAG,SAAS,aAAa,GAAG,SAAS,UAAW;AACpD,MAAI,OAAO,KAAK,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,SAAS,aAAa,EAAE,QAAQ,GAAG,GAAG,GAAG;AACxF,UAAM,IAAI;AAAA,MACR,iDAAiD,GAAG,GAAG,aAAa,IAAI;AAAA,IAE1E;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../src/durable/spawn-journal.ts"],"sourcesContent":["/**\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 * @experimental\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  // `spawned` (ordinal namespace) and `metered` (informational spend, no settlement order) live\n  // outside the cursor-uniqueness namespace replay relies on.\n  if (ev.kind === 'spawned' || ev.kind === 'metered') return\n  if (events.some((e) => e.kind !== 'spawned' && e.kind !== 'metered' && 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 === 'metered') continue // a spend record, not a settlement — irrelevant to replay\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, then adds each\n * `metered` event's driver-inference spend onto its node in a separate additive pass — 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\n    .filter((ev) => ev.kind !== 'spawned' && ev.kind !== 'metered')\n    .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  // Driver inference: a separate pass so it accumulates ONTO the settled child-work base (no\n  // dependence on metered-vs-settled seq order) without touching node status.\n  for (const ev of events) {\n    if (ev.kind !== 'metered') continue\n    const node = requireNode(nodes, ev.id)\n    node.spent = addJournalSpend(node.spent, ev.spend)\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\n/** Add a `metered` spend record onto a node's accumulated spend (per channel). */\nfunction addJournalSpend(a: Spend, b: Spend): Spend {\n  return {\n    iterations: a.iterations + b.iterations,\n    tokens: { input: a.tokens.input + b.tokens.input, output: a.tokens.output + b.tokens.output },\n    usd: a.usd + b.usd,\n    ...(a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {}),\n    ms: a.ms + b.ms,\n  }\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"],"mappings":";AAsBA,SAAS,kBAAkB;AA0BpB,SAAS,eAAe,UAA2B;AACxD,QAAM,MAAM,WAAW,QAAQ,EAAE,OAAO,gBAAgB,QAAQ,GAAG,OAAO,EAAE,OAAO,KAAK;AACxF,SAAO,UAAU,GAAG;AACtB;AAEA,SAAS,gBAAgB,OAAwB;AAC/C,MAAI,UAAU,QAAQ,OAAO,UAAU,SAAU,QAAO,KAAK,UAAU,KAAK,KAAK;AACjF,MAAI,MAAM,QAAQ,KAAK,EAAG,QAAO,IAAI,MAAM,IAAI,eAAe,EAAE,KAAK,GAAG,CAAC;AACzE,QAAM,UAAU,OAAO,QAAQ,KAAgC,EAC5D,OAAO,CAAC,CAAC,EAAE,CAAC,MAAM,MAAM,MAAS,EACjC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAO,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAE;AAClD,SAAO,IAAI,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,KAAK,UAAU,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,EAAE,EAAE,KAAK,GAAG,CAAC;AAC5F;AASO,IAAM,0BAAN,MAAyD;AAAA,EAC7C,QAAQ,oBAAI,IAAqB;AAAA,EAElD,MAAM,IAAI,QAAgB,UAAkC;AAC1D,yBAAqB,QAAQ,QAAQ;AACrC,SAAK,MAAM,IAAI,QAAQ,QAAQ;AAAA,EACjC;AAAA,EAEA,MAAM,IAAI,QAA8C;AACtD,WAAO,KAAK,MAAM,IAAI,MAAM,IAAI,KAAK,MAAM,IAAI,MAAM,IAAI;AAAA,EAC3D;AACF;AAwCA,SAAS,qBAAqB,QAAgB,UAAyB;AACrE,QAAM,WAAW,eAAe,QAAQ;AACxC,MAAI,WAAW,UAAU;AACvB,UAAM,IAAI;AAAA,MACR,gBAAgB,MAAM,+CAA+C,QAAQ;AAAA,IAE/E;AAAA,EACF;AACF;AAWO,IAAM,uBAAN,MAAmD;AAAA,EACvC,QAAQ,oBAAI,IAAuD;AAAA,EAEpF,MAAM,SAAS,MAAiD;AAC9D,UAAM,OAAO,KAAK,MAAM,IAAI,IAAI;AAChC,QAAI,CAAC,KAAM,QAAO;AAClB,WAAO,KAAK,OAAO,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,EAAE;AAAA,EAC5C;AAAA,EAEA,MAAM,UAAU,MAAc,IAA2B;AACvD,UAAM,WAAW,KAAK,MAAM,IAAI,IAAI;AACpC,QAAI,UAAU;AACZ,UAAI,SAAS,YAAY,IAAI;AAC3B,cAAM,IAAI;AAAA,UACR,eAAe,IAAI,sBAAsB,SAAS,OAAO,gCAAgC,EAAE;AAAA,QAC7F;AAAA,MACF;AACA;AAAA,IACF;AACA,SAAK,MAAM,IAAI,MAAM,EAAE,SAAS,IAAI,QAAQ,CAAC,EAAE,CAAC;AAAA,EAClD;AAAA,EAEA,MAAM,YAAY,MAAc,IAA+B;AAC7D,UAAM,OAAO,KAAK,MAAM,IAAI,IAAI;AAChC,QAAI,CAAC,MAAM;AACT,YAAM,IAAI,MAAM,8CAA8C,IAAI,yBAAyB;AAAA,IAC7F;AACA,oBAAgB,MAAM,KAAK,QAAQ,EAAE;AACrC,SAAK,OAAO,KAAK,EAAE,GAAG,GAAG,CAAC;AAAA,EAC5B;AACF;AA2GA,SAAS,gBAAgB,MAAc,QAAsB,IAAsB;AAGjF,MAAI,GAAG,SAAS,aAAa,GAAG,SAAS,UAAW;AACpD,MAAI,OAAO,KAAK,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,SAAS,aAAa,EAAE,QAAQ,GAAG,GAAG,GAAG;AACxF,UAAM,IAAI;AAAA,MACR,iDAAiD,GAAG,GAAG,aAAa,IAAI;AAAA,IAE1E;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-R5GWDTM3.js → chunk-ZEYAT33L.js}

@@ -1,7 +1,7 @@
 import {
   buildLoopOtelSpans,
   createOtelExporter
-} from "./chunk-J2K6WIG6.js";
+} from "./chunk-ISTDY47H.js";
 
 // src/mcp/trace-propagation.ts
 function readTraceContextFromEnv() {
@@ -49,4 +49,4 @@ export {
   createPropagatingTraceEmitter,
   traceContextToEnv
 };
-//# sourceMappingURL=chunk-R5GWDTM3.js.map
+//# sourceMappingURL=chunk-ZEYAT33L.js.map

package/dist/{completion-gate-BLaiN0-X.d.ts → completion-gate-BAj3dXeW.d.ts}

@@ -1,5 +1,5 @@
-import { L as LocalHarness } from './local-harness-dcD5WTTr.js';
-import { c as Executor } from './types-DAdIm4AC.js';
+import { L as LocalHarness, C as CodexTokenUsage, a as CodexExecutionPolicy } from './local-harness-B7bNuNJw.js';
+import { c as Executor } from './types-Bb-CqxJH.js';
 
 /**
  *
@@ -136,6 +136,18 @@ interface WorktreeHarnessResult {
         durationMs: number;
         stdout: string;
         stderr: string;
+        /** Exact Codex JSONL usage when reproducible mode is enabled. */
+        usage?: CodexTokenUsage;
+        /** Installed CLI version captured immediately before execution. */
+        cliVersion?: string;
+        /** SHA-256 of `codex debug prompt-input` output for the exact isolated prompt. */
+        effectivePromptSha256?: string;
+        /** SHA-256 of the exact executable + argv with prompt content replaced by `<PROMPT>`. */
+        nonPromptArgsSha256?: string;
+        /** SHA-256 of the isolated config that fixes permissions and shell environment. */
+        controlledConfigSha256?: string;
+        /** Explicit isolation claims checked before model execution. */
+        executionPolicy?: CodexExecutionPolicy;
     };
     /** Verification signals derived in the live worktree (present only when commands were given). */
     checks?: {

package/dist/{coordination-DxJ83oZA.d.ts → coordination-B3ZuApR_.d.ts}

@@ -1,12 +1,12 @@
-import { E as ExecutorFactory, h as ExecutorRegistry, e as Spend, A as Agent, S as Scope, a as ResultBlobStore, B as Budget } from './types-DAdIm4AC.js';
+import { E as ExecutorFactory, e as ExecutorRegistry, i as Spend, A as Agent, S as Scope, a as ResultBlobStore, B as Budget } from './types-Bb-CqxJH.js';
 import { AgentProfile } from '@tangle-network/agent-interface';
 import { U as UiLens, a as UiFinding, C as CoderTask } from './substrate-DO2GHNg2.js';
-import { S as SandboxClient, E as ExecCtx, h as LoopTraceEmitter, g as LoopTraceEvent, b as RuntimeStreamEvent, e as AgentRunSpec } from './types-B00NtbCs.js';
+import { S as SandboxClient, E as ExecCtx, g as LoopTraceEmitter, f as LoopTraceEvent, a as RuntimeStreamEvent, d as AgentRunSpec } from './types-DWA64rbJ.js';
 import { BackendType, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
 import { AgentEvalError } from '@tangle-network/agent-eval';
-import { b as ToolSpec, c as RuntimeTelemetryOptions, R as RouterConfig } from './sanitize-C9go6tXj.js';
-import { G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-BLaiN0-X.js';
-import { L as LocalHarness } from './local-harness-dcD5WTTr.js';
+import { b as ToolSpec, c as RuntimeTelemetryOptions, R as RouterConfig } from './sanitize-C2jicjNf.js';
+import { G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-BAj3dXeW.js';
+import { L as LocalHarness } from './local-harness-B7bNuNJw.js';
 import { ProviderExecutorOptions, AgentEnvironmentProviderRegistry } from './environment-provider.js';
 import { AgentEnvironmentProvider } from '@tangle-network/agent-interface/environment-provider';
 
@@ -87,6 +87,8 @@ interface CliWorktreeSeam {
     runId?: string;
     baseRef?: string;
     harnessTimeoutMs?: number;
+    /** Isolated, network-off Codex execution with terminal JSONL usage capture. */
+    codexReproducible?: boolean;
     testCmd?: string;
     typecheckCmd?: string;
     checkTimeoutMs?: number;

package/dist/environment-provider.d.ts

@@ -2,8 +2,8 @@ import { AgentProfile, AgentProfileValidationResult } from '@tangle-network/agen
 import { CreateAgentEnvironmentInput, AgentTurnInput, AgentEnvironmentProvider, AgentEnvironmentCapabilities, AgentProfileRef } from '@tangle-network/agent-interface/environment-provider';
 export { AgentEnvironment, AgentEnvironmentCapabilities, AgentEnvironmentEvent, AgentEnvironmentProvider, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentSession, AgentSessionRef, AgentSessionStatus, AgentTurnInput, AgentTurnResult, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from '@tangle-network/agent-interface/environment-provider';
 import { CreateSandboxOptions, BackendType } from '@tangle-network/sandbox';
-import { R as Runtime, E as ExecutorFactory } from './types-DAdIm4AC.js';
-import { S as SandboxClient } from './types-B00NtbCs.js';
+import { R as Runtime, E as ExecutorFactory } from './types-Bb-CqxJH.js';
+import { S as SandboxClient } from './types-DWA64rbJ.js';
 import '@tangle-network/agent-eval';
 
 /** Provider object or registry name accepted by runtime provider adapters.

package/dist/{improve-DDhQaaJT.d.ts → improve-r8SvIxYv.d.ts}

@@ -1,7 +1,7 @@
-import { Scenario, SelfImproveOptions, SurfaceProposer, SelfImproveResult } from '@tangle-network/agent-eval/contract';
+import { Scenario, SelfImproveOptions, SurfaceProposer, SelfImproveResult, MutableSurface } from '@tangle-network/agent-eval/contract';
 import { AgentProfile } from '@tangle-network/agent-interface';
-import { L as LocalHarness } from './local-harness-dcD5WTTr.js';
-import { V as Verifier, C as CandidateGenerator } from './agentic-generator-B8oeE2Yv.js';
+import { L as LocalHarness } from './local-harness-B7bNuNJw.js';
+import { V as Verifier, C as CandidateGenerator } from './agentic-generator-D9ZmAuiL.js';
 
 /**
  *
@@ -21,12 +21,7 @@ import { V as Verifier, C as CandidateGenerator } from './agentic-generator-B8oe
  *     lesson document supplied through `opts.memory`.
  *   - `surface: 'agent-profile'` → caller-supplied proposer mutates the complete
  *     canonical AgentProfile JSON in one candidate.
- *   - `surface: 'rollout-policy'` → `rolloutPolicyProposer` mutates the
- *     inference-time `StructuralRolloutPolicy` dials ({ k, repairRounds, testgen })
- *     persisted in `profile.extensions['structural-rollout']` — deterministic
- *     bounded neighbor enumeration; the held-out gate does the deciding. No-op
- *     (nothing proposed, nothing shipped) when the profile has no such extension.
- *   - `surface` ∈ {`tools`, `mcp`, `hooks`, `subagents`, `workflow`, `agent-profile`, `code`} → no zero-config default
+ *   - `surface` ∈ {`tools`, `mcp`, `hooks`, `subagents`, `agent-profile`, `code`} → no zero-config default
  *     proposer exists (a code/config proposer needs caller-supplied wiring — a
  *     worktree repo root, a candidate generator, a serializer). The facade
  *     requires an explicit `opts.generator` for these and throws a `ConfigError`
@@ -40,17 +35,16 @@ import { V as Verifier, C as CandidateGenerator } from './agentic-generator-B8oe
  * @experimental
  */
 
-/** The agent-profile lever `improve` optimizes. Mirrors the AgentProfile-law
- *  profile levers; `code` is the implementation-tier surface, `rollout-policy`
- *  the inference-time structuralRollout dials
- *  (`profile.extensions['structural-rollout']`). */
-type ImproveSurface = 'prompt' | 'skills' | 'tools' | 'mcp' | 'hooks' | 'subagents' | 'workflow' | 'agent-profile' | 'memory' | 'code' | 'rollout-policy';
+/** The executable agent lever `improve` optimizes. Profile fields remain
+ *  portable AgentProfile coordinates; implementation and orchestration files
+ *  use the code surface so a winner can be sealed into an exact candidate. */
+type ImproveSurface = 'prompt' | 'skills' | 'tools' | 'mcp' | 'hooks' | 'subagents' | 'agent-profile' | 'memory' | 'code';
 type ImproveOptions<TScenario extends Scenario, TArtifact> = Omit<SelfImproveOptions<TScenario, TArtifact>, 'analyzeGeneration' | 'baselineSurface' | 'findings' | 'gate' | 'proposer'> & {
     /** Which profile lever to optimize. Default `'prompt'`. Selects the default
      *  generator + the baseline-surface extraction shape. */
     surface?: ImproveSurface;
     /** The `SurfaceProposer` that mutates the surface. When unset, the facade
-     *  picks the default for prompt, skills, memory, and rollout policy; surfaces
+     *  picks the default for prompt, skills, and memory; surfaces
      *  with no default REQUIRE this (fail-loud otherwise). */
     generator?: SurfaceProposer;
     /** Gate mode. `'holdout'` (default) runs the held-out promotion gate;
@@ -146,6 +140,9 @@ interface ImproveResult<TScenario extends Scenario, TArtifact> {
     /** Full `selfImprove` result for advanced inspection. */
     raw: SelfImproveResult<TScenario, TArtifact>;
 }
+/** Apply a promoted winner surface back into the profile field for `surface`.
+ *  Returns a shallow copy; never mutates the input profile. */
+declare function applyImprovementWinnerToProfile(profile: AgentProfile, surface: ImproveSurface, winner: MutableSurface): AgentProfile;
 /**
  * Run the held-out-gated self-improvement loop on ONE profile surface.
  *
@@ -161,4 +158,4 @@ interface ImproveResult<TScenario extends Scenario, TArtifact> {
  */
 declare function improve<TScenario extends Scenario, TArtifact>(profile: AgentProfile, findings: unknown[], opts: ImproveOptions<TScenario, TArtifact>): Promise<ImproveResult<TScenario, TArtifact>>;
 
-export { type ImproveSurface as I, type ImproveOptions as a, type ImproveResult as b, type ImproveCodeOptions as c, type ImproveMemoryOptions as d, type ImproveSkillsOptions as e, improve as i };
+export { type ImproveSurface as I, type ImproveOptions as a, type ImproveResult as b, type ImproveCodeOptions as c, type ImproveMemoryOptions as d, type ImproveSkillsOptions as e, applyImprovementWinnerToProfile as f, improve as i };

package/dist/index.d.ts

@@ -1,34 +1,33 @@
 import { AgentProfile, AgentEvalError, AnalystFinding, KnowledgeReadinessReport, RunRecord, ControlEvalResult } from '@tangle-network/agent-eval';
 export { AgentEvalError, AgentEvalErrorCode, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, RunRecord, ValidationError } from '@tangle-network/agent-eval';
-import { i as AgentBackendInput, O as OpenAIChatTool, j as OpenAIChatToolChoice, k as OpenAIChatResponseFormat, l as AgentExecutionBackend, m as AgentBackendContext, b as RuntimeStreamEvent, K as KnowledgeReadinessDecision, n as RunAgentTaskOptions, o as AgentTaskRunResult, p as RunAgentTaskStreamOptions, q as RuntimeSessionStore, r as RuntimeSession, R as RuntimeHooks } from './types-B00NtbCs.js';
-export { s as AgentAdapter, t as AgentKnowledgeProvider, A as AgentRuntimeEvent, u as AgentRuntimeEventSink, v as AgentTaskContext, w as AgentTaskSpec, c as AgentTaskStatus, B as BackendErrorDetail, x as RuntimeDecisionEvidenceRef, y as RuntimeDecisionKind, z as RuntimeDecisionPoint, C as RuntimeHookContext, F as RuntimeHookErrorContext, G as RuntimeHookEvent, H as RuntimeHookPhase, J as RuntimeHookTarget, M as RuntimeRunHandle, N as RuntimeRunPersistenceAdapter, P as RuntimeRunRow, Q as composeRuntimeHooks, T as defineRuntimeHooks, U as notifyRuntimeDecisionPoint, W as notifyRuntimeHookEvent, X as startRuntimeRun } from './types-B00NtbCs.js';
-export { AgentCandidateCodeSource, AgentCandidateCodeSurfaceSource, AgentCandidateModelGrantActivateInput, AgentCandidateModelGrantClient, AgentCandidateModelGrantReservation, AgentCandidateModelGrantReserveInput, AgentCandidateModelGrantSettleInput, AgentCandidateProfileSource, BuildAgentCandidateBundleInput, CreateProtectedAgentCandidateModelPortOptions, DisposePreparedAgentCandidateOptions, FileAgentCandidateExecutionClaimStore, FileAgentCandidateExecutionClaimStoreOptions, RecoverExpiredAgentCandidateOptions, buildAgentCandidateBundle, candidateExecutionClaim, createProtectedAgentCandidateModelPort, disposePreparedAgentCandidateExecution, persistCandidateOutputArtifact, recoverExpiredAgentCandidateExecution, verifyAgentCandidateBundle } from './candidate-execution/index.js';
-export { d as AgentCandidateArtifactPort, e as AgentCandidateBenchmarkGraderIdentity, f as AgentCandidateBenchmarkGraderPort, c as AgentCandidateBundleInput, g as AgentCandidateContainerPort, h as AgentCandidateExecutionAttemptRecord, i as AgentCandidateExecutionAttemptRef, j as AgentCandidateExecutionClaim, k as AgentCandidateExecutionClaimResult, l as AgentCandidateExecutionClaimStore, m as AgentCandidateExecutionCleanupHandles, n as AgentCandidateExecutionFailureClass, o as AgentCandidateExecutionFinishResult, p as AgentCandidateExecutionLease, q as AgentCandidateExecutionPhase, r as AgentCandidateExecutionPhaseResult, a as AgentCandidateExecutionPorts, s as AgentCandidateExecutionRecoveryEvidence, t as AgentCandidateExecutionStageResult, u as AgentCandidateExecutionTerminalRecord, v as AgentCandidateExecutionTerminalResult, w as AgentCandidateExecutionUsage, x as AgentCandidateExecutorFinalCapture, y as AgentCandidateExecutorMemoryCapture, z as AgentCandidateExecutorPort, B as AgentCandidateExecutorProfileFile, C as AgentCandidateExecutorRequest, D as AgentCandidateExecutorStopRequest, F as AgentCandidateExecutorTaskOutcomeCapture, G as AgentCandidateExecutorWorkspaceFile, H as AgentCandidateExecutorWorkspaceInput, I as AgentCandidateMemoryPort, J as AgentCandidateMemoryResetResult, K as AgentCandidateModelLimits, L as AgentCandidateModelPort, M as AgentCandidateOutputArtifactPort, N as AgentCandidateOutputPurpose, O as AgentCandidateProtectedModelActivation, Q as AgentCandidateProtectedModelCall, R as AgentCandidateProtectedModelReservation, S as AgentCandidateProtectedModelSettlement, T as AgentCandidateProtectedRunCapture, U as AgentCandidateRepositoryPort, V as AgentCandidateRetryRejection, b as AgentCandidateRunFinalization, A as AgentCandidateTaskExecution, W as AgentCandidateVerificationPorts, X as AgentCandidateWorkspacePort, Y as CANDIDATE_TRACE_ENV, Z as CANDIDATE_TRACE_TAGS, _ as CanonicalCandidateDocument, E as ExecutePreparedAgentCandidateOptions, $ as InMemoryAgentCandidateExecutionClaimStore, P as PrepareAgentCandidateExecutionOptions, a0 as PreparedAgentCandidateExecution, a1 as PreparedAgentCandidateInstruction, a2 as PreparedAgentCandidateLaunch, a3 as PreparedAgentCandidateTrace, a4 as ResolvedAgentCandidateContainer, a5 as VerifiedAgentCandidate, a6 as VerifiedAgentCandidateTaskOutcome, a7 as executePreparedAgentCandidate, a8 as prepareAgentCandidateExecution, a9 as sealAgentCandidateBundle } from './prepare-DiVGKcwS.js';
-import { Scenario, ProfileDispatchFn, MutableSurface, SurfaceProposer } from '@tangle-network/agent-eval/campaign';
-import { C as CandidateGenerator } from './agentic-generator-B8oeE2Yv.js';
-export { A as AgenticGeneratorOptions, I as ImprovementDriverOptions, M as ManagedImprovementDriver, V as Verifier, a as VerifyResult, b as agenticGenerator, c as commandVerifier, i as improvementDriver } from './agentic-generator-B8oeE2Yv.js';
-export { c as ImproveCodeOptions, d as ImproveMemoryOptions, a as ImproveOptions, b as ImproveResult, e as ImproveSkillsOptions, I as ImproveSurface, i as improve } from './improve-DDhQaaJT.js';
-export { M as McpServeSpec, m as mcpServeVerifier } from './mcp-serve-verifier-Bg4C3p5S.js';
+import { h as AgentBackendInput, O as OpenAIChatTool, i as OpenAIChatToolChoice, j as OpenAIChatResponseFormat, k as AgentExecutionBackend, l as AgentBackendContext, a as RuntimeStreamEvent, K as KnowledgeReadinessDecision, m as RunAgentTaskOptions, n as AgentTaskRunResult, o as RunAgentTaskStreamOptions, p as RuntimeSessionStore, q as RuntimeSession, R as RuntimeHooks } from './types-DWA64rbJ.js';
+export { r as AgentAdapter, s as AgentKnowledgeProvider, A as AgentRuntimeEvent, t as AgentRuntimeEventSink, u as AgentTaskContext, v as AgentTaskSpec, b as AgentTaskStatus, B as BackendErrorDetail, w as RuntimeDecisionEvidenceRef, x as RuntimeDecisionKind, y as RuntimeDecisionPoint, z as RuntimeHookContext, C as RuntimeHookErrorContext, F as RuntimeHookEvent, G as RuntimeHookPhase, H as RuntimeHookTarget, J as RuntimeRunHandle, M as RuntimeRunPersistenceAdapter, N as RuntimeRunRow, P as composeRuntimeHooks, Q as defineRuntimeHooks, T as notifyRuntimeDecisionPoint, U as notifyRuntimeHookEvent, W as startRuntimeRun } from './types-DWA64rbJ.js';
+export { AgentCandidateCodeSource, AgentCandidateCodeSurfaceSource, AgentCandidateModelGrantActivateInput, AgentCandidateModelGrantClient, AgentCandidateModelGrantReservation, AgentCandidateModelGrantReserveInput, AgentCandidateModelGrantSettleInput, AgentCandidateProfileSource, BuildAgentCandidateBundleInput, CreateProtectedAgentCandidateModelPortOptions, DisposePreparedAgentCandidateOptions, FileAgentCandidateExecutionClaimStore, FileAgentCandidateExecutionClaimStoreOptions, RecoverExpiredAgentCandidateOptions, applyExactAgentProfileDiff, buildAgentCandidateBundle, candidateExecutionClaim, createProtectedAgentCandidateModelPort, disposePreparedAgentCandidateExecution, parseExactAgentProfile, parseExactAgentProfileDiff, persistCandidateOutputArtifact, recoverExpiredAgentCandidateExecution, verifyAgentCandidateBundle } from './candidate-execution/index.js';
+export { d as AgentCandidateArtifactPort, e as AgentCandidateBenchmarkGraderIdentity, f as AgentCandidateBenchmarkGraderPort, A as AgentCandidateBundleInput, g as AgentCandidateContainerPort, h as AgentCandidateExecutionAttemptRecord, i as AgentCandidateExecutionAttemptRef, j as AgentCandidateExecutionClaim, k as AgentCandidateExecutionClaimResult, l as AgentCandidateExecutionClaimStore, m as AgentCandidateExecutionCleanupHandles, n as AgentCandidateExecutionFailureClass, o as AgentCandidateExecutionFinishResult, p as AgentCandidateExecutionLease, q as AgentCandidateExecutionPhase, r as AgentCandidateExecutionPhaseResult, b as AgentCandidateExecutionPorts, s as AgentCandidateExecutionRecoveryEvidence, t as AgentCandidateExecutionStageResult, u as AgentCandidateExecutionTerminalRecord, v as AgentCandidateExecutionTerminalResult, w as AgentCandidateExecutionUsage, x as AgentCandidateExecutorFinalCapture, y as AgentCandidateExecutorMemoryCapture, z as AgentCandidateExecutorPort, B as AgentCandidateExecutorProfileFile, C as AgentCandidateExecutorRequest, D as AgentCandidateExecutorStopRequest, F as AgentCandidateExecutorTaskOutcomeCapture, G as AgentCandidateExecutorWorkspaceFile, H as AgentCandidateExecutorWorkspaceInput, I as AgentCandidateMemoryPort, J as AgentCandidateMemoryResetResult, K as AgentCandidateModelLimits, L as AgentCandidateModelPort, M as AgentCandidateOutputArtifactPort, N as AgentCandidateOutputPurpose, O as AgentCandidateProtectedModelActivation, Q as AgentCandidateProtectedModelCall, R as AgentCandidateProtectedModelReservation, S as AgentCandidateProtectedModelSettlement, T as AgentCandidateProtectedRunCapture, U as AgentCandidateRepositoryPort, V as AgentCandidateRetryRejection, c as AgentCandidateRunFinalization, a as AgentCandidateTaskExecution, W as AgentCandidateVerificationPorts, X as AgentCandidateWorkspacePort, Y as CANDIDATE_TRACE_ENV, Z as CANDIDATE_TRACE_TAGS, _ as CanonicalCandidateDocument, E as ExecutePreparedAgentCandidateOptions, $ as InMemoryAgentCandidateExecutionClaimStore, P as PrepareAgentCandidateExecutionOptions, a0 as PreparedAgentCandidateExecution, a1 as PreparedAgentCandidateInstruction, a2 as PreparedAgentCandidateLaunch, a3 as PreparedAgentCandidateTrace, a4 as ResolvedAgentCandidateContainer, a5 as VerifiedAgentCandidate, a6 as VerifiedAgentCandidateTaskOutcome, a7 as executePreparedAgentCandidate, a8 as prepareAgentCandidateExecution, a9 as sealAgentCandidateBundle } from './prepare-BKxAiUcH.js';
+import { Scenario, ProfileDispatchFn, ProposeContext, SurfaceProposer } from '@tangle-network/agent-eval/campaign';
+import { C as CandidateGenerator } from './agentic-generator-D9ZmAuiL.js';
+export { A as AgenticGeneratorOptions, I as ImprovementDriverOptions, M as ManagedImprovementDriver, V as Verifier, a as VerifyResult, b as agenticGenerator, c as commandVerifier, i as improvementDriver } from './agentic-generator-D9ZmAuiL.js';
+export { c as ImproveCodeOptions, d as ImproveMemoryOptions, a as ImproveOptions, b as ImproveResult, e as ImproveSkillsOptions, I as ImproveSurface, f as applyImprovementWinnerToProfile, i as improve } from './improve-r8SvIxYv.js';
+export { M as McpServeSpec, m as mcpServeVerifier } from './mcp-serve-verifier-BuXjaZDE.js';
+import { AgentProfileDiff, AgentProfile as AgentProfile$1 } from '@tangle-network/agent-interface';
 import { Scenario as Scenario$1, SelfImproveOptions } from '@tangle-network/agent-eval/contract';
 import { S as SurfaceImprovementEdit } from './improvement-adapter-BieWeK5J.js';
 import { I as ImprovementAdapter } from './types-BC3bZpH0.js';
-import { AgentProfile as AgentProfile$1 } from '@tangle-network/agent-interface';
-import { S as StructuralRolloutPolicy } from './structural-rollout-DHGDbhvR.js';
 export { AgentKnowledgeReadinessCheckOptions, KnowledgeImprovementJobMeasurement, KnowledgeImprovementJobResult, KnowledgeReadinessCheck, KnowledgeReadinessCheckInput, KnowledgeReadinessCheckResult, RESEARCH_SUPERVISOR_SYSTEM_PROMPT, RunKnowledgeImprovementJobOptions, SupervisedKnowledgeUpdateInput, SupervisedKnowledgeUpdateOptions, SupervisedKnowledgeUpdateResult, SupervisedKnowledgeUpdater, createAgentKnowledgeReadinessCheck, createSupervisedKnowledgeUpdater, formatSupervisedKnowledgeTask, knowledgeReadinessDeliverable, runKnowledgeImprovementJob, runSupervisedKnowledgeUpdate } from './knowledge.js';
-export { D as DELEGATED_LOOP_MODES, a as DelegatedLoopMode, b as DelegatedLoopRegistry, c as DelegatedLoopResult, d as DelegatedLoopRunner, L as LoopRunnerCliArgs, e as LoopRunnerCliResult, R as ResearchLoopResult, f as ResearchLoopRunnerOptions, g as RunDelegatedLoopOptions, V as VetoedFact, W as WorktreeLoopRunnerOptions, h as auditLoopRunner, i as isDelegatedLoopMode, p as parseLoopRunnerArgv, r as researchLoopRunner, j as runDelegatedLoop, k as runLoopRunnerCli, s as selfImproveLoopRunner, w as worktreeLoopRunner } from './loop-runner-bin-kKUNGLyV.js';
-export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './openai-tools-E3woykz9.js';
-export { b0 as EvalRunEvent, b1 as EvalRunGeneration, b2 as EvalRunsExportConfig, b3 as EvalRunsExportResult, b4 as INTELLIGENCE_WIRE_VERSION, b5 as LoopSpanNode, b6 as OtelAttribute, b7 as OtelExportConfig, b8 as OtelExporter, b9 as OtelSpan, ba as RuntimeEventOtelOptions, bb as buildLoopOtelSpans, bc as buildLoopSpanNodes, bd as buildRuntimeEventOtelSpans, be as createOtelExporter, bf as exportEvalRuns, bg as loopEventToOtelSpan } from './coordination-DxJ83oZA.js';
-import { c as RuntimeTelemetryOptions } from './sanitize-C9go6tXj.js';
-export { d as RuntimeEventCollector, e as RuntimeStreamEventCollector, S as SanitizedKnowledgeReadinessReport, f as createRuntimeEventCollector, g as createRuntimeStreamEventCollector, s as sanitizeAgentRuntimeEvent, h as sanitizeKnowledgeReadinessReport, i as sanitizeRuntimeStreamEvent } from './sanitize-C9go6tXj.js';
+export { D as DELEGATED_LOOP_MODES, a as DelegatedLoopMode, b as DelegatedLoopRegistry, c as DelegatedLoopResult, d as DelegatedLoopRunner, L as LoopRunnerCliArgs, e as LoopRunnerCliResult, R as ResearchLoopResult, f as ResearchLoopRunnerOptions, g as RunDelegatedLoopOptions, V as VetoedFact, W as WorktreeLoopRunnerOptions, h as auditLoopRunner, i as isDelegatedLoopMode, p as parseLoopRunnerArgv, r as researchLoopRunner, j as runDelegatedLoop, k as runLoopRunnerCli, s as selfImproveLoopRunner, w as worktreeLoopRunner } from './loop-runner-bin-D4bMIxmB.js';
+export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './openai-tools-D0ZSRCC6.js';
+export { b0 as EvalRunEvent, b1 as EvalRunGeneration, b2 as EvalRunsExportConfig, b3 as EvalRunsExportResult, b4 as INTELLIGENCE_WIRE_VERSION, b5 as LoopSpanNode, b6 as OtelAttribute, b7 as OtelExportConfig, b8 as OtelExporter, b9 as OtelSpan, ba as RuntimeEventOtelOptions, bb as buildLoopOtelSpans, bc as buildLoopSpanNodes, bd as buildRuntimeEventOtelSpans, be as createOtelExporter, bf as exportEvalRuns, bg as loopEventToOtelSpan } from './coordination-B3ZuApR_.js';
+import { c as RuntimeTelemetryOptions } from './sanitize-C2jicjNf.js';
+export { d as RuntimeEventCollector, e as RuntimeStreamEventCollector, S as SanitizedKnowledgeReadinessReport, f as createRuntimeEventCollector, g as createRuntimeStreamEventCollector, s as sanitizeAgentRuntimeEvent, h as sanitizeKnowledgeReadinessReport, i as sanitizeRuntimeStreamEvent } from './sanitize-C2jicjNf.js';
 import '@tangle-network/sandbox';
-import './local-harness-dcD5WTTr.js';
+import './local-harness-B7bNuNJw.js';
 import 'node:child_process';
-import './worktree-fanout-BUb2Ag02.js';
-import './types-DAdIm4AC.js';
-import './completion-gate-BLaiN0-X.js';
 import '@tangle-network/agent-knowledge';
-import './supervise-T2pazU3G.js';
+import './supervise-DTNcLDl2.js';
+import './types-Bb-CqxJH.js';
+import './completion-gate-BAj3dXeW.js';
 import './kb-gate-CwHO0vz6.js';
+import './worktree-fanout-IMKqdV_E.js';
 import './substrate-DO2GHNg2.js';
 import './environment-provider.js';
 import '@tangle-network/agent-interface/environment-provider';
@@ -1174,6 +1173,24 @@ declare function toolBuildPrompt(args: FindingsArg): string;
 /** Build the starting instruction for a coder agent tasked with implementing a new MCP server. */
 declare function mcpBuildPrompt(args: FindingsArg): string;
 
+interface AgentProfileDiffProposal {
+    diff: AgentProfileDiff;
+    label?: string;
+    rationale?: string;
+}
+type ProfileDiffProposerContext<TFindings = unknown> = ProposeContext<TFindings> & {
+    profile: AgentProfile$1;
+};
+interface ProfileDiffProposerOptions<TFindings = unknown> {
+    proposeDiffs(context: ProfileDiffProposerContext<TFindings>): Promise<readonly AgentProfileDiffProposal[]> | readonly AgentProfileDiffProposal[];
+}
+/**
+ * Turn exact AgentProfileDiffs from any source into full profile candidates for
+ * the shared optimization loop. Research, catalogs, humans, and trace miners
+ * differ only in `proposeDiffs`; measurement and promotion stay identical.
+ */
+declare function profileDiffProposer<TFindings = unknown>(options: ProfileDiffProposerOptions<TFindings>): SurfaceProposer<TFindings>;
+
 /**
  *
  * `rawTraceDistiller` — the meta-harness `analyzeGeneration` producer.
@@ -1264,94 +1281,6 @@ interface ReflectiveGeneratorOptions {
 /** Cheap no-sandbox `CandidateGenerator` (the `shots=1` setting): draft surface edits via the improvement adapter and apply them as one coherent candidate. */
 declare function reflectiveGenerator(opts: ReflectiveGeneratorOptions): CandidateGenerator;
 
-/**
- * `rolloutPolicyProposer` — the `'rollout-policy'` surface for `improve()`: the
- * inference-time `StructuralRolloutPolicy` dials { k, repairRounds, testgen } as a
- * held-out-gated optimizable surface.
- *
- * Why this seam: agent-eval's loop contract is already generic — `MutableSurface`
- * admits any string, documented as "serialized tool config" — so the policy rides
- * the SAME serialize→propose→gate→parse-back cycle the tools/mcp/hooks surfaces
- * use. No agent-eval changes; the only net-new piece is this proposer.
- *
- * Why deterministic: prompt-wording proposals are a measured zero on this stack,
- * and the policy space is tiny and fully enumerable. The proposer emits bounded
- * single-dial neighbors (k±2 in [1,10], repairRounds±1 in [0,3], testgen±3 in
- * [0,10], ≤4 per generation) and lets the held-out gate do ALL the deciding — an
- * LLM proposer would add cost and nondeterminism with nothing to reason about.
- *
- * Persistence: the policy lives in `profile.extensions['structural-rollout']`
- * (AgentProfile's designed slot for runtime-specific config). A gated winner is
- * written back there by `improve()`, the same profile-field write-back every other
- * config surface gets; `structuralRolloutPolicyFromProfile` is the read side a
- * runtime caller feeds to `structuralRollout({ policy })`.
- *
- * @experimental
- */
-
-/** The profile extensions namespace the policy persists under. */
-declare const ROLLOUT_POLICY_EXTENSION = "structural-rollout";
-/** Proposal bounds per dial. These are the SEARCH bounds (what the proposer may
- *  explore), chosen so every reachable value is a measured-sane recipe: k=1 is the
- *  low-compute preset, testgen=0 disables check authoring, repairRounds caps where
- *  the measured increment flattens (+1–3pp beyond round 2). */
-declare const ROLLOUT_POLICY_BOUNDS: {
-    readonly k: {
-        readonly min: 1;
-        readonly max: 10;
-        readonly step: 2;
-    };
-    readonly repairRounds: {
-        readonly min: 0;
-        readonly max: 3;
-        readonly step: 1;
-    };
-    readonly testgen: {
-        readonly min: 0;
-        readonly max: 10;
-        readonly step: 3;
-    };
-};
-/** Parse a serialized policy surface. Defensive by design — the proposer reads
- *  `ctx.currentSurface`, which the loop types as `string | CodeSurface`. Returns
- *  `undefined` (never throws) for non-strings, malformed JSON, or a shape that
- *  violates the policy's own invariants: the no-op signal. Unknown dials are
- *  dropped; `diverse`/`temperature` ride through untouched (the proposer never
- *  mutates them — `diverse` is a measured paired null). */
-declare function parseRolloutPolicy(surface: MutableSurface): StructuralRolloutPolicy | undefined;
-/** Normalize an untyped policy bag (a parsed surface or a profile extension) into
- *  a full `StructuralRolloutPolicy`, defaults merged. Returns `undefined` when any
- *  present dial violates the policy invariants (mirrors `resolvePolicy`: integer
- *  k ≥ 1, repairRounds ≥ 0, testgen ≥ 0) — a corrupt config must read as "not
- *  configured", never as a fabricated recipe. */
-declare function normalizeRolloutPolicy(raw: unknown): StructuralRolloutPolicy | undefined;
-/** Stable serialization — dial order is fixed so identical policies produce
- *  identical surfaces (the loop dedupes/hashes candidates by surface content). */
-declare function serializeRolloutPolicy(policy: StructuralRolloutPolicy): string;
-/** Read the persisted policy off the profile. `undefined` when the profile does
- *  not opt into structural rollout — the improve() surface no-ops then, because
- *  tuning dials nothing consumes would ship dead config. */
-declare function structuralRolloutPolicyFromProfile(profile: AgentProfile$1): StructuralRolloutPolicy | undefined;
-/** Persist a policy into the profile's extensions namespace. Shallow copy; never
- *  mutates the input profile (the applyWinnerToProfile contract). */
-declare function applyRolloutPolicyToProfile(profile: AgentProfile$1, policy: StructuralRolloutPolicy): AgentProfile$1;
-/** All bounded single-dial neighbors of `policy`, in a fixed priority order: k
- *  first (selection breadth carries 85–92% of the measured effect), then
- *  repairRounds, then testgen. Steps clamp to the dial's bounds; clamped-to-no-op
- *  and duplicate policies are dropped. */
-declare function enumerateNeighborPolicies(policy: StructuralRolloutPolicy): StructuralRolloutPolicy[];
-/**
- * The deterministic `SurfaceProposer` for the `'rollout-policy'` surface.
- *
- * Each generation: parse the current policy surface, enumerate its bounded
- * single-dial neighbors, and return at most `min(populationSize, 4)` of them,
- * rotating the enumeration window by generation so successive generations explore
- * different neighbors when nothing promoted. Proposes NOTHING when the surface
- * carries no policy (the profile never opted in) — an empty proposal is the
- * loop-native no-op, mirroring `improvementDriver`'s no-findings behavior.
- */
-declare function rolloutPolicyProposer(): SurfaceProposer;
-
 /**
  *
  * Chat-model resolution + catalog validation — the shared primitive every
@@ -1777,4 +1706,4 @@ interface StreamToolLoopOptions<Raw> {
  *  `capped` if it stops for any non-completed reason with calls still pending. */
 declare function streamToolLoop<Raw>(opts: StreamToolLoopOptions<Raw>): AsyncGenerator<StreamToolLoopYield<Raw>, void, unknown>;
 
-export { AgentBackendContext, AgentBackendInput, type AgentBackendKind, AgentExecutionBackend, AgentTaskRunResult, type AuthSource, type BackendCallPolicy, BackendTransportError, CandidateGenerator, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type CircuitBreakerConfig, CircuitBreakerState, CircuitOpenError, type Conversation, type ConversationDriveState, type ConversationJournal, type ConversationJournalEntry, type ConversationParticipant, type ConversationPolicy, type ConversationResult, type ConversationStreamEvent, type ConversationTurn, type D1DatabaseLike, type D1StmtLike, DEFAULT_MAX_DEPTH, DEFAULT_ROUTER_BASE_URL, DeadlineExceededError, FORWARD_HEADERS, FileConversationJournal, type ForwardHeaderName, type HaltContext, type HaltPredicate, type HaltReason, type HaltSignal, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatResponseFormat, OpenAIChatTool, OpenAIChatToolChoice, type PersonaConversationResult, type PersonaDriver, PlannerError, type PropagatedHeaders, ROLLOUT_POLICY_BOUNDS, ROLLOUT_POLICY_EXTENSION, type RawTraceDistillerOptions, type ReflectiveGeneratorOptions, type ResolveAgentBackendOptions, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunChatTurnInput, type RunConversationOptions, type RunPersonaConfig, type RunPersonaConversationOptions, type RunToolLoopOptions, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, RuntimeTelemetryOptions, type SqlAdapter, SqlConversationJournal, type StreamToolLoopOptions, type StreamToolLoopYield, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, type TurnOrder, applyRolloutPolicyToProfile, applyRunRecordDefaults, buildForwardHeaders, cleanModelId, computeBackoff, createConversationBackend, createIterableBackend, createOpenAICompatibleBackend, createSandboxPromptBackend, d1ToSqlAdapter, decideKnowledgeReadiness, defaultIsRetryable, defineConversation, deriveExecutionId, enumerateNeighborPolicies, getModels, handleChatTurn, isDepthExceeded, makePerAttemptSignal, mcpBuildPrompt, normalizeRolloutPolicy, parseRolloutPolicy, rawTraceDistiller, readDepth, readinessServerSentEvent, reflectiveGenerator, resolveAgentBackend, resolveChatModel, resolveRouterBaseUrl, rolloutPolicyProposer, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runPersonaConversation, runPersonaDispatch, runToolLoop, runtimeStreamServerSentEvent, serializeRolloutPolicy, sleep, slugifySpeaker, streamToolLoop, structuralRolloutPolicyFromProfile, toolBuildPrompt, turnId, validateChatModelId };
+export { AgentBackendContext, AgentBackendInput, type AgentBackendKind, AgentExecutionBackend, type AgentProfileDiffProposal, AgentTaskRunResult, type AuthSource, type BackendCallPolicy, BackendTransportError, CandidateGenerator, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type CircuitBreakerConfig, CircuitBreakerState, CircuitOpenError, type Conversation, type ConversationDriveState, type ConversationJournal, type ConversationJournalEntry, type ConversationParticipant, type ConversationPolicy, type ConversationResult, type ConversationStreamEvent, type ConversationTurn, type D1DatabaseLike, type D1StmtLike, DEFAULT_MAX_DEPTH, DEFAULT_ROUTER_BASE_URL, DeadlineExceededError, FORWARD_HEADERS, FileConversationJournal, type ForwardHeaderName, type HaltContext, type HaltPredicate, type HaltReason, type HaltSignal, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatResponseFormat, OpenAIChatTool, OpenAIChatToolChoice, type PersonaConversationResult, type PersonaDriver, PlannerError, type ProfileDiffProposerContext, type ProfileDiffProposerOptions, type PropagatedHeaders, type RawTraceDistillerOptions, type ReflectiveGeneratorOptions, type ResolveAgentBackendOptions, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunChatTurnInput, type RunConversationOptions, type RunPersonaConfig, type RunPersonaConversationOptions, type RunToolLoopOptions, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, RuntimeTelemetryOptions, type SqlAdapter, SqlConversationJournal, type StreamToolLoopOptions, type StreamToolLoopYield, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, type TurnOrder, applyRunRecordDefaults, buildForwardHeaders, cleanModelId, computeBackoff, createConversationBackend, createIterableBackend, createOpenAICompatibleBackend, createSandboxPromptBackend, d1ToSqlAdapter, decideKnowledgeReadiness, defaultIsRetryable, defineConversation, deriveExecutionId, getModels, handleChatTurn, isDepthExceeded, makePerAttemptSignal, mcpBuildPrompt, profileDiffProposer, rawTraceDistiller, readDepth, readinessServerSentEvent, reflectiveGenerator, resolveAgentBackend, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runPersonaConversation, runPersonaDispatch, runToolLoop, runtimeStreamServerSentEvent, sleep, slugifySpeaker, streamToolLoop, toolBuildPrompt, turnId, validateChatModelId };