@tangle-network/agent-runtime 0.293.4 → 0.295.0

package/dist/testing.d.ts

@@ -1,5 +1,5 @@
-import { Ac as SuperviseTestOptions, Mc as superviseWithTestBrain, Tn as driverAgent, Zt as RunGraphTestOptions, tn as runGraphWithTestBrain, ul as SupervisorAgentTestDeps, wn as DriverAgentOptions, yl as supervisorAgentWithTestBrain } from "./index-DZqkIP6a.js";
-import { Gn as ToolLoopChat, Wn as ToolLoopCallContext } from "./stream-agent-turn-DsHYpI9p.js";
+import { Ic as SuperviseTestOptions, Rc as superviseWithTestBrain, Tl as supervisorAgentWithTestBrain, Tn as driverAgent, Zt as RunGraphTestOptions, gl as SupervisorAgentTestDeps, tn as runGraphWithTestBrain, wn as DriverAgentOptions } from "./index-nREMiWJP.js";
+import { Gn as ToolLoopChat, Wn as ToolLoopCallContext } from "./stream-agent-turn-CwqktoXW.js";
 import { AgentImprovementProposal, AgentProfile, AgentProfileImprovementMeasuredComparison, SandboxSizePreset } from "@tangle-network/agent-interface";
 //#region src/testing/index.d.ts
 /** A proposal produced by Runtime's opaque profile-improvement path. */

package/dist/testing.js

@@ -1,14 +1,14 @@
-import { O as immutableCandidateValue, w as canonicalCandidateDigest$1 } from "./workspace-archive-MhowMCmp.js";
-import { f as verifyAgentImprovementProposal } from "./improvement-cycle-CBAuTq3p.js";
-import { i as applyExactAgentProfileDiff, p as parseExactAgentProfile } from "./profile-C4NDjZyB.js";
-import { r as driverAgent } from "./coordination-driver-BpEJv7GR.js";
-import { a as superviseWithTestBrain, h as supervisorAgentWithTestBrain } from "./supervise-Cu0yOTkc.js";
-import { i as runGraphWithTestBrain } from "./graph-oFWfYVpn.js";
+import { D as canonicalCandidateDigest$1, j as immutableCandidateValue } from "./workspace-streams-D4TMTrJV.js";
+import { f as verifyAgentImprovementProposal } from "./improvement-cycle-D4hoGlAe.js";
+import { i as applyExactAgentProfileDiff, p as parseExactAgentProfile } from "./profile-BubsrYhR.js";
+import { r as driverAgent } from "./coordination-driver-Do3g6Qif.js";
+import { a as superviseWithTestBrain, h as supervisorAgentWithTestBrain } from "./supervise-BwfqpTVR.js";
+import { i as runGraphWithTestBrain } from "./graph-dNmpMnzl.js";
 import { SANDBOX_SIZE_PRESET_NAMES, canonicalAgentProfileDigest } from "@tangle-network/agent-interface";
 //#region src/testing/fixtures/agent-improvement-proposal.json
 var agent_improvement_proposal_default = {
 	changedSurfaces: ["prompt"],
-	digest: "sha256:b884ed0fd4efeca2dc60325b4f422c9eccd30e444447d05dd35007e016d9e445",
+	digest: "sha256:92ae4f0346f8bcf97d235489d683bdb8580acc51292cd42825038bddb74cd15b",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -4579,7 +4579,7 @@ var agent_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-improvement-proposal",
-			"runtimeVersion": "0.293.4"
+			"runtimeVersion": "0.295.0"
 		},
 		"objectives": [
 			{
@@ -4690,8 +4690,8 @@ var agent_improvement_proposal_default = {
 			"baselineContentHash": "sha256:5c21ee53e513fc604cb09754e21c392b24a424da0ef37dbf8f1ee4a8a0b08f09",
 			"candidateContentHash": "sha256:60fcbb1c728194bd51d7d19cb732d1c3f1881dce7e0a6266b41c8b98cfd65693",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:a54f7d32bcd984e2aad2765608ada91db000c4502f04dac1a01f2a2a919ba876",
-			"runId": "agent-runtime-0.293.4-proposal-fixture",
+			"recordDigest": "sha256:910d1c0d45c3a710f6fd5e74e37f136b7e7f80134c1d60a802b632a32fb83ace",
+			"runId": "agent-runtime-0.295.0-proposal-fixture",
 			"schema": "agent-candidate-experiment"
 		}
 	},
@@ -4714,13 +4714,13 @@ var agent_improvement_proposal_default = {
 	}],
 	kind: "agent-improvement-proposal",
 	proposedAt: "2026-07-10T01:00:00.000Z",
-	runId: "agent-runtime-0.293.4-proposal-fixture"
+	runId: "agent-runtime-0.295.0-proposal-fixture"
 };
 //#endregion
 //#region src/testing/fixtures/agent-profile-improvement-proposal.json
 var agent_profile_improvement_proposal_default = {
 	changedSurfaces: ["prompt", "skills"],
-	digest: "sha256:f27225c1967d28b52dcbb6695fa0e951ebc8f78a467c4244d5be5d47917a3c0c",
+	digest: "sha256:d515abd0654e1c9bddad5f78adc5ebffdd67665d1877bb758a90ec45fb87b273",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -6354,7 +6354,7 @@ var agent_profile_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-profile-improvement-proposal",
-			"runtimeVersion": "0.293.4"
+			"runtimeVersion": "0.295.0"
 		},
 		"objectives": [
 			{
@@ -6465,7 +6465,7 @@ var agent_profile_improvement_proposal_default = {
 			"baselineContentHash": "sha256:21c495a37c418c10bde64fbaa188beddeed31f1f051ea60a6a6582a9ee0db704",
 			"candidateContentHash": "sha256:103f77bc8481601eef1ad5fe6ba84a40dffabc3a44f421f8c8559121edab84e9",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:00c90f15ae9007a286726ca7844f1bbff8f102ee754c05f23ed571f6b37bae37",
+			"recordDigest": "sha256:3ea42b79172f7a43340e78b622151271db8d8ead2ae5ada9f720340d20c56a32",
 			"runId": "profile-improvement-1",
 			"schema": "agent-profile-improvement-experiment"
 		}

package/dist/tui/index.d.ts

@@ -1,4 +1,4 @@
-import { Ct as ProvisionSupervisorConnection, Dt as provisionSupervisor, Et as SupervisorCleanupReceipt, Tt as ProvisionedSupervisor, wt as ProvisionSupervisorRequest } from "../index-DZqkIP6a.js";
+import { Ct as ProvisionSupervisorConnection, Dt as provisionSupervisor, Et as SupervisorCleanupReceipt, Tt as ProvisionedSupervisor, wt as ProvisionSupervisorRequest } from "../index-nREMiWJP.js";
 //#region src/tui/top-app.d.ts
 /**
  * The interactive side of the supervisor-run TUI: a keypress/mouse loop over the frames

package/dist/tui/index.js

@@ -1,3 +1,3 @@
-import { t as provisionSupervisor } from "../provision-supervisor-CIwZLCGR.js";
+import { t as provisionSupervisor } from "../provision-supervisor-B_3hmSz6.js";
 import { a as renderTopFrameWithLayout, i as renderTopFrame, n as runTopApp, r as loadTopSnapshot, t as renderTopOnce } from "../top-app-DaiR4LXM.js";
 export { loadTopSnapshot, provisionSupervisor, renderTopFrame, renderTopFrameWithLayout, renderTopOnce, runTopApp };

package/dist/{workspace-archive-DpyZV2Cj.d.ts → workspace-archive-pz8YJ1fr.d.ts}

@@ -16,10 +16,21 @@ declare const verifiedTaskOutcomeBrand: unique symbol;
 /** Reads one content-addressed object from the closed S3/IPFS locator set. */
 interface AgentCandidateArtifactPort {
   read(ref: AgentCandidateArtifactRef): Promise<Uint8Array>;
+  /** Stream an artifact without materializing its complete contents. */
+  readStream?(ref: AgentCandidateArtifactRef, options?: {
+    signal?: AbortSignal;
+  }): AsyncIterable<Uint8Array>;
 }
 type AgentCandidateOutputPurpose = 'execution-plan' | 'materialization-receipt' | 'candidate-workspace-manifest' | 'candidate-workspace-archive' | 'task-manifest' | 'task-archive' | 'task-patch' | 'task-output' | 'task-outcome' | 'memory-after-manifest' | 'memory-after-archive' | 'grader-evidence' | 'benchmark-result' | 'model-settlement' | 'trace' | 'executor-native-evidence' | 'executor-capture' | 'run-receipt' | 'knowledge-retrieval-config' | 'knowledge-evaluation' | 'failure-evidence';
 /** Durable content-addressed evidence store controlled only by the evaluator. */
 interface AgentCandidateOutputArtifactPort extends AgentCandidateArtifactPort {
+  /** Consume all chunks before publishing; preserve put's identity and cancellation guarantees. */
+  putStream?(input: {
+    executionId: string;
+    purpose: AgentCandidateOutputPurpose;
+    chunks: AsyncIterable<Uint8Array>;
+    signal?: AbortSignal;
+  }): Promise<AgentCandidateArtifactRef>;
   /** Must be idempotent for identical bytes and return only a durable S3/IPFS locator. */
   put(input: {
     executionId: string;
@@ -540,4 +551,4 @@ declare function captureAgentCandidateWorkspaceFiles(input: readonly AgentCandid
 declare function createAgentCandidateWorkspacePort(options?: CreateAgentCandidateWorkspacePortOptions): AgentCandidateWorkspacePort;
 //#endregion
 export { AgentCandidateProtectedModelSettlement as A, CanonicalCandidateDocument as B, AgentCandidateMemoryResetResult as C, AgentCandidateOutputPurpose as D, AgentCandidateOutputArtifactPort as E, AgentCandidateTaskExecution as F, PreparedAgentCandidateLaunch as G, PreparedAgentCandidateExecution as H, AgentCandidateVerificationPorts as I, VerifiedAgentCandidate as J, PreparedAgentCandidateTrace as K, AgentCandidateWorkspacePort as L, AgentCandidateProtectedRunCapture as M, AgentCandidateRepositoryPort as N, AgentCandidateProtectedModelActivation as O, AgentCandidateRunFinalization as P, CANDIDATE_TRACE_ENV as R, AgentCandidateMemoryPort as S, AgentCandidateModelPort as T, PreparedAgentCandidateInstruction as U, PersistedTaskOutcomeEvidence as V, PreparedAgentCandidateKnowledge as W, AgentCandidateExecutionRoots as X, VerifiedAgentCandidateTaskOutcome as Y, AgentCandidateExecutorRequest as _, captureAgentCandidateWorkspace as a, AgentCandidateExecutorWorkspaceFile as b, AgentCandidateArtifactPort as c, AgentCandidateContainerPort as d, AgentCandidateExecutionPorts as f, AgentCandidateExecutorProfileFile as g, AgentCandidateExecutorPort as h, CreateAgentCandidateWorkspacePortOptions as i, AgentCandidateProtectedModelSettlementCall as j, AgentCandidateProtectedModelReservation as k, AgentCandidateBenchmarkGraderIdentity as l, AgentCandidateExecutorMemoryCapture as m, CaptureAgentCandidateWorkspaceOptions as n, captureAgentCandidateWorkspaceFiles as o, AgentCandidateExecutorFinalCapture as p, ResolvedAgentCandidateContainer as q, CapturedAgentCandidateWorkspace as r, createAgentCandidateWorkspacePort as s, AgentCandidateWorkspaceArchiveLimits as t, AgentCandidateBenchmarkGraderPort as u, AgentCandidateExecutorStopRequest as v, AgentCandidateModelLimits as w, AgentCandidateExecutorWorkspaceInput as x, AgentCandidateExecutorTaskOutcomeCapture as y, CANDIDATE_TRACE_TAGS as z };
-//# sourceMappingURL=workspace-archive-DpyZV2Cj.d.ts.map
+//# sourceMappingURL=workspace-archive-pz8YJ1fr.d.ts.map

package/dist/{workspace-archive-MhowMCmp.js → workspace-streams-D4TMTrJV.js}

@@ -7,6 +7,8 @@ import { lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, ren
 import { tmpdir } from "node:os";
 import { isAnyArrayBuffer, isSharedArrayBuffer } from "node:util/types";
 import { extract, pack } from "tar-stream";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 //#region src/candidate-execution/digest.ts
 /** Use native hashing for workspace archives. */
 function sha256Bytes$1(bytes) {
@@ -193,9 +195,11 @@ async function walkWorkspace(root, options, keepBytes) {
 	const scanned = [];
 	let totalBytes = 0;
 	async function visit(directory) {
+		options.signal?.throwIfAborted();
 		const entries = await readdir(directory, { withFileTypes: true });
 		entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
 		for (const entry of entries) {
+			options.signal?.throwIfAborted();
 			if (directory === absoluteRoot && ignoredProtectedRootEntries.has(entry.name)) continue;
 			const absolute = resolve(directory, entry.name);
 			const relPath = relative(absoluteRoot, absolute).split(sep).join("/");
@@ -217,7 +221,7 @@ async function walkWorkspace(root, options, keepBytes) {
 				if (limits && openedStats.size > limits.maxFileBytes) throw new WorkspaceScanLimitError(`workspace file exceeds maxFileBytes: ${relPath}`);
 				const remainingBytes = limits ? limits.maxTotalFileBytes - totalBytes : void 0;
 				if (remainingBytes !== void 0 && openedStats.size > remainingBytes) throw new WorkspaceScanLimitError("workspace exceeds maxTotalFileBytes");
-				const read = await readWorkspaceFile(descriptor, limits ? Math.min(limits.maxFileBytes, remainingBytes ?? limits.maxFileBytes) : void 0, keepBytes, relPath);
+				const read = await readWorkspaceFile(descriptor, limits ? Math.min(limits.maxFileBytes, remainingBytes ?? limits.maxFileBytes) : void 0, keepBytes, relPath, options.signal);
 				totalBytes += read.byteLength;
 				scanned.push({
 					path: relPath,
@@ -268,12 +272,13 @@ function isWithin(root, path) {
 * chunks in order equals hashing the whole buffer, so a manifest a buffered read produced is
 * reproduced byte for byte.
 */
-async function readWorkspaceFile(descriptor, maxBytes, keepBytes, path) {
+async function readWorkspaceFile(descriptor, maxBytes, keepBytes, path, signal) {
 	const hash = createHash("sha256");
 	const buffer = Buffer.allocUnsafe(1024 * 1024);
 	const chunks = [];
 	let total = 0;
 	while (true) {
+		signal?.throwIfAborted();
 		const { bytesRead } = await descriptor.read(buffer, 0, buffer.byteLength, null);
 		if (bytesRead === 0) break;
 		total += bytesRead;
@@ -951,17 +956,7 @@ function repositoryFromTar(metadata, bundle) {
 }
 async function writeTarEntry(archive, name, mode, bytes) {
 	await new Promise((resolveEntry, rejectEntry) => {
-		archive.entry({
-			name,
-			mode,
-			uid: 0,
-			gid: 0,
-			size: bytes.byteLength,
-			mtime: fixedTarTime,
-			type: "file",
-			uname: "",
-			gname: ""
-		}, Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength), (error) => error ? rejectEntry(error) : resolveEntry());
+		archive.entry(workspaceTarHeader(name, mode, bytes.byteLength), Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength), (error) => error ? rejectEntry(error) : resolveEntry());
 	});
 }
 async function readTarEntry(entry, maxBytes, label) {
@@ -1205,7 +1200,298 @@ function requireTypedArrayGetter(name) {
 const typedArrayBufferGetter = requireTypedArrayGetter("buffer");
 const typedArrayByteOffsetGetter = requireTypedArrayGetter("byteOffset");
 const typedArrayByteLengthGetter = requireTypedArrayGetter("byteLength");
+/** Shared canonical header for both archive encoders. */
+function workspaceTarHeader(name, mode, size) {
+	return {
+		name,
+		mode,
+		uid: 0,
+		gid: 0,
+		size,
+		mtime: fixedTarTime,
+		type: "file",
+		uname: "",
+		gname: ""
+	};
+}
+//#endregion
+//#region src/candidate-execution/artifact-streams.ts
+/** Verify the complete stream, including its final digest, before accepting its consumer's result. */
+async function* verifiedArtifactChunks(artifact, port, signal) {
+	signal?.throwIfAborted();
+	if (!("content" in artifact) && !port.readStream) throw new Error("streaming workspace artifacts require readStream");
+	const chunks = "content" in artifact ? [Buffer.from(artifact.content, "base64")] : port.readStream(artifact, { signal });
+	const hash = createHash("sha256");
+	let byteLength = 0;
+	for await (const chunk of chunks) {
+		signal?.throwIfAborted();
+		if (!(chunk instanceof Uint8Array)) throw new Error("candidate artifact emitted a non-byte chunk");
+		byteLength += chunk.byteLength;
+		if (byteLength > artifact.byteLength) throw new Error("candidate artifact exceeds its declared length");
+		hash.update(chunk);
+		yield chunk;
+	}
+	signal?.throwIfAborted();
+	if (byteLength !== artifact.byteLength || `sha256:${hash.digest("hex")}` !== artifact.sha256) throw new Error("candidate artifact failed digest or length verification");
+}
+/** Stream evaluator evidence into its existing store and verify durable readback before returning. */
+async function persistCandidateOutputArtifactStream(port, input) {
+	if (!port.putStream || !port.readStream) throw new Error("streaming workspace persistence requires putStream and readStream");
+	input.signal?.throwIfAborted();
+	const hash = createHash("sha256");
+	let byteLength = 0;
+	let consumed = false;
+	async function* checked() {
+		for await (const chunk of input.chunks) {
+			input.signal?.throwIfAborted();
+			if (!(chunk instanceof Uint8Array)) throw new Error("candidate artifact emitted a non-byte chunk");
+			byteLength += chunk.byteLength;
+			if (byteLength > input.maxBytes) throw new Error("candidate workspace archive exceeds maxArchiveBytes");
+			hash.update(chunk);
+			yield chunk;
+		}
+		consumed = true;
+		input.signal?.throwIfAborted();
+	}
+	const chunks = checked();
+	try {
+		const ref = agentCandidateArtifactRefSchema.parse(await port.putStream({
+			executionId: input.executionId,
+			purpose: input.purpose,
+			chunks,
+			...input.signal ? { signal: input.signal } : {}
+		}));
+		input.signal?.throwIfAborted();
+		if (!consumed || ref.sha256 !== `sha256:${hash.digest("hex")}` || ref.byteLength !== byteLength) throw new Error("candidate output locator does not identify the submitted bytes");
+		for await (const _chunk of verifiedArtifactChunks(ref, port, input.signal));
+		return immutableCandidateValue(ref);
+	} finally {
+		await chunks.return(void 0);
+	}
+}
+//#endregion
+//#region src/candidate-execution/workspace-streams.ts
+/** Capture regular files to durable artifacts with memory bounded by the manifest and stream buffers. */
+async function captureAgentCandidateWorkspaceToArtifacts(rootInput, options) {
+	const { outputArtifacts, executionId, signal } = options.artifactPersistence;
+	if (!outputArtifacts.putStream || !outputArtifacts.readStream) throw new Error("streaming workspace persistence requires putStream and readStream");
+	if (!executionId.trim()) throw new Error("candidate workspace artifact persistence requires an executionId");
+	signal?.throwIfAborted();
+	const limits = workspaceLimits(options.limits);
+	const material = await scanMaterializedWorkspaceManifest(rootInput, {
+		limits,
+		signal
+	});
+	validateManifest(material, limits);
+	const root = await realpath(resolve(rootInput));
+	const manifest = canonicalCandidateBytes$1(material);
+	const manifestArtifact = await persistCandidateOutputArtifactStream(outputArtifacts, {
+		executionId,
+		purpose: "candidate-workspace-manifest",
+		chunks: oneChunk(manifest),
+		maxBytes: manifest.byteLength,
+		signal
+	});
+	const archiveArtifact = await persistCandidateOutputArtifactStream(outputArtifacts, {
+		executionId,
+		purpose: "candidate-workspace-archive",
+		chunks: workspaceArchiveChunks(root, material, signal),
+		maxBytes: limits.maxArchiveBytes,
+		signal
+	});
+	return Object.freeze({ snapshot: deepFreezeCandidate({
+		kind: "agent-candidate-workspace-snapshot",
+		digest: canonicalCandidateDigest$1(material),
+		material,
+		manifest: manifestArtifact,
+		archive: archiveArtifact
+	}) });
+}
+/** Verify durable regular-file workspace evidence without retaining archive or file contents. */
+async function verifyAgentCandidateWorkspaceArtifacts(input) {
+	await consumeWorkspaceArtifacts(input);
+}
+/** Restore regular-file artifacts into an empty destination, publishing only after complete verification. */
+async function materializeAgentCandidateWorkspaceFromArtifacts(input) {
+	input.signal?.throwIfAborted();
+	if (!input.artifacts.readStream) throw new Error("streaming workspace artifacts require readStream");
+	const destination = resolve(input.destination);
+	await prepareEmptyDestination(destination);
+	const staging = await mkdtemp(`${destination}.materializing-`);
+	try {
+		await consumeWorkspaceArtifacts(input, staging);
+		input.signal?.throwIfAborted();
+		await rename(staging, destination);
+	} catch (error) {
+		await rm(staging, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+}
+async function consumeWorkspaceArtifacts(input, destination) {
+	const { artifacts, signal } = input;
+	const snapshot = deepFreezeCandidate(structuredClone(input.snapshot));
+	signal?.throwIfAborted();
+	if (!artifacts.readStream) throw new Error("streaming workspace artifacts require readStream");
+	const limits = workspaceLimits(input.limits);
+	validateManifest(snapshot.material, limits);
+	if (snapshot.archive.byteLength > limits.maxArchiveBytes) throw new Error("candidate workspace archive exceeds maxArchiveBytes");
+	const manifest = canonicalCandidateBytes$1(snapshot.material);
+	verifyBytes(manifest, snapshot.manifest.sha256, snapshot.manifest.byteLength, "candidate workspace manifest");
+	if (canonicalCandidateDigest$1(snapshot.material) !== snapshot.digest) throw new Error("workspace snapshot digest does not match its canonical manifest material");
+	let offset = 0;
+	for await (const chunk of verifiedArtifactChunks(snapshot.manifest, artifacts, signal)) {
+		if (!Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength).equals(manifest.subarray(offset, offset + chunk.byteLength))) throw new Error("workspace manifest artifact is not the exact canonical manifest material");
+		offset += chunk.byteLength;
+	}
+	const parser = extract();
+	const canonical = pack();
+	const canonicalResult = digestChunks(canonical, limits.maxArchiveBytes, signal);
+	const reading = pipeline(Readable.from(verifiedArtifactChunks(snapshot.archive, artifacts, signal)), parser, { signal });
+	reading.catch(() => void 0);
+	canonicalResult.catch(() => void 0);
+	try {
+		let index = 0;
+		for await (const entry of parser) {
+			signal?.throwIfAborted();
+			const expected = snapshot.material.files[index++];
+			if (!expected || entry.header.type !== "file" || entry.header.name !== `workspace/${expected.path}` || entry.header.mode !== expected.mode || entry.header.size !== expected.byteLength) throw new Error("candidate workspace archive does not match its snapshot manifest");
+			const file = destination ? await openDestination(destination, expected.path) : void 0;
+			try {
+				async function* checked() {
+					const hash = createHash("sha256");
+					let byteLength = 0;
+					for await (const chunk of entry) {
+						if (!(chunk instanceof Uint8Array)) throw new Error("workspace entry emitted a non-byte chunk");
+						signal?.throwIfAborted();
+						byteLength += chunk.byteLength;
+						if (byteLength > expected.byteLength) throw new Error("workspace entry exceeds its manifest length");
+						hash.update(chunk);
+						if (file) await file.writeFile(chunk);
+						yield chunk;
+					}
+					if (byteLength !== expected.byteLength || `sha256:${hash.digest("hex")}` !== expected.sha256) throw new Error("candidate workspace archive does not match its snapshot manifest");
+				}
+				await appendTarFile(canonical, expected, checked(), signal);
+				if (file) await file.chmod(expected.mode);
+			} finally {
+				await file?.close();
+			}
+		}
+		if (index !== snapshot.material.files.length) throw new Error("candidate workspace archive does not match its snapshot manifest");
+		await reading;
+		canonical.finalize();
+		const observed = await canonicalResult;
+		if (observed.byteLength !== snapshot.archive.byteLength || observed.sha256 !== snapshot.archive.sha256) throw new Error("candidate workspace tar is not canonical");
+	} catch (error) {
+		parser.destroy(asError(error));
+		canonical.destroy(asError(error));
+		await Promise.allSettled([reading, canonicalResult]);
+		throw error;
+	}
+}
+async function openDestination(destination, relativePath) {
+	const path = workspacePath(destination, relativePath);
+	await mkdir(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	return open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+}
+async function* workspaceArchiveChunks(root, material, signal) {
+	const archive = pack();
+	const writing = (async () => {
+		try {
+			for (const file of material.files) {
+				signal?.throwIfAborted();
+				await appendTarFile(archive, file, workspaceFileChunks(root, file, signal), signal);
+			}
+			archive.finalize();
+		} catch (error) {
+			archive.destroy(asError(error));
+			throw error;
+		}
+	})();
+	writing.catch(() => void 0);
+	try {
+		for await (const chunk of archive) {
+			if (!(chunk instanceof Uint8Array)) throw new Error("workspace archive emitted a non-byte chunk");
+			signal?.throwIfAborted();
+			yield chunk;
+		}
+		await writing;
+	} finally {
+		archive.destroy();
+		await writing.catch(() => void 0);
+	}
+}
+async function* workspaceFileChunks(root, expected, signal) {
+	const path = workspacePath(root, expected.path);
+	if (await realpath(path) !== path) throw new Error(`workspace file path changed during capture: ${expected.path}`);
+	const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+	try {
+		const stats = await file.stat();
+		if (!stats.isFile() || stats.nlink !== 1 || stats.size !== expected.byteLength || (stats.mode & 511) !== expected.mode) throw new Error(`workspace file changed during capture: ${expected.path}`);
+		const hash = createHash("sha256");
+		let byteLength = 0;
+		for await (const chunk of file.createReadStream({
+			autoClose: false,
+			highWaterMark: 64 * 1024
+		})) {
+			signal?.throwIfAborted();
+			byteLength += chunk.byteLength;
+			if (byteLength > expected.byteLength) throw new Error(`workspace file changed during capture: ${expected.path}`);
+			hash.update(chunk);
+			yield chunk;
+		}
+		if (byteLength !== expected.byteLength || `sha256:${hash.digest("hex")}` !== expected.sha256) throw new Error(`workspace file changed during capture: ${expected.path}`);
+	} finally {
+		await file.close();
+	}
+}
+async function appendTarFile(archive, file, chunks, signal) {
+	const entry = archive.entry(workspaceTarHeader(`workspace/${file.path}`, file.mode, file.byteLength));
+	await pipeline(Readable.from(chunks), entry, { signal });
+}
+async function digestChunks(chunks, maxBytes, signal) {
+	const hash = createHash("sha256");
+	let byteLength = 0;
+	for await (const chunk of chunks) {
+		if (!(chunk instanceof Uint8Array)) throw new Error("workspace archive emitted a non-byte chunk");
+		signal?.throwIfAborted();
+		byteLength += chunk.byteLength;
+		if (byteLength > maxBytes) throw new Error("candidate workspace archive exceeds maxArchiveBytes");
+		hash.update(chunk);
+	}
+	return {
+		sha256: `sha256:${hash.digest("hex")}`,
+		byteLength
+	};
+}
+function validateManifest(material, limits) {
+	if (material.kind !== "agent-candidate-workspace-manifest" || material.files.length > limits.maxFiles) throw new Error("candidate workspace exceeds maxFiles");
+	let total = 0;
+	let previous;
+	const paths = /* @__PURE__ */ new Set();
+	for (const file of material.files) {
+		safeArchivePath(file.path, limits.maxPathBytes);
+		assertWorkspacePathOrder(file.path, previous, paths, "candidate workspace paths must be unique and sorted");
+		previous = file.path;
+		if (!Number.isSafeInteger(file.mode) || file.mode < 0 || file.mode > 511) throw new Error("candidate workspace file has unsupported mode");
+		if (!Number.isSafeInteger(file.byteLength) || file.byteLength < 0 || file.byteLength > limits.maxFileBytes) throw new Error("candidate workspace file exceeds maxFileBytes");
+		total += file.byteLength;
+		if (total > limits.maxTotalFileBytes) throw new Error("candidate workspace exceeds maxTotalFileBytes");
+	}
+}
+async function* oneChunk(bytes) {
+	yield bytes;
+}
+function asError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
 //#endregion
-export { sha256Bytes$1 as A, canonicalCandidateBytes$1 as C, embeddedCandidateArtifact as D, deepFreezeCandidate as E, immutableCandidateValue as O, verifyWorkspaceSnapshotArtifacts as S, canonicalCandidateDocument as T, readVerifiedArtifact as _, persistCandidateOutputArtifact as a, verifyMaterializedProfileWorkspace as b, verifyTaskCheckout as c, isWellFormedUnicode as d, WorkspaceScanLimitError as f, readMaterializedWorkspaceFiles as g, captureMaterializedWorkspace as h, verifyAgentCandidateWorkspaceArchive as i, verifyCanonicalCandidateDocument as j, omitTopLevelDigest as k, verifyTaskOutcomePatch as l, candidateWorkspaceManifest as m, captureAgentCandidateWorkspaceFiles as n, readCandidateGitHubResource as o, artifactCacheKey as p, createAgentCandidateWorkspacePort as r, verifyCandidateCode as s, captureAgentCandidateWorkspace as t, assertExactObjectKeys as u, scanMaterializedWorkspaceManifest as v, canonicalCandidateDigest$1 as w, verifyMaterializedWorkspace as x, verifyBytes as y };
+export { embeddedCandidateArtifact as A, verifyMaterializedProfileWorkspace as C, canonicalCandidateDigest$1 as D, canonicalCandidateBytes$1 as E, omitTopLevelDigest as M, sha256Bytes$1 as N, canonicalCandidateDocument as O, verifyCanonicalCandidateDocument as P, verifyBytes as S, verifyWorkspaceSnapshotArtifacts as T, candidateWorkspaceManifest as _, captureAgentCandidateWorkspaceFiles as a, readVerifiedArtifact as b, persistCandidateOutputArtifact as c, verifyTaskCheckout as d, verifyTaskOutcomePatch as f, artifactCacheKey as g, WorkspaceScanLimitError as h, captureAgentCandidateWorkspace as i, immutableCandidateValue as j, deepFreezeCandidate as k, readCandidateGitHubResource as l, isWellFormedUnicode as m, materializeAgentCandidateWorkspaceFromArtifacts as n, createAgentCandidateWorkspacePort as o, assertExactObjectKeys as p, verifyAgentCandidateWorkspaceArtifacts as r, verifyAgentCandidateWorkspaceArchive as s, captureAgentCandidateWorkspaceToArtifacts as t, verifyCandidateCode as u, captureMaterializedWorkspace as v, verifyMaterializedWorkspace as w, scanMaterializedWorkspaceManifest as x, readMaterializedWorkspaceFiles as y };
 
-//# sourceMappingURL=workspace-archive-MhowMCmp.js.map
+//# sourceMappingURL=workspace-streams-D4TMTrJV.js.map