@tangle-network/agent-runtime 0.225.5 → 0.226.0

package/dist/{supervise-qYms7HSb.js → supervise-CtXJ-lWb.js}

@@ -1,13 +1,16 @@
-import { $n as generateSpanId, $r as runtimeOwnedExecutorProviderEvidence, Ai as sleep, At as WORKER_TRACE_PROPAGATION, C as scopeOwnerExecutorNodeContext, Cr as defineProfileMaterializationContract, Dn as registerRetainedExecutorPreparation, Dr as promptModelProfileMaterialization, Dt as newUsageTotals, Er as promptControlProfileMaterialization, Et as meterUsageEvent, F as scopeRetainedOwnerResult, Fi as withTimeout, Fr as worktreeCliProfileMaterialization, Gi as teardownExecutor, Ii as zeroSpend, Jr as providerAttemptEvidence, Li as addResourceSpend, M as prepareScopeRetainedOwnerTask, Mn as runAbortable, N as scopeRetainedOwnerContext, Nr as unsupportedProfileDimensions, On as retainedExecutorSeamKey, P as scopeRetainedOwnerPriorSpend, Pi as unmeteredSpend, Q as captureReusableExecutorConfig, Qr as runtimeOwnedExecutorMaterialization, Ri as resourceTelemetry, S as restoreScopeOwnerAcceptedExecution, Si as addSpend, Sn as resolveAgentEnvironmentProvider, Sr as controlProfileMaterialization, St as contentAddress, Tr as profileMaterializationAxes$1, Ui as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, Vr as attestRuntimeOwnedScopeOwner, Wr as inheritRuntimeOwnedExecutorAttestation, Xn as createOtelExporter, Xr as runtimeOwnedDriveHarnessProviderEvidence, Xt as bridgeAdmissionRefusal, Yr as recordRuntimeOwnedDriveHarnessProviderEvidence, Z as bindReusableExecutorExecutionId, Zr as runtimeOwnedExecutorExecutionBinding, Zt as bridgeModelRouteRefusal, b as meterRuntimeOwnedProviderAttempt, d as runDriverWithRetry, ei as runtimeOwnedPendingExecutorMaterialization, f as driverChild, g as beginScopeOwnerAttempt, j as consumeScopeRetainedOwnerResult, jr as renderUnsupported, kn as RunCancellationReason, kt as spendFromUsageTotals, m as isDriverSpec, mn as routerBrain, n as createSupervisor, nn as bridgeRuntimeAttachmentsKey, o as runFinalizer, p as driverExecutorFactory, r as bestDelivered, rn as bridgeStopSignalKey, rr as toOtelAttributes, rt as snapshotExecutorConfig, s as runTree, si as detachedSnapshot, t as createRootHandle, ti as runtimeOwnedScopeOwnerRuntime, tt as createExecutor, u as defaultUnmetContractSteer, v as deriveNodeExecutionIdentity, wr as fullProfileMaterialization, wt as assertValidBudget, x as recordScopeOwnerMaterialization, xr as assertProfileMaterialization, y as meterRuntimeOwnedAccounting, zi as withBudgetResources, zt as createInbox } from "./supervisor-D1j1RRJy.js";
+import { $n as generateSpanId, $r as runtimeOwnedExecutorProviderEvidence, Ai as sleep, At as WORKER_TRACE_PROPAGATION, C as scopeOwnerExecutorNodeContext, Cr as defineProfileMaterializationContract, Dn as registerRetainedExecutorPreparation, Dr as promptModelProfileMaterialization, Dt as newUsageTotals, Er as promptControlProfileMaterialization, Et as meterUsageEvent, F as scopeRetainedOwnerResult, Fi as withTimeout, Fr as worktreeCliProfileMaterialization, Gi as teardownExecutor, Ii as zeroSpend, Ir as isNoEntError, Jr as providerAttemptEvidence, Li as addResourceSpend, Lr as parseCommittedJsonLines, M as prepareScopeRetainedOwnerTask, Mn as runAbortable, N as scopeRetainedOwnerContext, Nr as unsupportedProfileDimensions, On as retainedExecutorSeamKey, P as scopeRetainedOwnerPriorSpend, Pi as unmeteredSpend, Q as captureReusableExecutorConfig, Qr as runtimeOwnedExecutorMaterialization, Ri as resourceTelemetry, Rr as prepareJsonlAppend, S as restoreScopeOwnerAcceptedExecution, Si as addSpend, Sn as resolveAgentEnvironmentProvider, Sr as controlProfileMaterialization, St as contentAddress, Tr as profileMaterializationAxes$1, Ui as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, Vr as attestRuntimeOwnedScopeOwner, Wr as inheritRuntimeOwnedExecutorAttestation, Xn as createOtelExporter, Xr as runtimeOwnedDriveHarnessProviderEvidence, Xt as bridgeAdmissionRefusal, Yr as recordRuntimeOwnedDriveHarnessProviderEvidence, Z as bindReusableExecutorExecutionId, Zr as runtimeOwnedExecutorExecutionBinding, Zt as bridgeModelRouteRefusal, b as meterRuntimeOwnedProviderAttempt, d as runDriverWithRetry, ei as runtimeOwnedPendingExecutorMaterialization, f as driverChild, g as beginScopeOwnerAttempt, j as consumeScopeRetainedOwnerResult, jr as renderUnsupported, kn as RunCancellationReason, kt as spendFromUsageTotals, m as isDriverSpec, mn as routerBrain, n as createSupervisor, nn as bridgeRuntimeAttachmentsKey, o as runFinalizer, p as driverExecutorFactory, r as bestDelivered, rn as bridgeStopSignalKey, rr as toOtelAttributes, rt as snapshotExecutorConfig, s as runTree, si as detachedSnapshot, t as createRootHandle, ti as runtimeOwnedScopeOwnerRuntime, tt as createExecutor, u as defaultUnmetContractSteer, v as deriveNodeExecutionIdentity, wr as fullProfileMaterialization, wt as assertValidBudget, x as recordScopeOwnerMaterialization, xr as assertProfileMaterialization, y as meterRuntimeOwnedAccounting, zi as withBudgetResources, zt as createInbox } from "./supervisor-DCQxXRR8.js";
 import { i as ConfigError, m as ValidationError } from "./errors-DodWX-cb.js";
 import { a as concreteProfileModel, c as profileModelExecutionSettings, d as agentHarness, f as harnessRunsAgent, n as assertModelAllowed, o as enforceTokenLimits, r as assertProfileModelsAllowed, s as profileBridgeWireModel, t as assertExecutableAgentProfile } from "./model-policy-BbSCSak0.js";
 import { t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
+import { n as assertNoSymlinkDescendant } from "./durable-file-D24y9zg7.js";
 import { t as createStdioToolServer } from "./tool-server-BJbCPhoW.js";
-import { D as coordinationVerbNames, O as createCoordinationTools, S as watchRunCancellation, c as createProgressTracker, d as progressStop, r as driverAgent, v as createFileRunContext, w as DEFAULT_AWAIT_EVENT_TIMEOUT_MS, x as applyRunCancellation, y as createInMemoryRunContext } from "./coordination-driver-B5NtPTE1.js";
+import { D as coordinationVerbNames, O as createCoordinationTools, S as watchRunCancellation, c as createProgressTracker, d as progressStop, r as driverAgent, v as createFileRunContext, w as DEFAULT_AWAIT_EVENT_TIMEOUT_MS, x as applyRunCancellation, y as createInMemoryRunContext } from "./coordination-driver-DxHQLK8i.js";
 import { k as writeRunCancellation, o as readRunCancelRequest, s as readRunCancellation } from "./run-layout-hZREkcfu.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalCandidateJson, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { closeSync, constants, fsyncSync, openSync, writeSync } from "node:fs";
 import { resolve } from "node:path";
+import { mkdir, readFile } from "node:fs/promises";
 import { isMaterializerHarness } from "@tangle-network/agent-profile-materialize";
 import { createServer } from "node:http";
 //#region src/runtime/supervise/completion-gate.ts
@@ -1084,6 +1087,164 @@ function truncate(value) {
 	return value.length > MAX_DETAIL_CHARS ? `${value.slice(0, MAX_DETAIL_CHARS)}…` : value;
 }
 //#endregion
+//#region src/runtime/supervise/root-stream.ts
+/**
+* The root manager's own provider stream, retained where Runtime owns it.
+*
+* Measured motive (agent-runtime#1233, 2026-09-15): 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. Measured 2026-09-15 on this host's APFS: 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";
+/** Create the writer for `<runDir>/root-stream.jsonl`. Nothing touches disk until the first
+*  `beginAttempt`, so a run whose root never drives leaves no file and no receipt. */
+function createRootStreamSink(runDir, now) {
+	const dir = resolve(runDir);
+	const path = resolve(dir, ROOT_STREAM_FILE);
+	let fd;
+	let attempt = 0;
+	let seq = 0;
+	let closed = false;
+	const openOnce = async () => {
+		if (fd !== void 0) return;
+		await mkdir(dir, { recursive: true });
+		assertNoSymlinkDescendant(dir, path, "root stream");
+		const needsSeparator = await prepareJsonlAppend(path);
+		seq = (await readRootStream(dir) ?? []).length;
+		fd = openSync(path, constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | (typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0), 384);
+		if (needsSeparator) writeLine(fd, "");
+	};
+	return {
+		async beginAttempt() {
+			if (closed) throw new Error("root stream: beginAttempt after close");
+			attempt += 1;
+			if (fd !== void 0) fsyncSync(fd);
+			await openOnce();
+		},
+		append(event) {
+			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() {
+			if (closed) throw new Error("root stream: closed twice");
+			closed = true;
+			if (fd === void 0) return void 0;
+			try {
+				fsyncSync(fd);
+			} finally {
+				closeSync(fd);
+				fd = void 0;
+			}
+			return readRootStreamReceipt(dir);
+		}
+	};
+}
+/** `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) {
+	const path = resolve(runDir, ROOT_STREAM_FILE);
+	let bytes;
+	try {
+		bytes = await readFile(path);
+	} catch (error) {
+		if (isNoEntError(error)) return void 0;
+		throw error;
+	}
+	return Object.freeze({
+		ref: `sha256:${createHash("sha256").update(bytes).digest("hex")}`,
+		events: parseCommittedJsonLines(bytes.toString("utf8"), path).length
+	});
+}
+/** 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);
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch (error) {
+		if (isNoEntError(error)) return void 0;
+		throw error;
+	}
+	return parseCommittedJsonLines(text, path);
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
 //#region src/runtime/supervise/supervisor-agent.ts
 /**
 * `supervisorAgent` — build a supervisor `Agent` FROM its profile. The brain is resolved from
@@ -2195,7 +2356,7 @@ async function providerAcceptsCoordinationAttachments(backend) {
 /** Run a harness-brained manager through the same executor factory as its children. The manager's
 * full profile is preserved, the live coordination server is added under one reserved alias, and
 * every streamed turn is charged to the manager's scope before it may continue. */
-function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns) {
+function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns, rootStream) {
 	if (maxTurns !== void 0 && maxTurns < 0) throw new ValidationError("driveHarnessFromBackend: maxTurns must be >= 0 (0 lifts the turn cap; bounds become the conserved pool + deadline + abort)");
 	const turnCap = maxTurns ?? 0;
 	const boundBackend = bindReusableExecutorExecutionId(captureReusableExecutorConfig(backend, "driveHarnessFromBackend"), executionId);
@@ -2426,6 +2587,7 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns)
 			if (executor.budgetExempt) throw new ValidationError(`driveHarnessFromBackend: runtime ${JSON.stringify(executor.runtime)} does not report usage and cannot drive a budgeted supervisor`);
 			started = true;
 			if (retainedOwner?.admissions.length && !executor.recover) throw new ValidationError("retained owner executor does not support recovery");
+			await rootStream?.beginAttempt();
 			const run = retainedOwner?.admissions.length ? executor.recover(originalTask, scope.signal) : executor.execute(originalTask, scope.signal);
 			if (isAsyncIterable(run)) {
 				let turns = 0;
@@ -2433,7 +2595,8 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns)
 					await meterPending();
 					turns += 1;
 					if (turnStop !== void 0 && turns >= turnCap && !turnStop.signal.aborted) turnStop.abort(`supervise: maxTurns ${turnCap} reached`);
-				} else if (event.kind !== "progress") pendingUsage.push(event);
+				} else if (event.kind === "progress") rootStream?.append(event.progress);
+				else pendingUsage.push(event);
 				await meterPending();
 				const artifact = executor.resultArtifact();
 				const terminalResources = withBudgetResources({
@@ -3009,6 +3172,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 	const log = ctx.coordinationLog;
 	const rootOwnerId = rootCoordinationOwner(rootExecution.identity);
 	const rootProviderModels = [];
+	const rootStreamSink = options.runDir === void 0 ? void 0 : createRootStreamSink(resolve(options.runDir), options.now ?? Date.now);
 	const observeNodeEvent = options.onCoordinationEvent ? async (context, event, record) => {
 		await options.onCoordinationEvent?.(context, coordinationEventId(context, event), record);
 	} : void 0;
@@ -3044,7 +3208,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 		return managerBackend && automaticDriverBackendSupported(managerBackend, options.coordination) ? driveHarnessFromBackend(managerBackend, externalExecutionId("supervised-manager", {
 			runNamespace,
 			ownerId: context.ownerId
-		}), options.now ?? Date.now, options.maxTurns) : void 0;
+		}), options.now ?? Date.now, options.maxTurns, context.depth === 0 ? rootStreamSink : void 0) : void 0;
 	};
 	const rootDriveHarness = isExternalSupervisor(canonicalProfile) ? driveHarnessForOwner(freezeDetached({
 		runId,
@@ -3329,17 +3493,23 @@ function superviseInternal(profile, task, opts, testBrain) {
 		});
 		const settle = async () => {
 			let result;
+			let rootStream;
 			try {
 				result = await run;
 			} finally {
-				cancellation?.close();
-				cancellation?.check();
+				try {
+					rootStream = await rootStreamSink?.close();
+				} finally {
+					cancellation?.close();
+					cancellation?.check();
+				}
 			}
 			recordRunCancellationOutcome(options.runDir, result, now);
 			const rootProviderModel = ctx.resume === true ? rootProviderModelEvidence([]) : rootProviderModels.length > 0 ? rootProviderModelEvidence(rootProviderModels) : rootDriveHarness === void 0 ? rootProviderModelEvidence([]) : rootProviderModelEvidenceFromExecution(runtimeOwnedDriveHarnessProviderEvidence(rootDriveHarness));
 			return {
 				...result,
-				rootProviderModel
+				rootProviderModel,
+				...rootStream === void 0 ? {} : { rootStream }
 			};
 		};
 		if (!recorder) return settle();
@@ -3386,6 +3556,6 @@ function rootProviderModelEvidenceFromExecution(evidence) {
 	return evidence ?? rootProviderModelEvidence([]);
 }
 //#endregion
-export { mapExecutorResult as _, isPreSpawnExecutorFailure as a, withWorkerSpawnRetry as c, resolveSupervisorProfile as d, supervisorAgent as f, gateOnDeliverable as g, serveCoordinationMcp as h, workerFromBackend as i, assertCoordinationBinding as l, createSupervisorSpanRecorder as m, supervise as n, resolveWorkerSpawnRetry as o, supervisorAgentWithTestBrain as p, superviseWithTestBrain as r, retryPreSpawnRefusals as s, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, coordinationProfileToolPrefix as u };
+export { createSupervisorSpanRecorder as _, isPreSpawnExecutorFailure as a, mapExecutorResult as b, withWorkerSpawnRetry as c, resolveSupervisorProfile as d, supervisorAgent as f, readRootStreamReceipt as g, readRootStream as h, workerFromBackend as i, assertCoordinationBinding as l, ROOT_STREAM_FILE as m, supervise as n, resolveWorkerSpawnRetry as o, supervisorAgentWithTestBrain as p, superviseWithTestBrain as r, retryPreSpawnRefusals as s, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, coordinationProfileToolPrefix as u, serveCoordinationMcp as v, gateOnDeliverable as y };
 
-//# sourceMappingURL=supervise-qYms7HSb.js.map
+//# sourceMappingURL=supervise-CtXJ-lWb.js.map