@tangle-network/agent-runtime 0.142.3 → 0.153.1

package/dist/{run-layout-Be_Z0dF8.js → run-layout-C2jgwsCq.js}

@@ -28,7 +28,15 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeF
 *                                  {@link WorkerCancelRequest}
 *   cancellations/<opId>.json      the acknowledgement for one cancel operation — a
 *                                  {@link WorkerCancellation} written ONLY by the runtime
-*                                  acknowledger (the coordination driver's turn loop)
+*                                  acknowledger in the OWNING manager's turn loop: exact node
+*                                  ids route to the manager that parents them (any depth);
+*                                  label/profile-name references to the root manager alone
+*   cancellations/run.request.json the run-scoped cancel request — one {@link RunCancelRequest},
+*                                  the whole RUN rather than one worker
+*   cancellations/run.json         the acknowledgement for the run-scoped request — a
+*                                  {@link RunCancellation} written ONLY by the runtime (the root
+*                                  manager issues the abort; the `supervise()` settle path records
+*                                  what the run actually did)
 *
 * Reads are tolerant by contract: a partial trailing line (a writer mid-append) or a corrupt line
 * never poisons the rest of the file — later valid lines still matter.
@@ -217,9 +225,10 @@ function writeWorkerCancellation(eventDir, record) {
 * durable state.
 *
 * The write half of the acknowledged-cancellation contract (`writeWorkerSteer` is the steer
-* analog): append the request to the run's cancellation inbox, where the runtime's acknowledger
-* (the coordination driver's turn loop) applies it — aborting exactly that worker's subtree and
-* recording what it proved. This function never applies the cancellation itself; writing a
+* analog): append the request to the run's cancellation inbox, where the OWNING manager's
+* acknowledger (its turn loop — the root for label/profile references, the parent manager for an
+* exact node id at any depth) applies it — aborting exactly that worker's subtree and recording
+* what it proved. This function never applies the cancellation itself; writing a
 * request file is not an acknowledgement.
 *
 * Idempotency is a lookup: when an acknowledgement for `operationId` already exists, it is
@@ -266,6 +275,102 @@ function cancelWorker(eventDir, worker, operationId, options = {}) {
 		terminated: []
 	};
 }
+/** The run-scoped cancel request file of one run — one {@link RunCancelRequest}. */
+function runCancelRequestFile(eventDir) {
+	return join(workerCancellationsDir(eventDir), "run.request.json");
+}
+/** The run-scoped acknowledgement file of one run — one {@link RunCancellation}. */
+function runCancellationFile(eventDir) {
+	return join(workerCancellationsDir(eventDir), "run.json");
+}
+/** Read the run-scoped cancel request, or `undefined` when none was written. */
+function readRunCancelRequest(eventDir) {
+	const file = runCancelRequestFile(eventDir);
+	if (!existsSync(file)) return void 0;
+	const parsed = JSON.parse(readFileSync(file, "utf8"));
+	if (!isRunCancelRequest(parsed)) throw new Error(`run cancel request '${file}' is not a complete RunCancelRequest`);
+	return parsed;
+}
+/**
+* Read the acknowledgement for the run-scoped cancel operation. `undefined` when the runtime has
+* not answered. A record holding a DIFFERENT `operationId` belongs to another operation on the
+* same run — fail loud rather than answer for it.
+*/
+function readRunCancellation(eventDir, operationId) {
+	const file = runCancellationFile(eventDir);
+	if (!existsSync(file)) return void 0;
+	const parsed = JSON.parse(readFileSync(file, "utf8"));
+	if (parsed.operationId !== operationId) throw new Error(`run cancel acknowledgement '${file}' holds operation '${parsed.operationId}', not '${operationId}' — one run carries one run-scoped cancel operation`);
+	return parsed;
+}
+/**
+* Durably write the run-scoped acknowledgement. Write-then-rename, so a concurrent reader sees the
+* prior complete record or the new complete record, never a partial file.
+*
+* @internal The runtime is the only intended writer; clients read via {@link readRunCancellation}
+* or {@link cancelRun}.
+*/
+function writeRunCancellation(eventDir, record) {
+	mkdirSync(workerCancellationsDir(eventDir), { recursive: true });
+	const file = runCancellationFile(eventDir);
+	const tmp = `${file}.${randomUUID()}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+	renameSync(tmp, file);
+}
+/**
+* Request the cancellation of the WHOLE run, idempotently, and return the operation's current
+* durable state.
+*
+* The run-scoped twin of {@link cancelWorker}: write the request into the run's cancellation
+* directory, where the run's own root manager applies it — aborting the root through the one
+* cascade controller the run already has, so every live worker comes down with it. This function
+* never applies the cancellation itself; writing a request file is not an acknowledgement.
+*
+* Idempotency is a lookup: when an acknowledgement for `operationId` already exists it is returned
+* AS-IS and nothing is written. A request the runtime has not answered yet returns
+* `effect: 'unknown'` (never a success); call again with the same `operationId` — or
+* {@link readRunCancellation} — to read the acknowledged result after a reconnect.
+*
+* A run carries ONE run-scoped operation: a second request under a different `operationId` throws
+* rather than silently replacing the pending one, because both would claim the same single abort.
+*/
+function cancelRun(eventDir, operationId, options = {}) {
+	const opId = operationId.trim();
+	if (!opId) throw new Error("cancelRun: operationId is empty");
+	const acknowledged = readRunCancellation(eventDir, opId);
+	if (acknowledged) return acknowledged;
+	const pending = readRunCancelRequest(eventDir);
+	if (pending !== void 0 && pending.operationId !== opId) throw new Error(`cancelRun: run cancel '${pending.operationId}' is already pending for this run; read it with readRunCancellation instead of issuing '${opId}'`);
+	const source = options.source ?? "human";
+	const request = pending ?? {
+		operationId: opId,
+		at: (/* @__PURE__ */ new Date()).toISOString(),
+		source,
+		...options.reason === void 0 ? {} : { reason: options.reason }
+	};
+	if (pending === void 0) {
+		mkdirSync(workerCancellationsDir(eventDir), { recursive: true });
+		writeFileSync(runCancelRequestFile(eventDir), `${JSON.stringify(request, null, 2)}\n`, "utf8");
+		appendWorkerControlEvent(eventDir, "run", {
+			kind: "run-cancel-request",
+			operationId: opId,
+			source,
+			queued: true,
+			...options.reason === void 0 ? {} : { reason: options.reason }
+		});
+	}
+	return {
+		operationId: opId,
+		effect: "unknown",
+		requestedAt: request.at,
+		observedAt: request.at,
+		...request.reason === void 0 ? {} : { reason: request.reason },
+		detail: "request queued; no runtime acknowledger has answered yet"
+	};
+}
+function isRunCancelRequest(value) {
+	return typeof value.operationId === "string" && value.operationId.length > 0 && typeof value.at === "string" && typeof value.source === "string" && (value.reason === void 0 || typeof value.reason === "string");
+}
 function isWorkerCancelRequest(value) {
 	return typeof value.operationId === "string" && value.operationId.length > 0 && typeof value.at === "string" && typeof value.source === "string" && typeof value.worker === "string" && value.worker.length > 0 && (value.reason === void 0 || typeof value.reason === "string");
 }
@@ -283,6 +388,6 @@ function isWorkerSteerRequest(value) {
 	return typeof value.id === "string" && typeof value.at === "string" && typeof value.source === "string" && typeof value.worker === "string" && typeof value.message === "string" && value.message.trim().length > 0;
 }
 //#endregion
-export { writeWorkerCancellation as _, readWorkerCancellation as a, supervisorRunDir as c, workerCancelRequestsFile as d, workerCancellationFile as f, workerInboxFileFromEventDir as g, workerInboxFile as h, readWorkerCancelRequests as i, supervisorRunsRoot as l, workerControlLogFile as m, legacySupervisorRunDir as n, readWorkerSteerRequests as o, workerCancellationsDir as p, legacySupervisorRunsRoot as r, safeWorkerFile as s, cancelWorker as t, supervisorWorkersDir as u, writeWorkerSteer as v };
+export { writeWorkerCancellation as C, writeRunCancellation as S, workerCancellationFile as _, readRunCancelRequest as a, workerInboxFile as b, readWorkerCancellation as c, runCancellationFile as d, safeWorkerFile as f, workerCancelRequestsFile as g, supervisorWorkersDir as h, legacySupervisorRunsRoot as i, readWorkerSteerRequests as l, supervisorRunsRoot as m, cancelWorker as n, readRunCancellation as o, supervisorRunDir as p, legacySupervisorRunDir as r, readWorkerCancelRequests as s, cancelRun as t, runCancelRequestFile as u, workerCancellationsDir as v, writeWorkerSteer as w, workerInboxFileFromEventDir as x, workerControlLogFile as y };
 
-//# sourceMappingURL=run-layout-Be_Z0dF8.js.map
+//# sourceMappingURL=run-layout-C2jgwsCq.js.map

package/dist/run-layout-C2jgwsCq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-layout-C2jgwsCq.js","names":[],"sources":["../src/runtime/supervise/run-layout.ts"],"sourcesContent":["/**\n * The on-disk supervisor-run layout: `<root>/.agent/supervisor/<id>`.\n *\n * This is the durable, cross-process face of a supervisor run — the counterpart to the in-process\n * `Inbox` seam in `./inbox`. A run persists its state under one directory so that any OTHER process\n * can find it after the fact: `@tangle-network/traces` reads exactly this layout via\n * `traces analyze --supervisor-run-dir`, a restarted host can rehydrate a run it no longer holds\n * handles to, and a human can steer a live worker by appending one NDJSON line. Until now the\n * layout was defined only in the unpublished `loops` repo (`src/supervisor-control.ts`) — a\n * published reader depending on an unpublished writer's convention — so the contract is promoted\n * here, names preserved.\n *\n * `.agent` is the one dot-dir for ALL agent-owned state (skills already write\n * `.agent/hypotheses/`, `.agent/skill-runs.jsonl`); supervisor runs live beside them rather than\n * under a product-branded dir. Runs written by older writers used `.loops/supervisor/<id>` —\n * readers that must see those keep a legacy fallback; this writer never creates `.loops` again.\n *\n * Layout, relative to `supervisorRunDir(root, id)`:\n *\n *   workers/<label>.inbox.ndjson   down-leg steer/answer requests for one worker (durable inbox);\n *                                  each line is a {@link WorkerSteerRequest}\n *   workers/<label>.ndjson         best-effort per-worker control-event log (delivery bookkeeping)\n *   cancellations/requests.ndjson  worker-scoped cancel requests (durable inbox); each line is a\n *                                  {@link WorkerCancelRequest}\n *   cancellations/<opId>.json      the acknowledgement for one cancel operation — a\n *                                  {@link WorkerCancellation} written ONLY by the runtime\n *                                  acknowledger in the OWNING manager's turn loop: exact node\n *                                  ids route to the manager that parents them (any depth);\n *                                  label/profile-name references to the root manager alone\n *   cancellations/run.request.json the run-scoped cancel request — one {@link RunCancelRequest},\n *                                  the whole RUN rather than one worker\n *   cancellations/run.json         the acknowledgement for the run-scoped request — a\n *                                  {@link RunCancellation} written ONLY by the runtime (the root\n *                                  manager issues the abort; the `supervise()` settle path records\n *                                  what the run actually did)\n *\n * Reads are tolerant by contract: a partial trailing line (a writer mid-append) or a corrupt line\n * never poisons the rest of the file — later valid lines still matter.\n *\n * Promoted from `loops/src/supervisor-control.ts`. The one deliberate difference: the loops version\n * resolved a worker id to its label through the run journal before writing a steer; that resolution\n * stays with the caller (it is journal-format-specific), so `writeWorkerSteer` here takes the worker\n * LABEL directly.\n *\n * @experimental\n */\n\nimport { randomUUID } from 'node:crypto'\nimport {\n  appendFileSync,\n  existsSync,\n  mkdirSync,\n  readFileSync,\n  renameSync,\n  writeFileSync,\n} from 'node:fs'\nimport { join, resolve } from 'node:path'\nimport type { RetainedRunEffect } from '../retained-run-types'\n\n/** One durable down-leg request appended to a worker's inbox file. */\nexport interface WorkerSteerRequest {\n  readonly id: string\n  /** ISO timestamp of the append. */\n  readonly at: string\n  /** Who asked — 'human', a brain label, a tool name. Provenance, not authorization. */\n  readonly source: string\n  /** The worker LABEL the request targets (already resolved by the caller). */\n  readonly worker: string\n  readonly message: string\n}\n\n/** One durable worker-scoped cancel request appended to the run's cancellation inbox. */\nexport interface WorkerCancelRequest {\n  /** Caller-minted stable operation identifier — the idempotency key of the whole operation. */\n  readonly operationId: string\n  /** ISO timestamp of the append. */\n  readonly at: string\n  /** Who asked — 'human', a brain label, a tool name. Provenance, not authorization. */\n  readonly source: string\n  /** The worker the request targets: a workerId (node id — routed to the owning manager at any\n   *  depth), or a profile name or spawn label (resolved by the root manager against its direct\n   *  children only). */\n  readonly worker: string\n  readonly reason?: string\n}\n\n/**\n * The durable acknowledgement state for one worker-scoped cancel operation, keyed by\n * `operationId`. The runtime acknowledger is the ONLY writer; `cancelWorker` only reads it.\n *\n * `effect` reuses the retained-run vocabulary ({@link RetainedRunEffect}) so the runtime has one\n * spelling of the four cancellation states:\n *  - `'unknown'`          — not yet resolved by the runtime (also what `cancelWorker` returns for\n *                           a request no acknowledger has answered), or — terminally, with the\n *                           run-over detail — an abort was issued but the run ended before the\n *                           termination could be observed. Never a success.\n *  - `'cancel_requested'` — the runtime issued the worker's abort; termination not yet proven.\n *  - `'cancelled'`        — the worker reached a terminal `down` state on the settle path.\n *  - `'not_live'`         — the worker was not live to cancel (already settled, it settled\n *                           `done` despite the abort, or the run ended before the request was\n *                           ever applied). Never a success of THIS operation.\n *\n * Expiry is run end: the owning manager's final pass closes every still-open request it owns\n * (`not_live` never applied, `unknown` issued-but-unproven), so a pending request cannot outlive\n * its run and abort a future spawn that happens to reuse a label.\n */\nexport interface WorkerCancellation {\n  readonly operationId: string\n  /** The worker reference exactly as requested. */\n  readonly worker: string\n  readonly effect: RetainedRunEffect\n  /** ISO timestamp of the original request. */\n  readonly requestedAt: string\n  /** ISO timestamp of the runtime's most recent observation of this operation. */\n  readonly observedAt: string\n  /** The node id the acknowledger resolved `worker` to, once resolved. */\n  readonly workerId?: string\n  /** The caller's reason, carried verbatim from the request. */\n  readonly reason?: string\n  /** The runtime's explanation of how it arrived at `effect`. */\n  readonly detail?: string\n  /**\n   * Every node id this operation PROVED terminated: the requested worker plus each descendant of\n   * its subtree observed to reach a terminal `down`/`cancelled` journal record at or after the\n   * abort was ISSUED — the acknowledger's own `observedAt` on the `cancel_requested` record\n   * (runtime clock), never the client's `requestedAt` (a cancelled lead cascades to its subtree\n   * by design — the scope signal chain — so the acknowledgement names the set, not one id).\n   * Proven at acknowledgement time; post-abort causation is approximate: a descendant that died\n   * of its own cause after the abort is indistinguishable from the cascade and may be included,\n   * a late teardown journal joins the set on a later pass while the manager still runs, and one\n   * still absent at run end is absent from the set. Grows monotonically; empty until termination\n   * is proven.\n   */\n  readonly terminated: ReadonlyArray<string>\n}\n\n/** One durable run-scoped cancel request: cancel the WHOLE run, not one worker. */\nexport interface RunCancelRequest {\n  /** Caller-minted stable operation identifier — the idempotency key of the whole operation. */\n  readonly operationId: string\n  /** ISO timestamp of the write. */\n  readonly at: string\n  /** Who asked — 'human', a brain label, a tool name. Provenance, not authorization. */\n  readonly source: string\n  readonly reason?: string\n}\n\n/**\n * The durable acknowledgement state for the run-scoped cancel operation, keyed by `operationId`.\n * The runtime is the ONLY writer; {@link cancelRun} only reads it.\n *\n * `effect` is the same {@link RetainedRunEffect} vocabulary the worker-scoped and retained-run\n * paths use, so the runtime has one spelling of the four cancellation states:\n *  - `'unknown'`          — no runtime has answered yet. Never a success.\n *  - `'cancel_requested'` — the root manager issued the run's cascading abort; the run's terminal\n *                           state is not yet observed.\n *  - `'cancelled'`        — the run reached its terminal state ABORTED after that request.\n *  - `'not_live'`         — the run was not live to cancel: it settled on its own despite the\n *                           request, or it ended before the request was applied.\n */\nexport interface RunCancellation {\n  readonly operationId: string\n  readonly effect: RetainedRunEffect\n  /** ISO timestamp of the original request. */\n  readonly requestedAt: string\n  /** ISO timestamp of the runtime's most recent observation of this operation. */\n  readonly observedAt: string\n  /** The caller's reason, carried verbatim from the request. */\n  readonly reason?: string\n  /** The runtime's explanation of how it arrived at `effect`. */\n  readonly detail?: string\n}\n\n/** The root every supervisor run of one workspace lives under. */\nexport function supervisorRunsRoot(rootDir: string): string {\n  return join(resolve(rootDir), '.agent', 'supervisor')\n}\n\n/** The run directory every artifact of one supervisor run lives under. */\nexport function supervisorRunDir(rootDir: string, id: string): string {\n  return join(supervisorRunsRoot(rootDir), id)\n}\n\n/**\n * Where a pre-rename writer put the same run (`<root>/.loops/supervisor/<id>`). Readers that must\n * see historical runs check {@link supervisorRunDir} first and fall back to this; nothing writes\n * here anymore.\n */\nexport function legacySupervisorRunDir(rootDir: string, id: string): string {\n  return join(legacySupervisorRunsRoot(rootDir), id)\n}\n\n/**\n * The pre-rename runs root (`<root>/.loops/supervisor`). Only readers that ENUMERATE historical\n * runs need this — the per-id form is {@link legacySupervisorRunDir}. Nothing writes here.\n */\nexport function legacySupervisorRunsRoot(rootDir: string): string {\n  return join(resolve(rootDir), '.loops', 'supervisor')\n}\n\n/** A worker label reduced to a safe filename stem. Empty labels get a stable fallback. */\nexport function safeWorkerFile(label: string): string {\n  const safe = label.replace(/[^A-Za-z0-9._-]/g, '_')\n  return safe.length > 0 ? safe : 'worker'\n}\n\n/** The directory holding every per-worker file of one run (inboxes and control-event logs). */\nexport function supervisorWorkersDir(eventDir: string): string {\n  return join(eventDir, 'workers')\n}\n\n/** The durable inbox file for one worker of one run. */\nexport function workerInboxFile(rootDir: string, supervisorId: string, worker: string): string {\n  return workerInboxFileFromEventDir(supervisorRunDir(rootDir, supervisorId), worker)\n}\n\n/** Same, addressed from an already-known run directory (the reader's usual entry point). */\nexport function workerInboxFileFromEventDir(eventDir: string, worker: string): string {\n  return join(supervisorWorkersDir(eventDir), `${safeWorkerFile(worker)}.inbox.ndjson`)\n}\n\n/**\n * The best-effort control-event log for one worker (`workers/<label>.ndjson`) — delivery\n * bookkeeping for steers, plus whatever lifecycle events a writer chooses to append. Distinct from\n * the inbox: the inbox is the durable down-leg queue, this is the record of what happened to it.\n */\nexport function workerControlLogFile(eventDir: string, worker: string): string {\n  return join(supervisorWorkersDir(eventDir), `${safeWorkerFile(worker)}.ndjson`)\n}\n\n/**\n * Durably append one steer request to a worker's inbox and log the delivery attempt.\n *\n * The inbox append is the durable act; the control-event log is best-effort bookkeeping and may\n * silently fail without voiding the steer.\n */\nexport function writeWorkerSteer(\n  rootDir: string,\n  supervisorId: string,\n  worker: string,\n  message: string,\n  source = 'human',\n): { worker: string; file: string; request: WorkerSteerRequest } {\n  const trimmed = message.trim()\n  if (!trimmed) throw new Error('steer message is empty')\n  const dir = supervisorRunDir(rootDir, supervisorId)\n  mkdirSync(supervisorWorkersDir(dir), { recursive: true })\n  const request: WorkerSteerRequest = {\n    id: randomUUID(),\n    at: new Date().toISOString(),\n    source,\n    worker,\n    message: trimmed,\n  }\n  const file = workerInboxFile(rootDir, supervisorId, worker)\n  appendFileSync(file, `${JSON.stringify(request)}\\n`, 'utf8')\n  appendWorkerControlEvent(dir, worker, {\n    kind: 'message',\n    direction: 'down',\n    source,\n    requestId: request.id,\n    message: trimmed,\n    queued: true,\n    delivered: false,\n  })\n  return { worker, file, request }\n}\n\n/** Read every valid steer request in a worker's inbox. Corrupt or partial lines are skipped. */\nexport function readWorkerSteerRequests(eventDir: string, worker: string): WorkerSteerRequest[] {\n  const file = workerInboxFileFromEventDir(eventDir, worker)\n  if (!existsSync(file)) return []\n  const out: WorkerSteerRequest[] = []\n  let raw = ''\n  try {\n    raw = readFileSync(file, 'utf8')\n  } catch {\n    return out\n  }\n  for (const line of raw.split('\\n')) {\n    const trimmed = line.trim()\n    if (!trimmed) continue\n    try {\n      const parsed = JSON.parse(trimmed) as Partial<WorkerSteerRequest>\n      if (isWorkerSteerRequest(parsed)) out.push(parsed)\n    } catch {\n      // Ignore partial or corrupt input lines; later valid lines still matter.\n    }\n  }\n  return out\n}\n\n/** The directory holding every cancellation artifact of one run (request inbox + acknowledgements). */\nexport function workerCancellationsDir(eventDir: string): string {\n  return join(eventDir, 'cancellations')\n}\n\n/** The durable cancel-request inbox of one run — one NDJSON line per {@link WorkerCancelRequest}. */\nexport function workerCancelRequestsFile(eventDir: string): string {\n  return join(workerCancellationsDir(eventDir), 'requests.ndjson')\n}\n\n/**\n * The acknowledgement file for one cancel operation. The filename is a sanitized stem of the\n * `operationId`; the record inside carries the exact id, and readers verify it so two distinct\n * ids that sanitize to one stem fail loud instead of answering for each other.\n */\nexport function workerCancellationFile(eventDir: string, operationId: string): string {\n  return join(workerCancellationsDir(eventDir), `${safeOperationFile(operationId)}.json`)\n}\n\nfunction safeOperationFile(operationId: string): string {\n  const safe = operationId.replace(/[^A-Za-z0-9._-]/g, '_')\n  if (safe.length === 0) throw new Error('cancel operationId is empty')\n  return safe\n}\n\n/** Read every valid cancel request in the run's cancellation inbox. Corrupt lines are skipped. */\nexport function readWorkerCancelRequests(eventDir: string): WorkerCancelRequest[] {\n  const file = workerCancelRequestsFile(eventDir)\n  if (!existsSync(file)) return []\n  const out: WorkerCancelRequest[] = []\n  let raw = ''\n  try {\n    raw = readFileSync(file, 'utf8')\n  } catch {\n    return out\n  }\n  for (const line of raw.split('\\n')) {\n    const trimmed = line.trim()\n    if (!trimmed) continue\n    try {\n      const parsed = JSON.parse(trimmed) as Partial<WorkerCancelRequest>\n      if (isWorkerCancelRequest(parsed)) out.push(parsed)\n    } catch {\n      // Ignore partial or corrupt input lines; later valid lines still matter.\n    }\n  }\n  return out\n}\n\n/**\n * Read the acknowledgement for one cancel operation. `undefined` when the runtime has not\n * answered. A record whose stored `operationId` differs from the requested one is a filename\n * collision between two sanitized ids — fail loud rather than return another operation's answer.\n */\nexport function readWorkerCancellation(\n  eventDir: string,\n  operationId: string,\n): WorkerCancellation | undefined {\n  const file = workerCancellationFile(eventDir, operationId)\n  if (!existsSync(file)) return undefined\n  const parsed = JSON.parse(readFileSync(file, 'utf8')) as WorkerCancellation\n  if (parsed.operationId !== operationId) {\n    throw new Error(\n      `cancel acknowledgement collision: '${file}' holds operation '${parsed.operationId}', ` +\n        `not '${operationId}' — use operation ids that stay distinct after filename sanitization`,\n    )\n  }\n  return parsed\n}\n\n/**\n * Durably write one acknowledgement record. Write-then-rename, so a concurrent reader sees the\n * prior complete record or the new complete record, never a partial file.\n *\n * @internal The runtime acknowledger is the only intended writer; clients read via\n * {@link readWorkerCancellation} or {@link cancelWorker}.\n */\nexport function writeWorkerCancellation(eventDir: string, record: WorkerCancellation): void {\n  const dir = workerCancellationsDir(eventDir)\n  mkdirSync(dir, { recursive: true })\n  const file = workerCancellationFile(eventDir, record.operationId)\n  const tmp = `${file}.${randomUUID()}.tmp`\n  writeFileSync(tmp, `${JSON.stringify(record, null, 2)}\\n`, 'utf8')\n  renameSync(tmp, file)\n}\n\n/**\n * Request the cancellation of ONE worker, idempotently, and return the operation's current\n * durable state.\n *\n * The write half of the acknowledged-cancellation contract (`writeWorkerSteer` is the steer\n * analog): append the request to the run's cancellation inbox, where the OWNING manager's\n * acknowledger (its turn loop — the root for label/profile references, the parent manager for an\n * exact node id at any depth) applies it — aborting exactly that worker's subtree and recording\n * what it proved. This function never applies the cancellation itself; writing a\n * request file is not an acknowledgement.\n *\n * Idempotency is a lookup: when an acknowledgement for `operationId` already exists, it is\n * returned AS-IS and nothing is appended — repeating one operation can never apply twice. A\n * request the runtime has not answered yet returns `effect: 'unknown'` (never a success); call\n * again with the same `operationId` — or `readWorkerCancellation` — to read the acknowledged\n * result after a reconnect.\n */\nexport function cancelWorker(\n  eventDir: string,\n  worker: string,\n  operationId: string,\n  options: { readonly reason?: string; readonly source?: string } = {},\n): WorkerCancellation {\n  const ref = worker.trim()\n  if (!ref) throw new Error('cancelWorker: worker reference is empty')\n  const opId = operationId.trim()\n  if (!opId) throw new Error('cancelWorker: operationId is empty')\n  const acknowledged = readWorkerCancellation(eventDir, opId)\n  if (acknowledged) return acknowledged\n  const source = options.source ?? 'human'\n  const pending = readWorkerCancelRequests(eventDir).find((r) => r.operationId === opId)\n  const request: WorkerCancelRequest = pending ?? {\n    operationId: opId,\n    at: new Date().toISOString(),\n    source,\n    worker: ref,\n    ...(options.reason === undefined ? {} : { reason: options.reason }),\n  }\n  if (!pending) {\n    mkdirSync(workerCancellationsDir(eventDir), { recursive: true })\n    appendFileSync(workerCancelRequestsFile(eventDir), `${JSON.stringify(request)}\\n`, 'utf8')\n    appendWorkerControlEvent(eventDir, ref, {\n      kind: 'cancel-request',\n      operationId: opId,\n      source,\n      queued: true,\n      ...(options.reason === undefined ? {} : { reason: options.reason }),\n    })\n  }\n  return {\n    operationId: opId,\n    worker: request.worker,\n    effect: 'unknown',\n    requestedAt: request.at,\n    observedAt: request.at,\n    ...(request.reason === undefined ? {} : { reason: request.reason }),\n    detail: 'request queued; no runtime acknowledger has answered yet',\n    terminated: [],\n  }\n}\n\n/** The run-scoped cancel request file of one run — one {@link RunCancelRequest}. */\nexport function runCancelRequestFile(eventDir: string): string {\n  return join(workerCancellationsDir(eventDir), 'run.request.json')\n}\n\n/** The run-scoped acknowledgement file of one run — one {@link RunCancellation}. */\nexport function runCancellationFile(eventDir: string): string {\n  return join(workerCancellationsDir(eventDir), 'run.json')\n}\n\n/** Read the run-scoped cancel request, or `undefined` when none was written. */\nexport function readRunCancelRequest(eventDir: string): RunCancelRequest | undefined {\n  const file = runCancelRequestFile(eventDir)\n  if (!existsSync(file)) return undefined\n  const parsed = JSON.parse(readFileSync(file, 'utf8')) as Partial<RunCancelRequest>\n  if (!isRunCancelRequest(parsed)) {\n    throw new Error(`run cancel request '${file}' is not a complete RunCancelRequest`)\n  }\n  return parsed\n}\n\n/**\n * Read the acknowledgement for the run-scoped cancel operation. `undefined` when the runtime has\n * not answered. A record holding a DIFFERENT `operationId` belongs to another operation on the\n * same run — fail loud rather than answer for it.\n */\nexport function readRunCancellation(\n  eventDir: string,\n  operationId: string,\n): RunCancellation | undefined {\n  const file = runCancellationFile(eventDir)\n  if (!existsSync(file)) return undefined\n  const parsed = JSON.parse(readFileSync(file, 'utf8')) as RunCancellation\n  if (parsed.operationId !== operationId) {\n    throw new Error(\n      `run cancel acknowledgement '${file}' holds operation '${parsed.operationId}', not ` +\n        `'${operationId}' — one run carries one run-scoped cancel operation`,\n    )\n  }\n  return parsed\n}\n\n/**\n * Durably write the run-scoped acknowledgement. Write-then-rename, so a concurrent reader sees the\n * prior complete record or the new complete record, never a partial file.\n *\n * @internal The runtime is the only intended writer; clients read via {@link readRunCancellation}\n * or {@link cancelRun}.\n */\nexport function writeRunCancellation(eventDir: string, record: RunCancellation): void {\n  const dir = workerCancellationsDir(eventDir)\n  mkdirSync(dir, { recursive: true })\n  const file = runCancellationFile(eventDir)\n  const tmp = `${file}.${randomUUID()}.tmp`\n  writeFileSync(tmp, `${JSON.stringify(record, null, 2)}\\n`, 'utf8')\n  renameSync(tmp, file)\n}\n\n/**\n * Request the cancellation of the WHOLE run, idempotently, and return the operation's current\n * durable state.\n *\n * The run-scoped twin of {@link cancelWorker}: write the request into the run's cancellation\n * directory, where the run's own root manager applies it — aborting the root through the one\n * cascade controller the run already has, so every live worker comes down with it. This function\n * never applies the cancellation itself; writing a request file is not an acknowledgement.\n *\n * Idempotency is a lookup: when an acknowledgement for `operationId` already exists it is returned\n * AS-IS and nothing is written. A request the runtime has not answered yet returns\n * `effect: 'unknown'` (never a success); call again with the same `operationId` — or\n * {@link readRunCancellation} — to read the acknowledged result after a reconnect.\n *\n * A run carries ONE run-scoped operation: a second request under a different `operationId` throws\n * rather than silently replacing the pending one, because both would claim the same single abort.\n */\nexport function cancelRun(\n  eventDir: string,\n  operationId: string,\n  options: { readonly reason?: string; readonly source?: string } = {},\n): RunCancellation {\n  const opId = operationId.trim()\n  if (!opId) throw new Error('cancelRun: operationId is empty')\n  const acknowledged = readRunCancellation(eventDir, opId)\n  if (acknowledged) return acknowledged\n  const pending = readRunCancelRequest(eventDir)\n  if (pending !== undefined && pending.operationId !== opId) {\n    throw new Error(\n      `cancelRun: run cancel '${pending.operationId}' is already pending for this run; ` +\n        `read it with readRunCancellation instead of issuing '${opId}'`,\n    )\n  }\n  const source = options.source ?? 'human'\n  const request: RunCancelRequest = pending ?? {\n    operationId: opId,\n    at: new Date().toISOString(),\n    source,\n    ...(options.reason === undefined ? {} : { reason: options.reason }),\n  }\n  if (pending === undefined) {\n    mkdirSync(workerCancellationsDir(eventDir), { recursive: true })\n    writeFileSync(runCancelRequestFile(eventDir), `${JSON.stringify(request, null, 2)}\\n`, 'utf8')\n    appendWorkerControlEvent(eventDir, 'run', {\n      kind: 'run-cancel-request',\n      operationId: opId,\n      source,\n      queued: true,\n      ...(options.reason === undefined ? {} : { reason: options.reason }),\n    })\n  }\n  return {\n    operationId: opId,\n    effect: 'unknown',\n    requestedAt: request.at,\n    observedAt: request.at,\n    ...(request.reason === undefined ? {} : { reason: request.reason }),\n    detail: 'request queued; no runtime acknowledger has answered yet',\n  }\n}\n\nfunction isRunCancelRequest(value: Partial<RunCancelRequest>): value is RunCancelRequest {\n  return (\n    typeof value.operationId === 'string' &&\n    value.operationId.length > 0 &&\n    typeof value.at === 'string' &&\n    typeof value.source === 'string' &&\n    (value.reason === undefined || typeof value.reason === 'string')\n  )\n}\n\nfunction isWorkerCancelRequest(value: Partial<WorkerCancelRequest>): value is WorkerCancelRequest {\n  return (\n    typeof value.operationId === 'string' &&\n    value.operationId.length > 0 &&\n    typeof value.at === 'string' &&\n    typeof value.source === 'string' &&\n    typeof value.worker === 'string' &&\n    value.worker.length > 0 &&\n    (value.reason === undefined || typeof value.reason === 'string')\n  )\n}\n\nfunction appendWorkerControlEvent(\n  eventDir: string,\n  label: string,\n  event: Record<string, unknown>,\n): void {\n  try {\n    mkdirSync(supervisorWorkersDir(eventDir), { recursive: true })\n    appendFileSync(\n      workerControlLogFile(eventDir, label),\n      `${JSON.stringify({ at: new Date().toISOString(), label, ...event })}\\n`,\n      'utf8',\n    )\n  } catch {\n    // Control logging is best-effort; the inbox write above is the durable part.\n  }\n}\n\nfunction isWorkerSteerRequest(value: Partial<WorkerSteerRequest>): value is WorkerSteerRequest {\n  return (\n    typeof value.id === 'string' &&\n    typeof value.at === 'string' &&\n    typeof value.source === 'string' &&\n    typeof value.worker === 'string' &&\n    typeof value.message === 'string' &&\n    value.message.trim().length > 0\n  )\n}\n"],"mappings":"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"}

package/dist/{runtime-htqI3fKL.d.ts → runtime-B-5dp5Iz.d.ts}

@@ -1,9 +1,10 @@
-import { E as SandboxClient, i as ExecCtx, k as Validator } from "./types-DZrBoBpN.js";
-import { I as Scope, Q as UsageEvent, U as Spend, d as ExecutorFactory, gn as ExecutorProgress, ln as TraceSource, m as ExecutorRegistry } from "./types-_7w24mMg.js";
-import { i as AgentEnvironmentProvider, o as AgentEnvironmentProviderRegistry, w as ProviderExecutorOptions } from "./environment-provider-BicwCDK5.js";
-import { AgentProfile, AgentProfileMcpServer, HarnessType, ReasoningEffort } from "@tangle-network/agent-interface";
+import { E as SandboxClient, at as RuntimeStreamEvent, i as ExecCtx, k as Validator } from "./types-DeX8ibLc.js";
+import { B as Scope, Cn as ExecutorProgress, _ as ExecutorRegistry, a as DefaultVerdict, g as ExecutorProgressEvent, gn as TraceSource, l as ExecutorCancellation, p as ExecutorFactory, q as Spend, rt as UsageEvent, u as ExecutorCancellationRequest, y as ExecutorToolCall } from "./types-BPQhQRrC.js";
+import { i as AgentEnvironmentProvider, o as AgentEnvironmentProviderRegistry, w as ProviderExecutorOptions } from "./environment-provider-DJG0yIYl.js";
+import { AgentProfile, AgentProfileMcpServer, HarnessType, ReasoningEffort, StreamEvent } from "@tangle-network/agent-interface";
 import { WorkspacePlanReceipt } from "@tangle-network/agent-profile-materialize";
 import { ChildProcess } from "node:child_process";
+import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
 import { BackendType, SandboxEvent } from "@tangle-network/sandbox";
 //#region src/mcp/protocol.d.ts
 /**
@@ -320,6 +321,13 @@ interface RouterConfig extends RouterTransportConfig {
    * lives here rather than on one call site.
    */
   maxTokens?: number;
+  /**
+   * Optional ceiling on TOTAL completion tokens — visible answer plus hidden reasoning —
+   * forwarded as `max_completion_tokens`. Distinct from `maxTokens`: a reasoning model can spend
+   * an entire `max_tokens` budget on hidden thinking, so only this field bounds what the provider
+   * bills for one completion.
+   */
+  maxCompletionTokens?: number;
   /**
    * Take the tool-calling completion over SSE instead of one buffered POST. Off by default —
    * `routerChatWithTools` never streams, and every existing caller keeps the buffered transport
@@ -770,6 +778,212 @@ interface ResolvedMcpServerLaunch {
  */
 declare function resolveMcpServerLaunch(server: AgentProfileMcpServer, keys: KeyProvider | undefined, label: string): Promise<ResolvedMcpServerLaunch>;
 //#endregion
+//#region src/runtime/sandbox-events.d.ts
+/** The provider/model the platform reports it actually bound to a turn, when it reports one.
+ *  `source` is the platform's own account of where that choice came from — `environment` means
+ *  the platform chose, not the request. */
+interface SandboxServedBackend {
+  readonly provider?: string;
+  readonly model?: string;
+  readonly source?: string;
+}
+/**
+ * Read the served execution identity off one Sandbox event.
+ *
+ * The platform reports `effectiveBackend` on `execution.started` and again on the terminal
+ * event (`@tangle-network/sandbox`, `EffectiveBackend`). Absence returns `undefined`
+ * and must stay unknown — a request is not a receipt, so nothing here may be inferred from
+ * what was asked for.
+ */
+declare function sandboxEventServedBackend(event: SandboxEvent): SandboxServedBackend | undefined;
+/**
+ * Fail the execution when the platform reports serving a model other than the exact one asked for.
+ *
+ * Measured motive (agent-runtime#892, live infrastructure 2026-08-17): 6 of 6 boxes whose profile
+ * declared `zai-coding-plan/glm-5.2` reported
+ * `{"provider":"openai-compat","model":"deepseek/deepseek-v4-flash","source":"environment"}`,
+ * while the materialization receipt recorded the declared model as `status: "known"`. Sending
+ * `backend.model` makes that substitution unlikely; only reading the report back makes it
+ * detectable. A run that cannot say which model produced its evidence must not settle as one
+ * that can.
+ *
+ * Silent when the platform reports no served model: unobserved stays unobserved.
+ */
+declare function assertSandboxServedModel(event: SandboxEvent, expected: {
+  readonly provider?: string;
+  readonly model?: string;
+} | undefined): void;
+/**
+ * Extract a `RuntimeStreamEvent`-shaped `llm_call` from a sandbox event when
+ * the event carries usage/cost data. Returns `undefined` for non-cost events
+ * so the kernel can iterate the full stream without branching.
+ *
+ * Pure by contract: it never throws on a failed run. The terminal truth
+ * boundary is the public Sandbox outcome tracker, applied after the complete
+ * stream. Post-hoc readers — {@link sumSandboxUsage}, the
+ * analyst trace store, the chat projection — must stay able to read a failed
+ * turn's events, which is when reading them matters most.
+ *
+ * Canonical cost-carrying types observed in the wild:
+ *   - `llm_call` — `data: { model, tokensIn, tokensOut, costUsd, ... }`
+ *   - `message.completed` / `result` — `data: { usage: { inputTokens,
+ *      outputTokens, totalCostUsd? } }`
+ *   - `cost.usage` / `usage` — same shape under a dedicated type
+ *
+ * Numeric coercion is strict: `Number.isFinite` gates every accumulator write
+ * so a sentinel `NaN` from a misbehaving backend cannot poison the ledger.
+ */
+declare function extractLlmCallEvent(event: SandboxEvent, agentRunName: string): (RuntimeStreamEvent & {
+  type: 'llm_call';
+}) | undefined;
+/**
+ * Sum the token usage + USD cost of a sandbox turn's events — the one honest way to meter an
+ * `openSandboxRun` cell. Folds `extractLlmCallEvent` over the stream (which reads usage off EVERY backend
+ * event shape), so a `runProfileMatrix` dispatch can report it to `ctx.cost`:
+ *
+ *     receipt: (turn) => {
+ *       const u = sumSandboxUsage(turn.events)
+ *       return { model, inputTokens: u.input, outputTokens: u.output,
+ *         ...(u.tokensKnown === false ? { usageUnknown: true } : {}),
+ *         ...(u.usdKnown !== false && u.costUsd > 0 ? { actualCostUsd: u.costUsd } : {}),
+ *         ...(u.usdKnown === false ? { costUnknown: true } : {}),
+ *         ...(u.estimatedCostUsd !== undefined ? { estimatedCostUsd: u.estimatedCostUsd } : {}) }
+ *     }
+ *
+ * Without this a cell reads `{tokens:0, cost:0}` and the backend-integrity guard correctly aborts the
+ * matrix as a stub. `agentRunName` is the fallback model label for cost-only events (default `'agent'`).
+ */
+declare function sumSandboxUsage(events: readonly SandboxEvent[], agentRunName?: string): {
+  input: number;
+  output: number;
+  costUsd: number;
+  tokensKnown?: false;
+  usdKnown?: false;
+  estimatedCostUsd?: number;
+};
+/**
+ * Cross-event state for {@link mapSandboxToolEvent}. Sandbox backends emit a
+ * tool invocation as MANY `message.part.updated` frames on the same call id
+ * (pending → running → completed), so faithful projection needs per-call
+ * status memory: one `tool_call` on first sighting, at most one `tool_result`
+ * on the terminal transition, nothing on intermediate re-frames. Create one
+ * state per turn via {@link createSandboxToolPartState}.
+ *
+ * @experimental
+ */
+interface SandboxToolPartState {
+  /** Last seen status per tool call id. A terminal status is sticky — later
+   *  frames on a settled call project to nothing. */
+  statusByCall: Map<string, string>;
+  /** Sequence for synthesized call ids when an event carries none. */
+  seq: number;
+}
+/**
+ * Fresh per-turn {@link SandboxToolPartState} for {@link mapSandboxToolEvent} — an
+ * empty call-status map so each turn projects tool frames independently.
+ *
+ * @experimental
+ */
+declare function createSandboxToolPartState(): SandboxToolPartState;
+/**
+ * Project one `SandboxEvent` onto the `tool_call` / `tool_result` variants of
+ * `RuntimeStreamEvent` — the tool-part projection `mapSandboxEvent`
+ * deliberately does NOT perform. Opt-in and additive: `mapSandboxEvent`'s
+ * default vocabulary (text/reasoning deltas + `llm_call`) is unchanged;
+ * consumers that need the tool surface (chat UIs rendering tool activity)
+ * compose this projector alongside it — `streamAgentTurn` does exactly that
+ * under its `preserveToolParts` option.
+ *
+ * Handled shapes (observed on the opencode / claude-code sandbox backends):
+ *   - `message.part.updated` with `part.type === 'tool'` — stateful: a
+ *     `tool_call` on the call id's first frame (args from `state.input` or
+ *     `state.metadata.input`), a `tool_result` when the status transitions to
+ *     `completed` (result from `state.output` / `metadata.output`) or to a
+ *     terminal failure (result is `{ error, status, output? }` — the error
+ *     surfaced in-band, never dropped).
+ *   - bare `tool*` event types (`tool.call`, `tool_result`, …) — stateless:
+ *     `*result*` types project to `tool_result`, the rest to `tool_call`.
+ *
+ * Returns `[]` for every non-tool event.
+ *
+ * @experimental
+ */
+declare function mapSandboxToolEvent(event: SandboxEvent, state: SandboxToolPartState): (RuntimeStreamEvent & {
+  type: 'tool_call' | 'tool_result';
+})[];
+/**
+ * Project one `SandboxEvent` onto the `RuntimeStreamEvent` chat-UX vocabulary,
+ * for runtimes that bridge a sandbox `streamPrompt` into the
+ * `AgentRuntime.act` streaming contract. Returns `undefined` for events that
+ * have no faithful projection — the raw stream is preserved separately for the
+ * `OutputAdapter`, so an unmapped event never loses data.
+ *
+ * Mapped (the task-optional incremental variants — no synthesized task
+ * lifecycle, no guessed tool-part shapes):
+ *   - `message.part.updated` text part → `text_delta`
+ *   - `message.part.updated` reasoning/thinking part → `reasoning_delta`
+ *   - cost-bearing events → `llm_call` (shared with the ledger extractor)
+ *
+ * Tool parts are deliberately NOT mapped here (unchanged default) — compose
+ * {@link mapSandboxToolEvent} alongside when a consumer needs them.
+ *
+ * The opencode backend emits incremental text as
+ * `{ type: 'message.part.updated', data: { part: { type, text }, delta } }`;
+ * `delta` is the increment, `part.text` the running accumulation.
+ */
+declare function mapSandboxEvent(event: SandboxEvent, opts?: {
+  agentRunName?: string;
+}): RuntimeStreamEvent | undefined;
+/**
+ * Project one `SandboxEvent` onto Runtime's executor progress vocabulary: incremental text and
+ * reasoning, tool calls and results, and an interaction request. It composes the existing
+ * projections ({@link mapSandboxEvent}, {@link mapSandboxToolEvent}, and the canonical Agent
+ * Interface decode) so every sandbox-shaped executor publishes live output through one reader.
+ * Usage-bearing events project to nothing here — accounting stays on the `tokens`/`cost`
+ * channels.
+ *
+ * Pass one {@link SandboxToolPartState} per turn so a multi-frame tool call yields one call and
+ * at most one result.
+ *
+ * @experimental
+ */
+declare function sandboxProgressEvents(event: SandboxEvent, state: SandboxToolPartState): ExecutorProgressEvent[];
+//#endregion
+//#region src/runtime/sandbox-executor-output.d.ts
+/**
+ * What a settled turn produced, as an explicit marker.
+ *
+ * `text` carries the byte length of the answer, `empty` says a text-bearing terminal event was
+ * observed and carried nothing, and `absent` says no text-bearing event was observed at all.
+ * The three are distinct on purpose: an empty settle blob used to be indistinguishable from lost
+ * output, so a reader could not tell a box that produced nothing from one whose answer never
+ * arrived.
+ */
+type SandboxOutputMarker = {
+  readonly kind: 'text';
+  readonly bytes: number;
+} | {
+  readonly kind: 'empty';
+} | {
+  readonly kind: 'absent';
+};
+/** Parsed output of one Sandbox executor turn. */
+interface SandboxLeafOut {
+  events: SandboxEvent[];
+  /** The observed answer. `undefined` when no text-bearing event was observed — never `''`. */
+  content: string | undefined;
+  /** Explicit account of what the turn produced. */
+  output: SandboxOutputMarker;
+  /**
+   * Provider and model the platform reported serving this turn, when it reported one. Absent means
+   * the platform said nothing; it is never filled from the request, because a request is not a
+   * receipt.
+   */
+  servedBackend?: SandboxServedBackend;
+  toolCalls?: ExecutorToolCall[];
+  outcome?: AgentRunOutcome;
+}
+//#endregion
 //#region src/runtime/supervise/inbox.d.ts
 /** A message from the run's AUTHORITY — the parent driver. These two kinds carry instruction. */
 interface AuthorityInboxMessage {
@@ -829,10 +1043,13 @@ interface SteerableSandboxSession {
   /** Drive the worker to settlement. `signal` is the spawn-scoped abort handed to `execute`. */
   stream(task: unknown, signal: AbortSignal): AsyncIterable<UsageEvent>;
   progress(): ExecutorProgress;
+  /** Ask the box to stop the running execution on this exact session and report what it answered. */
+  cancel(request: ExecutorCancellationRequest): Promise<ExecutorCancellation>;
   traceSource(): TraceSource;
   artifact(): {
     outRef: string;
     out: unknown;
+    verdict?: DefaultVerdict;
     spent: Spend;
   } | undefined;
   teardown(): Promise<void>;
@@ -1109,11 +1326,6 @@ interface RouterToolsSeam {
     durationMs?: number;
   }) => void;
 }
-/** Parsed output of the sandbox leaf: the iteration's raw event stream. What a
- *  `SandboxSeam.validator` receives as its `output` argument. */
-interface SandboxLeafOut {
-  events: SandboxEvent[];
-}
 /**
  * The leaf `createWorktreeCliExecutor` as a backend-as-data factory: a supervisor-authored
  * `AgentProfile` driving claude / codex / opencode on its own worktree. `budgetExempt` like
@@ -1161,5 +1373,5 @@ declare function createExecutor(config: ExecutorConfig): ExecutorFactory<unknown
  */
 declare function createExecutorRegistry(): ExecutorRegistry;
 //#endregion
-export { WorktreeHandle as $, resolveSecretEnv as A, JsonRpcResponse as At, LOCAL_HARNESSES as B, PeerInboxMessage as C, PeerMailboxOptions as Ct, envKeyProvider as D, peerMailTools as Dt, ResolvedMcpServerLaunch as E, isPeerMailEnvelope as Et, WorktreeProfileMaterializationReceipt as F, localHarnessExecutable as G, LocalHarnessResult as H, CodexExecutionEvidence as I, CreateWorktreeOptions as J, parseCodexTokenUsage as K, CodexExecutionPolicy as L, WorktreeCheckRunner as M, McpTransport as Mt, WorktreeCommandResult as N, mcpSecretEnvMetadataKey as O, peerMailVerbNames as Ot, WorktreeHarnessResult as P, RemoveWorktreeOptions as Q, CodexTokenUsage as R, InboxMessage as S, PeerMailbox as St, KeyProvider as T, createPeerMailbox as Tt, RunLocalHarnessOptions as U, LocalHarness as V, harnessSupportsReasoningEffort as W, DiffResult as X, DiffOptions as Y, GitRunner as Z, SteerableSandboxArgs as _, PeerMailLimits as _t, CliWorktreeSeam as a, ToolLoopCallContext as at, AuthorityInboxMessage as b, PeerMailRefusal as bt, RouterSeam as c, ToolLoopCompactionOptions as ct, SandboxSeam as d, AUTHORITY_MARKERS as dt, captureWorktreeDiff as et, cliWorktreeExecutor as f, DEFAULT_PEER_MAIL_LIMITS as ft, SandboxSteeringOptions as g, PeerMailKind as gt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as h, PeerMailEvent as ht, CliWorktreeBridgeSeam as i, ToolSpec as it, secretEnvOfMcpServer as j, McpToolDescriptor as jt, resolveMcpServerLaunch as k, JsonRpcMessage as kt, RouterToolsSeam as l, ToolLoopMessageRecord as lt, createExecutorRegistry as m, PeerMailEnvelope as mt, BridgeSeam as n, removeWorktree as nt, ExecutorConfig as o, ToolLoopChat as ot, createExecutor as p, PEER_MAIL_WIRE_KEY as pt, runLocalHarness as q, CliSeam as r, RouterTransportConfig as rt, ProviderSeam as s, ToolLoopCompaction as st, BridgeModelCredential as t, createWorktree as tt, SandboxLeafOut as u, ToolLoopToolCall as ut, SteerableSandboxSession as v, PeerMailOutcome as vt, createInbox as w, claimsAuthority as wt, Inbox as x, PeerMailSendInput as xt, createSteerableSandboxSession as y, PeerMailReadout as yt, DEFAULT_LOCAL_HARNESS as z };
-//# sourceMappingURL=runtime-htqI3fKL.d.ts.map
+export { LocalHarnessResult as $, extractLlmCallEvent as A, PeerMailReadout as At, resolveMcpServerLaunch as B, JsonRpcMessage as Bt, createInbox as C, DEFAULT_PEER_MAIL_LIMITS as Ct, SandboxToolPartState as D, PeerMailKind as Dt, SandboxServedBackend as E, PeerMailEvent as Et, sumSandboxUsage as F, claimsAuthority as Ft, WorktreeHarnessResult as G, secretEnvOfMcpServer as H, McpToolDescriptor as Ht, KeyProvider as I, createPeerMailbox as It, CodexExecutionPolicy as J, WorktreeProfileMaterializationReceipt as K, ResolvedMcpServerLaunch as L, isPeerMailEnvelope as Lt, mapSandboxToolEvent as M, PeerMailSendInput as Mt, sandboxEventServedBackend as N, PeerMailbox as Nt, assertSandboxServedModel as O, PeerMailLimits as Ot, sandboxProgressEvents as P, PeerMailboxOptions as Pt, LocalHarness as Q, envKeyProvider as R, peerMailTools as Rt, PeerInboxMessage as S, AUTHORITY_MARKERS as St, SandboxOutputMarker as T, PeerMailEnvelope as Tt, WorktreeCheckRunner as U, McpTransport as Ut, resolveSecretEnv as V, JsonRpcResponse as Vt, WorktreeCommandResult as W, DEFAULT_LOCAL_HARNESS as X, CodexTokenUsage as Y, LOCAL_HARNESSES as Z, SteerableSandboxSession as _, ToolLoopChat as _t, CliWorktreeSeam as a, CreateWorktreeOptions as at, Inbox as b, ToolLoopMessageRecord as bt, RouterSeam as c, GitRunner as ct, cliWorktreeExecutor as d, captureWorktreeDiff as dt, RunLocalHarnessOptions as et, createExecutor as f, createWorktree as ft, SteerableSandboxArgs as g, ToolLoopCallContext as gt, SandboxSteeringOptions as h, ToolSpec as ht, CliWorktreeBridgeSeam as i, runLocalHarness as it, mapSandboxEvent as j, PeerMailRefusal as jt, createSandboxToolPartState as k, PeerMailOutcome as kt, RouterToolsSeam as l, RemoveWorktreeOptions as lt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as m, RouterTransportConfig as mt, BridgeSeam as n, localHarnessExecutable as nt, ExecutorConfig as o, DiffOptions as ot, createExecutorRegistry as p, removeWorktree as pt, CodexExecutionEvidence as q, CliSeam as r, parseCodexTokenUsage as rt, ProviderSeam as s, DiffResult as st, BridgeModelCredential as t, harnessSupportsReasoningEffort as tt, SandboxSeam as u, WorktreeHandle as ut, createSteerableSandboxSession as v, ToolLoopCompaction as vt, SandboxLeafOut as w, PEER_MAIL_WIRE_KEY as wt, InboxMessage as x, ToolLoopToolCall as xt, AuthorityInboxMessage as y, ToolLoopCompactionOptions as yt, mcpSecretEnvMetadataKey as z, peerMailVerbNames as zt };
+//# sourceMappingURL=runtime-B-5dp5Iz.d.ts.map