@tangle-network/agent-runtime 2.2.1 → 2.3.0

package/dist/{journal-store-E6TojmWB.js → root-stream-To4qAc0e.js}

@@ -1,16 +1,17 @@
 import { m as ValidationError, r as BackendTransportError } from "./errors-AzSuGI23.js";
-import { D as assertResources, E as addResourceSpend, T as zeroTokenUsage, i as chargedTokens, k as withBudgetResources, l as fnv1a32Hex, m as promptCacheTokenClasses, o as cloneTokenUsage, r as addTokenUsage, u as hasCompleteCacheBreakdown } from "./util-BX20UJ9X.js";
-import { d as detachedSnapshot, m as errMessage, n as isNoEntError, o as readCommittedJsonLines, p as causeChain, t as appendCommittedJsonLine } from "./jsonl-file-BBP9Dz9w.js";
-import { n as assertNoSymlinkDescendant, o as captureRunWriteContext, r as publishExclusiveDurableFile } from "./durable-file-DstVeHcj.js";
+import { D as assertResources, E as addResourceSpend, T as zeroTokenUsage, c as errorMessage, i as chargedTokens, k as withBudgetResources, l as fnv1a32Hex, m as promptCacheTokenClasses, o as cloneTokenUsage, r as addTokenUsage, u as hasCompleteCacheBreakdown } from "./util-BX20UJ9X.js";
+import { d as detachedSnapshot, i as prepareJsonlAppend, l as sha256, m as errMessage, n as isNoEntError, o as readCommittedJsonLines, p as causeChain, t as appendCommittedJsonLine } from "./jsonl-file-BBP9Dz9w.js";
+import { a as writeAtomicDurableFile, n as assertNoSymlinkDescendant, o as captureRunWriteContext, r as publishExclusiveDurableFile, s as fenceRunWrite, t as appendDurableFile } from "./durable-file-DstVeHcj.js";
 import { a as withPursuitContext } from "./runtime-hooks-CsW2pfFk.js";
-import { AgentTurnResultSchema, CanonicalStreamEventSchema, RuntimeEventEnvelopeSchema } from "@tangle-network/agent-interface";
+import { AgentTurnResultSchema, CanonicalStreamEventSchema, RuntimeEventEnvelopeSchema, canonicalCandidateDigest } from "@tangle-network/agent-interface";
 import { isRecord } from "@tangle-network/agent-core";
 import { collectAgentFinalMessageText, collectAgentResponseText } from "@tangle-network/sandbox";
 import { z } from "zod";
 import { createHash } from "node:crypto";
 import { LedgerCanonicalizationError, canonicalString, jsonDocument, merkleLeafHash, merkleRoot, merkleSalt } from "@tangle-network/agent-eval/ledger-core";
-import { fstatSync, statSync } from "node:fs";
-import { resolve } from "node:path";
+import { appendFileSync, closeSync, constants, existsSync, fstatSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, statSync, writeSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { mkdir } from "node:fs/promises";
 // src/record-value.ts
 function recordValue(value) {
 	return isRecord(value) ? value : void 0;
@@ -3545,6 +3546,707 @@ var FileSpawnJournal = class {
 function journalFileStamp(stat) {
 	return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
 }
-export { newUsageTotals as $, workspaceCaptureWriter as A, TRACE_SUMMARY_SCHEMA as B, executorEvidenceWriter as C, sumSandboxUsage as Ct, registerRetainedExecutorPreparation as D, prepareRetainedExecutor as E, recordValue as Et, unavailablePauseMs as F, executorFailureInfra as G, contentAddress as H, unavailableResumeAt as I, credentialCommandExit as J, executorFailureReason as K, unavailableSignalInText as L, UNAVAILABLE_STATUSES as M, cappedDoublingMs as N, retainedExecutorContext as O, jitteredMs as P, meterUsageEvent as Q, unavailableSignalOfFailure as R, RetainedExecutionPendingError as S, sandboxTerminalUsageField as St, leafContinuationExecutionId as T, parseCodexUsageRecord as Tt, contentRef as U, traceRootWriter as V, executorFailure as W, BudgetReconcileFault as X, isCredentialRefusal as Y, createBudgetPool as Z, runtimeFailureRemediationSchema as _, createSandboxUsageLedger as _t, encodeResultBlob as a, mapSandboxEvent as at, BUDGET_CONTINUATION_TASK as b, notifySandboxEventObserver as bt, insideCursorNamespace as c, sandboxOutputMarker as ct, createFileObserverHooks as d, canonicalStreamEventFromSandboxEvent as dt, spendFromUsageEvents as et, observerRecordDigest as f, extractTransportEventIdentity as ft, runtimeFailureCauseSchema as g, createSandboxTurnEventCollector as gt, runtimeFailureCause as h, canonicalSandboxUsageMode as ht, FileResultBlobStore as i, createSandboxToolPartState as it, UNAVAILABLE_CODES as j, retainedExecutorSeamKey as k, outsideCursorNamespace as l, sandboxProgressEvents as lt, reportedFailureCause as m, assertSandboxServedModel as mt, appendSpawnEvents as n, assertValidBudget as nt, SpawnEventIndex as o, mapSandboxToolEvent as ot, verifyObserverRecords as p, parseCanonicalTransportEvent as pt, hashJson as q, spawnJournalRecordEvents as r, assertValidSpend as rt, closesCursorSlot as s, sandboxLeafOutputFromEvents as st, FileSpawnJournal as t, spendFromUsageTotals as tt, FileObserverJournal as u, terminalTextFromSandboxEvent as ut, runtimeProviderCode as v, extractLlmCallEvent as vt, isProvisioningRefusal as w, decodeHarnessUsage as wt, DISPATCH_NOT_ADMITTED_CODE as x, sandboxEventServedBackend as xt, settlementFailureCause as y, isSandboxTerminalEvent as yt, TRACE_ROOT_SCHEMA as z };
+// src/runtime/supervise/run-layout.ts
+/**
+* The on-disk supervisor-run layout: `<root>/.agent/supervisor/<id>`.
+*
+* This is the durable, cross-process face of a supervisor run — the counterpart to the in-process
+* `Inbox` seam in `./inbox`. A run persists its state under one directory so that any OTHER process
+* can find it after the fact: `@tangle-network/traces` reads exactly this layout via
+* `traces analyze --supervisor-run-dir`, a restarted host can rehydrate a run it no longer holds
+* handles to, and a human can steer a live worker by appending one NDJSON line. Until now the
+* layout was defined only in the unpublished `loops` repo (`src/supervisor-control.ts`) — a
+* published reader depending on an unpublished writer's convention — so the contract is promoted
+* here, names preserved.
+*
+* `.agent` is the one dot-dir for ALL agent-owned state (skills already write
+* `.agent/hypotheses/`, `.agent/skill-runs.jsonl`); supervisor runs live beside them rather than
+* under a product-branded dir. Runs written by older writers used `.loops/supervisor/<id>` —
+* readers that must see those keep a legacy fallback; this writer never creates `.loops` again.
+*
+* Layout, relative to `supervisorRunDir(root, id)`:
+*
+*   steers/requests/<hash>.json    one exact, caller-idempotent {@link WorkerSteerRequest}
+*   steers/acks/<hash>.json        runtime acknowledgement for that steer operation
+*   workers/<id>.inbox.ndjson      best-effort readable projection of admitted steer requests
+*   workers/<label>.ndjson         best-effort per-worker control-event log (delivery bookkeeping)
+*   cancellations/requests.ndjson  worker-scoped cancel requests (durable inbox); each line is a
+*                                  {@link WorkerCancelRequest}
+*   cancellations/<opId>.json      the acknowledgement for one cancel operation — a
+*                                  {@link WorkerCancellation} written ONLY by the runtime
+*                                  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. Duplicate operation ids
+* collapse to the first admitted request, while a payload conflict fails closed.
+*
+* Promoted from `loops/src/supervisor-control.ts`. Steer admission now requires the exact worker id
+* and a caller-owned operation id. One atomic request file is the durable inbox; the NDJSON file is
+* a readable projection only and never controls idempotency.
+*
+* @experimental
+*/
+/** The root every supervisor run of one workspace lives under. */
+function supervisorRunsRoot(rootDir) {
+	return join(resolve(rootDir), ".agent", "supervisor");
+}
+/** The run directory every artifact of one supervisor run lives under. */
+function supervisorRunDir(rootDir, id) {
+	return join(supervisorRunsRoot(rootDir), id);
+}
+/**
+* Where a pre-rename writer put the same run (`<root>/.loops/supervisor/<id>`). Readers that must
+* see historical runs check {@link supervisorRunDir} first and fall back to this; nothing writes
+* here anymore.
+*/
+function legacySupervisorRunDir(rootDir, id) {
+	return join(legacySupervisorRunsRoot(rootDir), id);
+}
+/**
+* The pre-rename runs root (`<root>/.loops/supervisor`). Only readers that ENUMERATE historical
+* runs need this — the per-id form is {@link legacySupervisorRunDir}. Nothing writes here.
+*/
+function legacySupervisorRunsRoot(rootDir) {
+	return join(resolve(rootDir), ".loops", "supervisor");
+}
+/** A worker label reduced to a safe filename stem. Empty labels get a stable fallback. */
+function safeWorkerFile(label) {
+	const safe = label.replace(/[^A-Za-z0-9._-]/g, "_");
+	return safe.length > 0 ? safe : "worker";
+}
+/** The directory holding every per-worker file of one run (inboxes and control-event logs). */
+function supervisorWorkersDir(eventDir) {
+	return join(eventDir, "workers");
+}
+/** Same, addressed from an already-known run directory (the reader's usual entry point). */
+function workerInboxFileFromEventDir(eventDir, worker) {
+	return join(supervisorWorkersDir(eventDir), `${safeWorkerFile(worker)}.inbox.ndjson`);
+}
+/**
+* The best-effort control-event log for one worker (`workers/<label>.ndjson`) — delivery
+* bookkeeping for steers, plus whatever lifecycle events a writer chooses to append. Distinct from
+* the inbox: the inbox is the durable down-leg queue, this is the record of what happened to it.
+*/
+function workerControlLogFile(eventDir, worker) {
+	return join(supervisorWorkersDir(eventDir), `${safeWorkerFile(worker)}.ndjson`);
+}
+/** Directory containing atomically admitted steer requests and runtime acknowledgements. */
+function workerSteersDir(eventDir) {
+	return join(eventDir, "steers");
+}
+/** Directory containing one canonical request file per steer operation. */
+function workerSteerRequestsDir(eventDir) {
+	return join(workerSteersDir(eventDir), "requests");
+}
+/** Directory containing one runtime acknowledgement per steer operation. */
+function workerSteerAcknowledgementsDir(eventDir) {
+	return join(workerSteersDir(eventDir), "acks");
+}
+/** Canonical request file for one caller-owned steer operation id. */
+function workerSteerRequestFile(eventDir, operationId) {
+	return join(workerSteerRequestsDir(eventDir), `${operationFileHash(operationId)}.json`);
+}
+/** Runtime acknowledgement file for one caller-owned steer operation id. */
+function workerSteerAcknowledgementFile(eventDir, operationId) {
+	return join(workerSteerAcknowledgementsDir(eventDir), `${operationFileHash(operationId)}.json`);
+}
+/**
+* Admit one steer exactly once under a caller-owned operation id.
+*
+* Pass `supervisorId` as `worker` to address the root. Router roots consume requests between
+* turns; native roots use their existing accepting inbox during execution, or acknowledge
+* `unsupported` when none is available. Delivery does not prove model consumption.
+* This filesystem API requires trusted write access to the run directory; it adds no MCP grant.
+*
+* The per-operation request file is linked into place atomically after its bytes reach disk. A
+* same-body retry returns the winner's request. A changed-body retry fails loud. The NDJSON inbox
+* and control log are readable projections written only by the admission winner.
+* @stable
+*/
+function writeWorkerSteer(rootDir, supervisorId, worker, options) {
+	const workerId = worker.trim();
+	if (!workerId) throw new Error("writeWorkerSteer: worker id is empty");
+	const operationId = options.operationId.trim();
+	if (!operationId) throw new Error("writeWorkerSteer: operationId is empty");
+	const trimmed = options.message.trim();
+	if (!trimmed) throw new Error("steer message is empty");
+	const source = options.source?.trim() || "human";
+	const interrupt = options.interrupt === true;
+	if (options.eventDir !== void 0 && !options.eventDir.trim()) throw new Error("writeWorkerSteer: eventDir is empty");
+	const dir = options.eventDir === void 0 ? supervisorRunDir(rootDir, supervisorId) : resolve(options.eventDir);
+	const requestDigest = workerSteerRequestDigest({
+		operationId,
+		worker: workerId,
+		message: trimmed,
+		source,
+		interrupt
+	});
+	const request = {
+		schemaVersion: 1,
+		operationId,
+		requestDigest,
+		at: (/* @__PURE__ */ new Date()).toISOString(),
+		source,
+		worker: workerId,
+		message: trimmed,
+		interrupt
+	};
+	const file = workerSteerRequestFile(dir, operationId);
+	assertNoSymlinkDescendant(dir, file, "steer request");
+	mkdirSync(workerSteerRequestsDir(dir), { recursive: true });
+	assertNoSymlinkDescendant(dir, file, "steer request");
+	const admitted = admitSteerRequest(file, request);
+	if (admitted.replayed) return {
+		worker: admitted.request.worker,
+		file,
+		request: admitted.request,
+		...readWorkerSteerAcknowledgement(dir, operationId) === void 0 ? {} : { acknowledgement: readWorkerSteerAcknowledgement(dir, operationId) },
+		replayed: true
+	};
+	mkdirSync(supervisorWorkersDir(dir), { recursive: true });
+	const projection = workerInboxFileFromEventDir(dir, workerId);
+	try {
+		fenceRunWrite(() => appendFileSync(projection, `${JSON.stringify(request)}\n`, "utf8"));
+	} catch {}
+	appendWorkerControlEvent(dir, workerId, {
+		kind: "message",
+		direction: "down",
+		source,
+		operationId,
+		requestDigest,
+		message: trimmed,
+		interrupt,
+		queued: true,
+		delivered: false
+	});
+	return {
+		worker: workerId,
+		file,
+		request,
+		replayed: false
+	};
+}
+/** Read every atomically admitted request for one exact worker id, in admission order. @stable */
+function readWorkerSteerRequests(eventDir, worker) {
+	const workerId = worker?.trim();
+	if (worker !== void 0 && !workerId) return [];
+	let names;
+	assertNoSymlinkDescendant(eventDir, workerSteerRequestsDir(eventDir), "steer request");
+	try {
+		names = readdirSync(workerSteerRequestsDir(eventDir));
+	} catch {
+		return [];
+	}
+	const out = [];
+	for (const name of names) {
+		if (!name.endsWith(".json")) continue;
+		try {
+			const file = join(workerSteerRequestsDir(eventDir), name);
+			assertNoSymlinkDescendant(eventDir, file, "steer request");
+			const parsed = parseWorkerSteerRequest(JSON.parse(readFileSync(file, "utf8")));
+			if (name !== `${operationFileHash(parsed.operationId)}.json`) continue;
+			if (workerId === void 0 || parsed.worker === workerId) out.push(parsed);
+		} catch {}
+	}
+	return out.sort((left, right) => left.at === right.at ? left.operationId.localeCompare(right.operationId) : left.at.localeCompare(right.at));
+}
+/** Read one runtime steer acknowledgement, or `undefined` while no manager has answered. @stable */
+function readWorkerSteerAcknowledgement(eventDir, operationId) {
+	const id = operationId.trim();
+	if (!id) throw new Error("readWorkerSteerAcknowledgement: operationId is empty");
+	const file = workerSteerAcknowledgementFile(eventDir, id);
+	assertNoSymlinkDescendant(eventDir, file, "steer acknowledgement");
+	if (!existsSync(file)) return void 0;
+	const record = parseWorkerSteerAcknowledgement(JSON.parse(readFileSync(file, "utf8")));
+	if (record.operationId !== id) throw new Error(`steer acknowledgement '${file}' belongs to another operation`);
+	return record;
+}
+/**
+* Claim one steer for delivery with an atomic no-clobber acknowledgement.
+* Returns `true` only to the process that created the pre-delivery record.
+* @internal
+*/
+function claimWorkerSteerDelivery(eventDir, record) {
+	const exact = parseWorkerSteerAcknowledgement(record);
+	if (exact.effect !== "unknown") throw new Error("steer delivery claim must use effect unknown");
+	const request = readWorkerSteerRequest(eventDir, exact.operationId);
+	if (request === void 0 || request.requestDigest !== exact.requestDigest) throw new Error("steer delivery claim does not match an admitted request");
+	const dir = workerSteerAcknowledgementsDir(eventDir);
+	assertNoSymlinkDescendant(eventDir, dir, "steer acknowledgement");
+	mkdirSync(dir, { recursive: true });
+	assertNoSymlinkDescendant(eventDir, dir, "steer acknowledgement");
+	const file = workerSteerAcknowledgementFile(eventDir, exact.operationId);
+	if (publishExclusiveDurableFile(file, `${JSON.stringify(exact, null, 2)}\n`)) return true;
+	const winner = readWorkerSteerAcknowledgement(eventDir, exact.operationId);
+	if (winner === void 0 || winner.operationId !== exact.operationId || winner.requestDigest !== exact.requestDigest) throw new Error("steer delivery claim conflicts with another operation");
+	return false;
+}
+/** Atomically replace the runtime acknowledgement for one steer operation. @internal */
+function writeWorkerSteerAcknowledgement(eventDir, record) {
+	const exact = parseWorkerSteerAcknowledgement(record);
+	const request = readWorkerSteerRequest(eventDir, exact.operationId);
+	if (request === void 0 || request.requestDigest !== exact.requestDigest) throw new Error("steer acknowledgement does not match an admitted request");
+	const dir = workerSteerAcknowledgementsDir(eventDir);
+	assertNoSymlinkDescendant(eventDir, dir, "steer acknowledgement");
+	mkdirSync(dir, { recursive: true });
+	assertNoSymlinkDescendant(eventDir, dir, "steer acknowledgement");
+	const file = workerSteerAcknowledgementFile(eventDir, exact.operationId);
+	const prior = readWorkerSteerAcknowledgement(eventDir, exact.operationId);
+	if (prior !== void 0 && prior.effect !== "unknown" && canonicalCandidateDigest(prior) !== canonicalCandidateDigest(exact)) throw new Error(`steer operation '${exact.operationId}' already has a terminal acknowledgement`);
+	writeAtomicDurableFile(file, `${JSON.stringify(exact, null, 2)}\n`);
+}
+/** The directory holding every cancellation artifact of one run (request inbox + acknowledgements). */
+function workerCancellationsDir(eventDir) {
+	return join(eventDir, "cancellations");
+}
+/**
+* The durable cancel-request inbox of one run — one NDJSON line per {@link WorkerCancelRequest}.
+* It stays append-only so independent operations retain admission order and readers can skip a
+* partial trailing line. `appendDurableFile` uses O_APPEND, one write, file fsync, and directory
+* fsync; single-record acknowledgements use atomic replacement instead.
+*/
+function workerCancelRequestsFile(eventDir) {
+	return join(workerCancellationsDir(eventDir), "requests.ndjson");
+}
+/**
+* The acknowledgement file for one cancel operation. The filename is a sanitized stem of the
+* `operationId`; the record inside carries the exact id, and readers verify it so two distinct
+* ids that sanitize to one stem fail loud instead of answering for each other.
+*/
+function workerCancellationFile(eventDir, operationId) {
+	return join(workerCancellationsDir(eventDir), `${safeOperationFile(operationId)}.json`);
+}
+function safeOperationFile(operationId) {
+	const safe = operationId.replace(/[^A-Za-z0-9._-]/g, "_");
+	if (safe.length === 0) throw new Error("cancel operationId is empty");
+	return safe;
+}
+/** Read every valid cancel request in the run's cancellation inbox. Corrupt lines are skipped. */
+function readWorkerCancelRequests(eventDir) {
+	const dir = workerCancellationsDir(eventDir);
+	const file = workerCancelRequestsFile(eventDir);
+	assertNoSymlinkDescendant(eventDir, dir, "cancel request");
+	assertNoSymlinkDescendant(eventDir, file, "cancel request");
+	if (!existsSync(file)) return [];
+	const out = [];
+	const byOperationId = /* @__PURE__ */ new Map();
+	let raw = "";
+	try {
+		raw = readFileSync(file, "utf8");
+	} catch {
+		return out;
+	}
+	for (const line of raw.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			continue;
+		}
+		if (!isWorkerCancelRequest(parsed)) continue;
+		const prior = byOperationId.get(parsed.operationId);
+		if (prior !== void 0) assertSameWorkerCancelRequest(prior, parsed);
+		else {
+			byOperationId.set(parsed.operationId, parsed);
+			out.push(parsed);
+		}
+	}
+	return out;
+}
+/**
+* Read the acknowledgement for one cancel operation. `undefined` when the runtime has not
+* answered. A record whose stored `operationId` differs from the requested one is a filename
+* collision between two sanitized ids — fail loud rather than return another operation's answer.
+*/
+function readWorkerCancellation(eventDir, operationId) {
+	const dir = workerCancellationsDir(eventDir);
+	const file = workerCancellationFile(eventDir, operationId);
+	assertNoSymlinkDescendant(eventDir, dir, "cancel acknowledgement");
+	assertNoSymlinkDescendant(eventDir, file, "cancel acknowledgement");
+	if (!existsSync(file)) return void 0;
+	const parsed = JSON.parse(readFileSync(file, "utf8"));
+	if (parsed.operationId !== operationId) throw new Error(`cancel acknowledgement collision: '${file}' holds operation '${parsed.operationId}', not '${operationId}' — use operation ids that stay distinct after filename sanitization`);
+	return parsed;
+}
+/**
+* Durably write one acknowledgement record. The shared writer fsyncs the file and containing
+* directory, so a concurrent reader sees the prior complete record or the new complete record.
+*
+* @internal The runtime acknowledger is the only intended writer; clients read via
+* {@link readWorkerCancellation} or {@link cancelWorker}.
+*/
+function writeWorkerCancellation(eventDir, record) {
+	const dir = workerCancellationsDir(eventDir);
+	assertNoSymlinkDescendant(eventDir, dir, "cancel acknowledgement");
+	mkdirSync(dir, { recursive: true });
+	assertNoSymlinkDescendant(eventDir, dir, "cancel acknowledgement");
+	const file = workerCancellationFile(eventDir, record.operationId);
+	assertNoSymlinkDescendant(eventDir, file, "cancel acknowledgement");
+	writeAtomicDurableFile(file, `${JSON.stringify(record, null, 2)}\n`, { mode: 384 });
+}
+/**
+* Request the cancellation of ONE worker, idempotently, and return the operation's current
+* 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 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
+* returned AS-IS and nothing is appended — repeating one operation can never apply twice. A
+* retry that changes the worker, source, or reason fails closed. A request the runtime has not
+* answered yet returns `effect: 'unknown'` (never a success); call again with the same
+* `operationId` — or `readWorkerCancellation` — to read the acknowledged result after a
+* reconnect.
+*/
+function cancelWorker(eventDir, worker, operationId, options = {}) {
+	const ref = worker.trim();
+	if (!ref) throw new Error("cancelWorker: worker reference is empty");
+	const opId = operationId.trim();
+	if (!opId) throw new Error("cancelWorker: operationId is empty");
+	const pending = readWorkerCancelRequests(eventDir).find((r) => r.operationId === opId);
+	const candidate = {
+		operationId: opId,
+		worker: ref,
+		source: options.source ?? "human",
+		...options.reason === void 0 ? {} : { reason: options.reason }
+	};
+	if (pending !== void 0) assertSameWorkerCancelRequest(pending, candidate);
+	const acknowledged = readWorkerCancellation(eventDir, opId);
+	if (acknowledged !== void 0) {
+		if (pending === void 0 && options.source !== void 0) throw new Error(`cancelWorker: operation '${opId}' cannot verify source without its admitted request`);
+		assertWorkerCancellationMatchesCandidate(acknowledged, candidate);
+		return acknowledged;
+	}
+	const source = options.source ?? "human";
+	const request = pending ?? {
+		operationId: opId,
+		at: (/* @__PURE__ */ new Date()).toISOString(),
+		source,
+		worker: ref,
+		...options.reason === void 0 ? {} : { reason: options.reason }
+	};
+	if (!pending) {
+		const dir = workerCancellationsDir(eventDir);
+		assertNoSymlinkDescendant(eventDir, dir, "cancel request");
+		mkdirSync(dir, { recursive: true });
+		assertNoSymlinkDescendant(eventDir, dir, "cancel request");
+		const file = workerCancelRequestsFile(eventDir);
+		assertNoSymlinkDescendant(eventDir, file, "cancel request");
+		appendDurableFile(file, `${JSON.stringify(request)}\n`, { mode: 384 });
+		appendWorkerControlEvent(eventDir, ref, {
+			kind: "cancel-request",
+			operationId: opId,
+			source,
+			queued: true,
+			...options.reason === void 0 ? {} : { reason: options.reason }
+		});
+	}
+	return {
+		operationId: opId,
+		worker: request.worker,
+		effect: "unknown",
+		requestedAt: request.at,
+		observedAt: request.at,
+		...request.reason === void 0 ? {} : { reason: request.reason },
+		detail: "request queued; no runtime acknowledger has answered yet",
+		terminated: []
+	};
+}
+function assertSameWorkerCancelRequest(existing, candidate) {
+	if (existing.operationId !== candidate.operationId) throw new Error(`cancelWorker: operation '${candidate.operationId}' has an id collision`);
+	if (existing.worker !== candidate.worker) throw new Error(`cancelWorker: operation '${candidate.operationId}' conflicts with its admitted request (worker '${existing.worker}' != '${candidate.worker}')`);
+	if (existing.source !== candidate.source) throw new Error(`cancelWorker: operation '${candidate.operationId}' conflicts with its admitted request (source '${existing.source}' != '${candidate.source}')`);
+	if (existing.reason !== candidate.reason) throw new Error(`cancelWorker: operation '${candidate.operationId}' conflicts with its admitted request (reason differs)`);
+}
+function assertWorkerCancellationMatchesCandidate(existing, candidate) {
+	if (existing.worker !== candidate.worker) throw new Error(`cancelWorker: operation '${candidate.operationId}' conflicts with its acknowledgement (worker '${existing.worker}' != '${candidate.worker}')`);
+	if (existing.reason !== candidate.reason) throw new Error(`cancelWorker: operation '${candidate.operationId}' conflicts with its acknowledgement (reason differs)`);
+}
+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");
+}
+function appendWorkerControlEvent(eventDir, label, event) {
+	try {
+		fenceRunWrite(() => {
+			mkdirSync(supervisorWorkersDir(eventDir), { recursive: true });
+			appendFileSync(workerControlLogFile(eventDir, label), `${JSON.stringify({
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				label,
+				...event
+			})}\n`, "utf8");
+		});
+	} catch {}
+}
+function workerSteerRequestDigest(value) {
+	return canonicalCandidateDigest({
+		kind: "worker-steer-request.v1",
+		...value
+	});
+}
+function operationFileHash(operationId) {
+	const id = operationId.trim();
+	if (!id) throw new Error("steer operationId is empty");
+	return sha256(id);
+}
+function admitSteerRequest(file, request) {
+	const existing = readWorkerSteerRequestFile(file);
+	if (existing !== void 0) {
+		assertSameSteerRequest(existing, request);
+		return {
+			request: existing,
+			replayed: true
+		};
+	}
+	if (publishExclusiveDurableFile(file, `${JSON.stringify(request, null, 2)}\n`)) return {
+		request,
+		replayed: false
+	};
+	const winner = readWorkerSteerRequestFile(file);
+	if (winner === void 0) throw new Error("steer request publication lost its winner");
+	assertSameSteerRequest(winner, request);
+	return {
+		request: winner,
+		replayed: true
+	};
+}
+function readWorkerSteerRequest(eventDir, operationId) {
+	const file = workerSteerRequestFile(eventDir, operationId);
+	assertNoSymlinkDescendant(eventDir, file, "steer request");
+	const request = readWorkerSteerRequestFile(file);
+	if (request !== void 0 && request.operationId !== operationId) throw new Error("steer request file belongs to another operation");
+	return request;
+}
+function readWorkerSteerRequestFile(file) {
+	if (!existsSync(file)) return void 0;
+	return parseWorkerSteerRequest(JSON.parse(readFileSync(file, "utf8")));
+}
+function parseWorkerSteerRequest(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("steer request is malformed");
+	const request = value;
+	if (request.schemaVersion !== 1 || typeof request.operationId !== "string" || request.operationId.length === 0 || typeof request.requestDigest !== "string" || typeof request.at !== "string" || typeof request.source !== "string" || request.source.length === 0 || typeof request.worker !== "string" || request.worker.length === 0 || typeof request.message !== "string" || request.message.trim().length === 0 || typeof request.interrupt !== "boolean") throw new Error("steer request is malformed");
+	const exact = request;
+	const expected = workerSteerRequestDigest({
+		operationId: exact.operationId,
+		worker: exact.worker,
+		message: exact.message,
+		source: exact.source,
+		interrupt: exact.interrupt
+	});
+	if (exact.requestDigest !== expected) throw new Error("steer request digest does not match");
+	return exact;
+}
+function parseWorkerSteerAcknowledgement(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("steer acknowledgement is malformed");
+	const record = value;
+	if (record.schemaVersion !== 1 || typeof record.operationId !== "string" || record.operationId.length === 0 || typeof record.requestDigest !== "string" || typeof record.worker !== "string" || record.worker.length === 0 || record.effect !== "unknown" && record.effect !== "delivered" && record.effect !== "not_live" && record.effect !== "unsupported" && record.effect !== "refused" || typeof record.requestedAt !== "string" || typeof record.observedAt !== "string" || typeof record.detail !== "string") throw new Error("steer acknowledgement is malformed");
+	return record;
+}
+function assertSameSteerRequest(existing, candidate) {
+	if (existing.operationId !== candidate.operationId) throw new Error("steer operation file collision");
+	if (existing.requestDigest !== candidate.requestDigest) throw new Error(`writeWorkerSteer: operation '${candidate.operationId}' conflicts with its admitted request`);
+}
+// src/runtime/supervise/root-stream.ts
+/**
+* The root manager's own provider stream, retained where Runtime owns it.
+*
+* Measured motive (agent-runtime#1233): a CHILD's full event stream — reasoning, text,
+* and tool parts, 28k to 76k reasoning characters per child — is retained in the blob its
+* `settled` record names as `outRef`. The ROOT's stream reached nobody: `driveHarnessFromBackend`
+* drained the root executor for accounting and discarded every `progress` event, and on a
+* `winner` run `result.outRef` is the SELECTED CHILD's artifact, not the root's. A root that died
+* at its join barrier (fourier-e, 63 children) left a 607-byte `failure.json` and nothing it
+* thought; the Lab's only transcript of a root was a post-hoc scrape of the harness's own
+* database.
+*
+* `<runDir>/root-stream.jsonl` is the record: one JSONL line per `ExecutorProgressEvent`, written
+* AS IT ARRIVES, so a root whose process is killed mid-turn keeps every line already written. The
+* file itself is the evidence; the receipt (`ref`, the content address of the file's bytes, and
+* `events`, its committed line count) is what `result.json` and `failure.json` carry. The winner's
+* `outRef` keeps its meaning; this is a separate reference.
+*
+* Durability boundary: each line is written synchronously to an `O_APPEND` descriptor before the
+* next event is drained, and the file is fsynced at every drive-attempt boundary and at close, not
+* per line. An fsync per line cost 7.1 ms per event over
+* 1,000 events and 8.1 ms over 5,000 (~80 s for a root emitting ten thousand text deltas, all of
+* it serialized inside the drain loop that also meters the budget); an async `FileHandle.write`
+* still cost 0.9 to 1.1 ms per line in the thread pool the children's journal writes share; a
+* `writeSync` costs 6 µs. A process kill loses nothing written; only a kernel crash or power
+* loss can drop lines written since the last fsync, and the reader's torn-tail rule keeps such a
+* file readable.
+*
+* The bridge wire carries text and tool calls only: cli-bridge's SSE frames decode
+* `delta.content` and `delta.tool_calls`, never a reasoning delta. A bridge-placed root's retained
+* stream is therefore text plus tool calls; reasoning arrives only on the provider/sandbox path,
+* which projects `message.part.updated` reasoning parts to `reasoning_delta`.
+*/
+/** The root stream: one JSONL line per progress event the root's executor observed. */
+const ROOT_STREAM_FILE = "root-stream.jsonl";
+/** Each other node's stream, in the same record shape, keyed by its node id. A name the filename
+*  rules changed carries a digest of the id, so `a:b` and `a_b` never share a file. */
+function nodeStreamFile(nodeId) {
+	const safe = safeWorkerFile(nodeId);
+	return `streams/${safe === nodeId ? safe : `${safe}.${createHash("sha256").update(nodeId).digest("hex").slice(0, 12)}`}.jsonl`;
+}
+/** Create the writer for `<runDir>/root-stream.jsonl`, or for another `file` in the run directory.
+*  Nothing touches disk until the first `beginAttempt`, so a run whose root never drives leaves no
+*  file and no receipt. The root numbers attempts per process; a node stream, whose writer closes
+*  after every execution attempt, sets `continueAttempts` so a later attempt never reuses a number. */
+function createRootStreamSink(runDir, now, file = ROOT_STREAM_FILE, options = {}) {
+	const withClaim = captureRunWriteContext();
+	const dir = resolve(runDir);
+	const path = resolve(dir, file);
+	let fd;
+	let attempt = 0;
+	let seq = 0;
+	let closed = false;
+	const openOnce = async () => {
+		if (fd !== void 0) return;
+		await mkdir(dirname(path), { recursive: true });
+		assertNoSymlinkDescendant(dir, path, "root stream");
+		const needsSeparator = await prepareJsonlAppend(path);
+		seq = 0;
+		let priorAttempts = 0;
+		for await (const record of readCommittedJsonLines(path, { allowMissing: true })) {
+			seq += 1;
+			priorAttempts = Math.max(priorAttempts, record.attempt);
+		}
+		if (options.continueAttempts === true) attempt += priorAttempts;
+		fd = fenceRunWrite(() => {
+			const writer = openSync(path, constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | (typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0), 384);
+			try {
+				if (needsSeparator) writeLine(writer, "");
+				return writer;
+			} catch (error) {
+				closeSync(writer);
+				throw error;
+			}
+		});
+	};
+	return {
+		async beginAttempt() {
+			return withClaim(async () => {
+				if (closed) throw new Error("root stream: beginAttempt after close");
+				attempt += 1;
+				const writer = fd;
+				if (writer !== void 0) fenceRunWrite(() => fsyncSync(writer));
+				await openOnce();
+			});
+		},
+		append(event) {
+			return withClaim(() => fenceRunWrite(() => {
+				if (closed) throw new Error("root stream: append after close");
+				if (fd === void 0) throw new Error("root stream: append before beginAttempt");
+				const at = new Date(now()).toISOString();
+				const record = {
+					seq: seq + 1,
+					at,
+					attempt,
+					event
+				};
+				let line;
+				try {
+					line = JSON.stringify(record);
+				} catch (error) {
+					line = JSON.stringify({
+						seq: seq + 1,
+						at,
+						attempt,
+						dropped: {
+							kind: event.kind,
+							reason: errorMessage(error)
+						}
+					});
+				}
+				if (line === void 0) line = JSON.stringify({
+					seq: seq + 1,
+					at,
+					attempt,
+					dropped: {
+						kind: event.kind,
+						reason: "event serialized to nothing"
+					}
+				});
+				writeLine(fd, line);
+				seq += 1;
+			}));
+		},
+		async close() {
+			return withClaim(async () => {
+				if (closed) throw new Error("root stream: closed twice");
+				closed = true;
+				const writer = fd;
+				if (writer === void 0) return void 0;
+				try {
+					fenceRunWrite(() => fsyncSync(writer));
+				} finally {
+					closeSync(writer);
+					fd = void 0;
+				}
+				return readRootStreamReceipt(dir, file);
+			});
+		}
+	};
+}
+/** `writeSync` may legally make a short write; loop until the whole line and its newline land. */
+function writeLine(fd, line) {
+	const bytes = Buffer.from(`${line}\n`, "utf8");
+	let offset = 0;
+	while (offset < bytes.byteLength) {
+		const written = writeSync(fd, bytes, offset, bytes.byteLength - offset);
+		if (written <= 0) throw new Error(`root stream: append made no progress at byte ${offset}`);
+		offset += written;
+	}
+}
+/**
+* The receipt for the root stream a run directory holds, recomputed from the file's bytes, or
+* `undefined` when the directory holds none. This is what a run that never settled — a root that
+* died mid-turn — gets on its failure record, and it equals what `close()` returned for a run
+* that did.
+*/
+async function readRootStreamReceipt(runDir, file = ROOT_STREAM_FILE) {
+	const path = resolve(runDir, file);
+	const hash = createHash("sha256");
+	let events = 0;
+	try {
+		for await (const _record of readCommittedJsonLines(path, { onBytes: (bytes) => {
+			hash.update(bytes);
+		} })) events += 1;
+	} catch (error) {
+		if (isNoEntError(error)) return void 0;
+		throw error;
+	}
+	return Object.freeze({
+		ref: `sha256:${hash.digest("hex")}`,
+		events
+	});
+}
+/** Every committed line of the root stream, in order, or `undefined` when there is no file. A
+*  torn final line from a process that died mid-write is not a record and is left out. */
+async function readRootStream(runDir) {
+	const path = resolve(runDir, ROOT_STREAM_FILE);
+	const records = [];
+	try {
+		for await (const record of readCommittedJsonLines(path)) records.push(record);
+	} catch (error) {
+		if (isNoEntError(error)) return void 0;
+		throw error;
+	}
+	return records;
+}
+export { workspaceCaptureWriter as $, closesCursorSlot as A, sandboxLeafOutputFromEvents as At, runtimeFailureRemediationSchema as B, createSandboxUsageLedger as Bt, writeWorkerSteerAcknowledgement as C, spendFromUsageEvents as Ct, FileResultBlobStore as D, createSandboxToolPartState as Dt, spawnJournalRecordEvents as E, assertValidSpend as Et, observerRecordDigest as F, extractTransportEventIdentity as Ft, RetainedExecutionPendingError as G, sandboxTerminalUsageField as Gt, settlementFailureCause as H, isSandboxTerminalEvent as Ht, verifyObserverRecords as I, parseCanonicalTransportEvent as It, leafContinuationExecutionId as J, parseCodexUsageRecord as Jt, executorEvidenceWriter as K, sumSandboxUsage as Kt, reportedFailureCause as L, assertSandboxServedModel as Lt, outsideCursorNamespace as M, sandboxProgressEvents as Mt, FileObserverJournal as N, terminalTextFromSandboxEvent as Nt, encodeResultBlob as O, mapSandboxEvent as Ot, createFileObserverHooks as P, canonicalStreamEventFromSandboxEvent as Pt, retainedExecutorSeamKey as Q, runtimeFailureCause as R, canonicalSandboxUsageMode as Rt, writeWorkerSteer as S, newUsageTotals as St, appendSpawnEvents as T, assertValidBudget as Tt, BUDGET_CONTINUATION_TASK as U, notifySandboxEventObserver as Ut, runtimeProviderCode as V, extractLlmCallEvent as Vt, DISPATCH_NOT_ADMITTED_CODE as W, sandboxEventServedBackend as Wt, registerRetainedExecutorPreparation as X, prepareRetainedExecutor as Y, recordValue as Yt, retainedExecutorContext as Z, supervisorRunsRoot as _, credentialCommandExit as _t, readRootStreamReceipt as a, unavailableResumeAt as at, workerInboxFileFromEventDir as b, createBudgetPool as bt, claimWorkerSteerDelivery as c, TRACE_ROOT_SCHEMA as ct, readWorkerCancelRequests as d, contentAddress as dt, UNAVAILABLE_CODES as et, readWorkerCancellation as f, contentRef as ft, supervisorRunDir as g, hashJson as gt, safeWorkerFile as h, executorFailureReason as ht, readRootStream as i, unavailablePauseMs as it, insideCursorNamespace as j, sandboxOutputMarker as jt, SpawnEventIndex as k, mapSandboxToolEvent as kt, legacySupervisorRunDir as l, TRACE_SUMMARY_SCHEMA as lt, readWorkerSteerRequests as m, executorFailureInfra as mt, createRootStreamSink as n, cappedDoublingMs as nt, appendWorkerControlEvent as o, unavailableSignalInText as ot, readWorkerSteerAcknowledgement as p, executorFailure as pt, isProvisioningRefusal as q, decodeHarnessUsage as qt, nodeStreamFile as r, jitteredMs as rt, cancelWorker as s, unavailableSignalOfFailure as st, ROOT_STREAM_FILE as t, UNAVAILABLE_STATUSES as tt, legacySupervisorRunsRoot as u, traceRootWriter as ut, supervisorWorkersDir as v, isCredentialRefusal as vt, FileSpawnJournal as w, spendFromUsageTotals as wt, writeWorkerCancellation as x, meterUsageEvent as xt, workerCancellationsDir as y, BudgetReconcileFault as yt, runtimeFailureCauseSchema as z, createSandboxTurnEventCollector as zt };
 
-//# sourceMappingURL=journal-store-E6TojmWB.js.map
+//# sourceMappingURL=root-stream-To4qAc0e.js.map