@tangle-network/agent-runtime 0.337.2 → 0.339.0

package/dist/{sandbox-profile-compat-QTkLe1Z6.js → sandbox-profile-compat-BzVBFqrz.js}

@@ -1,4 +1,5 @@
 import { m as ValidationError } from "./errors-DodWX-cb.js";
+import { t as isRecord } from "./record-value-B6bwJxLa.js";
 import { runTaskQueue } from "./task-queue.js";
 import { agentCandidateArtifactRefSchema, canonicalCandidateBytes as canonicalCandidateBytes$1 } from "@tangle-network/agent-interface";
 import { createHash, randomUUID } from "node:crypto";
@@ -18,8 +19,6 @@ const DEFAULT_SUCCESSFUL_SHUTDOWN_MS = 5e3;
 const CHILD_DEADLINE_REASON = "child deadline exceeded";
 /** The abort reason the root's budget deadline cascades to every node. */
 const ROOT_DEADLINE_REASON = "root budget deadline exceeded";
-/** How long a checked-in child may go without progress before it is stopped: 30 min. */
-const DEFAULT_CHECK_IN_IDLE_MS = 30 * 6e4;
 /** The check-in a child receives at its own time box. */
 const DEADLINE_CHECK_IN_MESSAGE = "Check-in: your time box has ended. This is not a stop. Finish the step you are on and start nothing new. Record your current state and every result you have not recorded yet, then call submit_result with what you have now; if the work is not done, mark it incomplete and name what remains. Your lead decides whether to continue you or hand the work on. You keep running while you make progress.";
 /** The idle bound a check-in policy sets, or undefined when time boxes are hard kills. */
@@ -233,9 +232,9 @@ function randomSuffix(len = 8) {
 function randomUuid() {
 	return crypto.randomUUID();
 }
-/** Construct an AbortError. Downstream code pattern-matches on `err.name`. */
-function abortError() {
-	const err = /* @__PURE__ */ new Error("aborted");
+/** Construct an AbortError carrying the abort reason's message. Downstream code pattern-matches on `err.name`. */
+function abortError(reason) {
+	const err = new Error(reason instanceof Error ? reason.message : reason === void 0 ? "aborted" : String(reason));
 	err.name = "AbortError";
 	return err;
 }
@@ -635,6 +634,16 @@ function fnv1a32Hex(text) {
 	return (h >>> 0).toString(16).padStart(8, "0");
 }
 //#endregion
+//#region src/path-control-characters.ts
+/** Whether a serialized field contains an ASCII control or delete character. */
+function hasControlCharacter(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code < 32 || code === 127) return true;
+	}
+	return false;
+}
+//#endregion
 //#region src/candidate-execution/digest.ts
 /** Use native hashing for workspace archives. */
 function sha256Bytes$1(bytes) {
@@ -1035,170 +1044,609 @@ function isWellFormedUnicode(value) {
 	return true;
 }
 //#endregion
-//#region src/candidate-execution/git-materialize.ts
-async function verifyCandidateCode(code, repositories, patchBytes) {
-	if (code.kind === "disabled") return void 0;
-	const repositoryRoot = await verifiedRepositoryRoot(code.repository, repositories);
-	await assertCommitAndBaseTree(repositoryRoot, code.baseCommit, code.baseTree);
-	if (code.kind === "no-op") {
-		await assertSafeTree(repositoryRoot, code.baseTree);
-		return code.baseTree;
-	}
-	if (!patchBytes) throw new Error("git-patch candidate is missing verified patch bytes");
-	const temporary = await mkdtemp(join(tmpdir(), "agent-candidate-git-"));
-	try {
-		const indexFile = join(temporary, "index");
-		await runCandidateGit(repositoryRoot, ["read-tree", code.baseTree], void 0, { GIT_INDEX_FILE: indexFile });
-		await runCandidateGit(repositoryRoot, [
-			"apply",
-			"--cached",
-			"--binary",
-			"--whitespace=nowarn",
-			"-"
-		], patchBytes, { GIT_INDEX_FILE: indexFile });
-		const candidateTree = (await runCandidateGit(repositoryRoot, ["write-tree"], void 0, { GIT_INDEX_FILE: indexFile })).stdout.toString("utf8").trim();
-		if (candidateTree !== code.candidateTree) throw new Error(`git patch materialized tree ${candidateTree} does not match ${code.candidateTree}`);
-		await assertSafeTree(repositoryRoot, candidateTree);
-		return candidateTree;
-	} finally {
-		await rm(temporary, {
-			recursive: true,
-			force: true
-		});
-	}
+//#region src/candidate-execution/output-artifacts.ts
+/** Persist evaluator evidence, read it back, and bind the returned locator to the exact bytes. */
+async function persistCandidateOutputArtifact(port, input) {
+	input.signal?.throwIfAborted();
+	const bytes = Uint8Array.from(input.bytes);
+	const expectedDigest = sha256Bytes$1(bytes);
+	const ref = agentCandidateArtifactRefSchema.parse(await port.put({
+		executionId: input.executionId,
+		purpose: input.purpose,
+		bytes: Uint8Array.from(bytes),
+		...input.signal ? { signal: input.signal } : {}
+	}));
+	input.signal?.throwIfAborted();
+	if (ref.sha256 !== expectedDigest || ref.byteLength !== bytes.byteLength) throw new Error("candidate output locator does not identify the submitted bytes");
+	const stored = await port.read(ref);
+	input.signal?.throwIfAborted();
+	verifyBytes(stored, expectedDigest, bytes.byteLength, "persisted candidate output");
+	return immutableCandidateValue(ref);
 }
-async function readCandidateGitHubResource(resource, repositories) {
-	const repositoryRoot = await verifiedRepositoryRoot(resource.repository, repositories);
-	if ((await runCandidateGit(repositoryRoot, [
-		"cat-file",
-		"-t",
-		resource.commit
-	])).stdout.toString("utf8").trim() !== "commit") throw new Error(`GitHub resource commit is not a commit object: ${resource.commit}`);
-	const listing = (await runCandidateGit(repositoryRoot, [
-		"ls-tree",
-		"-z",
-		resource.commit,
-		"--",
-		resource.path
-	])).stdout;
-	const entries = parseTreeEntries(listing);
-	if (entries.length !== 1 || entries[0]?.path !== resource.path) throw new Error(`GitHub resource path is not one exact file: ${resource.path}`);
-	const entry = entries[0];
-	if (entry?.type !== "blob" || entry.mode !== "100644" && entry.mode !== "100755") throw new Error(`GitHub resource path is not a regular Git blob: ${resource.path}`);
-	const bytes = (await runCandidateGit(repositoryRoot, [
-		"cat-file",
-		"blob",
-		entry.object
-	])).stdout;
-	verifyBytes(bytes, resource.sha256, resource.byteLength, `GitHub resource ${resource.path}`);
-	return Uint8Array.from(bytes);
+//#endregion
+//#region src/candidate-execution/workspace-archive.ts
+const archiveKind = "agent-candidate-workspace-archive";
+const workspaceEntryPrefix = "workspace/";
+const repositoryMetadataEntry = "metadata/repository.json";
+const repositoryBundleEntry = "metadata/repository.bundle";
+const repositoryIndexEntry = "metadata/repository.index.json";
+const repositoryIndexPrefix = "index/";
+const fixedTarTime = /* @__PURE__ */ new Date(0);
+const defaultLimits = Object.freeze({
+	maxArchiveBytes: 512 * 1024 * 1024,
+	maxEmbeddedArtifactBytes: 1024 * 1024,
+	maxFiles: 5e4,
+	maxFileBytes: 128 * 1024 * 1024,
+	maxTotalFileBytes: 256 * 1024 * 1024,
+	maxPathBytes: 4096,
+	maxRepositoryBundleBytes: 128 * 1024 * 1024
+});
+/** Capture detached files returned by a remote executor into the standard archive. */
+async function captureAgentCandidateWorkspaceFiles(input, options = {}) {
+	const limits = workspaceLimits(options.limits);
+	return captureWorkspaceFiles(normalizeWorkspaceFiles(input, limits), void 0, limits, options.artifactPersistence);
 }
-async function verifyTaskCheckout(taskRoot, expected) {
-	const root = resolve(taskRoot);
-	const head = (await runCandidateGit(root, ["rev-parse", "HEAD"])).stdout.toString("utf8").trim();
-	if (head !== expected.baseCommit) throw new Error(`task checkout HEAD ${head} does not match ${expected.baseCommit}`);
-	const tree = (await runCandidateGit(root, ["rev-parse", "HEAD^{tree}"])).stdout.toString("utf8").trim();
-	if (tree !== expected.baseTree) throw new Error(`task checkout base tree ${tree} does not match ${expected.baseTree}`);
+async function captureWorkspaceFiles(files, repository, limits, artifactPersistence) {
+	const material = candidateWorkspaceManifest(files);
+	const manifest = canonicalCandidateBytes$1(material);
+	const archive = await encodeWorkspaceArchive(files, repository, limits.maxArchiveBytes);
+	if (!artifactPersistence && (manifest.byteLength > limits.maxEmbeddedArtifactBytes || archive.byteLength > limits.maxEmbeddedArtifactBytes)) throw new Error("candidate workspace artifacts exceed maxEmbeddedArtifactBytes; artifactPersistence is required");
+	const manifestArtifact = await captureWorkspaceArtifact("manifest", manifest, artifactPersistence);
+	const archiveArtifact = await captureWorkspaceArtifact("archive", archive, artifactPersistence);
+	const snapshot = deepFreezeCandidate({
+		kind: "agent-candidate-workspace-snapshot",
+		digest: canonicalCandidateDigest$1(material),
+		material,
+		manifest: manifestArtifact,
+		archive: archiveArtifact
+	});
+	return Object.freeze({
+		snapshot,
+		archive
+	});
 }
-/**
-* Apply an evaluator-captured binary diff in a detached object database and
-* prove its result tree exactly matches the captured after-state manifest.
-*/
-async function verifyTaskOutcomePatch(input) {
-	const repositoryRoot = resolve(input.repositoryRoot);
-	await verifyTaskCheckout(repositoryRoot, input);
-	const gitDir = resolve((await runCandidateGit(repositoryRoot, ["rev-parse", "--absolute-git-dir"])).stdout.toString("utf8").trim());
-	if (await realpath(gitDir) !== gitDir || gitDir.includes(":")) throw new Error("task Git object store has an unsupported path");
-	await assertNoGitIndirection(repositoryRoot, gitDir, "task repository");
-	const temporary = await mkdtemp(join(tmpdir(), "agent-candidate-task-outcome-"));
-	try {
-		const objectDirectory = join(temporary, "objects");
-		const indexFile = join(temporary, "index");
-		await mkdir(objectDirectory);
-		const gitEnvironment = {
-			GIT_INDEX_FILE: indexFile,
-			GIT_OBJECT_DIRECTORY: objectDirectory,
-			GIT_ALTERNATE_OBJECT_DIRECTORIES: join(gitDir, "objects")
-		};
-		await runCandidateGit(repositoryRoot, ["read-tree", input.baseTree], void 0, gitEnvironment);
-		if (input.patch.byteLength > 0) await runCandidateGit(repositoryRoot, [
-			"apply",
-			"--cached",
-			"--binary",
-			"--whitespace=nowarn",
-			"-"
-		], input.patch, gitEnvironment);
-		const resultTree = (await runCandidateGit(repositoryRoot, ["write-tree"], void 0, gitEnvironment)).stdout.toString("utf8").trim();
-		if (resultTree !== input.resultTree) throw new Error(`task outcome patch materialized tree ${resultTree} does not match ${input.resultTree}`);
-		await assertSafeTree(repositoryRoot, resultTree, gitEnvironment);
-		const observed = await workspaceManifestFromGitTree(repositoryRoot, resultTree, gitEnvironment);
-		if (!Buffer.from(canonicalCandidateBytes$1(observed)).equals(Buffer.from(canonicalCandidateBytes$1(input.afterState)))) throw new Error("task outcome after-state does not match the materialized result tree");
-		const resultCommit = (await runCandidateGit(repositoryRoot, [
-			"commit-tree",
-			resultTree,
-			"-p",
-			input.baseCommit
-		], Buffer.from("candidate task outcome\n", "utf8"), {
-			...gitEnvironment,
-			GIT_AUTHOR_NAME: "Tangle Evaluator",
-			GIT_AUTHOR_EMAIL: "evaluator@tangle.tools",
-			GIT_AUTHOR_DATE: "2000-01-01T00:00:00Z",
-			GIT_COMMITTER_NAME: "Tangle Evaluator",
-			GIT_COMMITTER_EMAIL: "evaluator@tangle.tools",
-			GIT_COMMITTER_DATE: "2000-01-01T00:00:00Z"
-		})).stdout.toString("utf8").trim();
-		if ((await runCandidateGit(repositoryRoot, ["rev-parse", `${resultCommit}^{tree}`], void 0, gitEnvironment)).stdout.toString("utf8").trim() !== resultTree) throw new Error("task outcome evaluator commit does not bind the verified result tree");
-		return {
-			resultTree,
-			resultCommit
-		};
-	} finally {
-		await rm(temporary, {
-			recursive: true,
-			force: true
-		});
-	}
+async function captureWorkspaceArtifact(kind, bytes, persistence) {
+	if (!persistence) return embeddedCandidateArtifact(bytes);
+	if (!persistence.executionId.trim()) throw new Error("candidate workspace artifact persistence requires an executionId");
+	return persistCandidateOutputArtifact(persistence.outputArtifacts, {
+		executionId: persistence.executionId,
+		purpose: kind === "manifest" ? "candidate-workspace-manifest" : "candidate-workspace-archive",
+		bytes,
+		...persistence.signal ? { signal: persistence.signal } : {}
+	});
 }
-async function verifiedRepositoryRoot(repository, repositories) {
-	const repositoryRoot = resolve(await repositories.resolve(repository));
-	if (!(await stat(repositoryRoot)).isDirectory()) throw new Error("candidate repository path is not a directory");
-	const origin = (await runCandidateGit(repositoryRoot, [
-		"remote",
-		"get-url",
-		"origin"
-	])).stdout.toString("utf8").trim();
-	const actual = parseGitHubRemote(origin);
-	if (!actual || actual.owner !== repository.owner || actual.repo !== repository.repo) throw new Error(`local repository origin ${origin || "<missing>"} does not match github.com/${repository.owner}/${repository.repo}`);
-	await assertNoGitIndirection(repositoryRoot, resolve((await runCandidateGit(repositoryRoot, ["rev-parse", "--absolute-git-dir"])).stdout.toString("utf8").trim()), "candidate repository");
-	return repositoryRoot;
+/** Verify a portable archive before its source environment may be discarded. */
+async function verifyAgentCandidateWorkspaceArchive(input) {
+	await decodeVerifiedWorkspaceArchive({
+		...input,
+		limits: workspaceLimits(input.limits)
+	});
 }
-async function assertNoGitIndirection(repositoryRoot, gitDir, label) {
-	if ((await runCandidateGit(repositoryRoot, [
-		"for-each-ref",
-		"--format=%(refname)",
-		"refs/replace"
-	])).stdout.toString("utf8").trim()) throw new Error(`${label} contains Git replace refs`);
-	const commonDir = await realpath(resolve(repositoryRoot, (await runCandidateGit(repositoryRoot, ["rev-parse", "--git-common-dir"])).stdout.toString("utf8").trim()));
-	if (commonDir.includes(":")) throw new Error(`${label} Git common directory has an unsupported path`);
-	for (const objectRoot of /* @__PURE__ */ new Set([gitDir, commonDir])) for (const name of ["alternates", "http-alternates"]) {
-		const path = join(objectRoot, "objects", "info", name);
-		try {
-			if ((await readFile(path, "utf8")).trim()) throw new Error(`${label} uses forbidden Git ${name}`);
-		} catch (error) {
-			if (!isNoEntry(error)) throw error;
-		}
-	}
+async function decodeVerifiedWorkspaceArchive(input) {
+	verifyBytes(input.archive, input.snapshot.archive.sha256, input.snapshot.archive.byteLength, "candidate workspace archive");
+	const decoded = await parseWorkspaceArchive(input.archive, input.limits);
+	if (decoded.repository && input.role !== "task") throw new Error("only task workspaces may carry a Git repository");
+	assertArchiveMatchesSnapshot(decoded.files, input.snapshot);
+	return decoded;
 }
-async function assertCommitAndBaseTree(repositoryRoot, commit, expectedTree) {
-	if ((await runCandidateGit(repositoryRoot, [
-		"cat-file",
-		"-t",
-		commit
-	])).stdout.toString("utf8").trim() !== "commit") throw new Error(`candidate base object is not a commit: ${commit}`);
-	const actualTree = (await runCandidateGit(repositoryRoot, ["rev-parse", `${commit}^{tree}`])).stdout.toString("utf8").trim();
-	if (actualTree !== expectedTree) throw new Error(`candidate base commit tree ${actualTree} does not match ${expectedTree}`);
+async function encodeWorkspaceArchive(files, repository, maxArchiveBytes) {
+	const archive = pack();
+	const output = collectStream(archive, maxArchiveBytes, "candidate workspace archive");
+	try {
+		await writeWorkspaceArchiveEntries(archive, files, repository);
+		archive.finalize();
+		return await output;
+	} catch (error) {
+		archive.destroy(error instanceof Error ? error : new Error(String(error)));
+		await output.catch(() => void 0);
+		throw error;
+	}
 }
-async function assertSafeTree(repositoryRoot, tree, environment = {}) {
+async function verifyCanonicalWorkspaceArchive(files, repository, expected, maxArchiveBytes) {
+	const archive = pack();
+	const comparison = streamEqualsBytes(archive, expected, maxArchiveBytes, "candidate workspace archive");
+	try {
+		await writeWorkspaceArchiveEntries(archive, files, repository);
+		archive.finalize();
+		if (!await comparison) throw new Error("candidate workspace tar is not canonical");
+	} catch (error) {
+		archive.destroy(error instanceof Error ? error : new Error(String(error)));
+		await comparison.catch(() => void 0);
+		throw error;
+	}
+}
+async function writeWorkspaceArchiveEntries(archive, files, repository) {
+	for (const file of files) await writeTarEntry(archive, `${workspaceEntryPrefix}${file.path}`, file.mode, file.bytes);
+	if (!repository) return;
+	const indexManifest = repository.workingTree ? canonicalCandidateBytes$1(candidateWorkspaceManifest(repository.workingTree.files)) : void 0;
+	const metadata = canonicalCandidateBytes$1({
+		kind: archiveKind,
+		headCommit: repository.headCommit,
+		headTree: repository.headTree,
+		bundle: {
+			sha256: repository.bundle.sha256,
+			byteLength: repository.bundle.byteLength
+		},
+		...indexManifest ? { workingTree: { indexManifest: {
+			sha256: sha256Bytes$1(indexManifest),
+			byteLength: indexManifest.byteLength
+		} } } : {}
+	});
+	await writeTarEntry(archive, repositoryMetadataEntry, 384, metadata);
+	await writeTarEntry(archive, repositoryBundleEntry, 384, repository.bundle.bytes);
+	if (repository.workingTree && indexManifest) {
+		await writeTarEntry(archive, repositoryIndexEntry, 384, indexManifest);
+		for (const file of repository.workingTree.files) await writeTarEntry(archive, `${repositoryIndexPrefix}${file.path}`, file.mode, file.bytes);
+	}
+}
+async function parseWorkspaceArchive(bytes, limits) {
+	if (bytes.byteLength > limits.maxArchiveBytes) throw new Error("candidate workspace archive exceeds maxArchiveBytes");
+	const parser = extract();
+	const files = [];
+	const observedEntryNames = /* @__PURE__ */ new Set();
+	const observedPaths = /* @__PURE__ */ new Set();
+	let totalBytes = 0;
+	let retainedEntryBytes = 0;
+	let previousPath;
+	let repositoryMetadata;
+	let repositoryBundle;
+	let repositoryIndex;
+	const indexFiles = [];
+	const indexPaths = /* @__PURE__ */ new Set();
+	let previousIndexPath;
+	let indexBytes = 0;
+	const decoded = (async () => {
+		for await (const entry of parser) {
+			const name = entry.header.name;
+			if (entry.header.type !== "file" || typeof name !== "string" || observedEntryNames.has(name)) throw new Error("candidate workspace tar contains an invalid entry");
+			observedEntryNames.add(name);
+			if (name.startsWith(workspaceEntryPrefix)) {
+				if (files.length >= limits.maxFiles) throw new Error("candidate workspace archive has an invalid file count");
+				const path = safeArchivePath(name.slice(10), limits.maxPathBytes);
+				if (!isWorkspaceFileMode(entry.header.mode)) throw new Error(`candidate workspace archive has an unsupported mode: ${path}`);
+				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
+				const fileBytes = await readTarEntry(entry, limits.maxFileBytes, `workspace file ${path}`);
+				retainedEntryBytes += fileBytes.byteLength;
+				assertWorkspacePathOrder(path, previousPath, observedPaths, "candidate workspace archive paths must be unique and sorted");
+				previousPath = path;
+				if (fileBytes.byteLength > limits.maxTotalFileBytes - totalBytes) throw new Error("candidate workspace archive exceeds maxTotalFileBytes");
+				totalBytes += fileBytes.byteLength;
+				files.push({
+					path,
+					mode: entry.header.mode,
+					bytes: fileBytes
+				});
+			} else if (name === repositoryMetadataEntry) {
+				if (entry.header.mode !== 384 || repositoryMetadata) throw new Error("candidate workspace archive repository metadata is invalid");
+				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
+				const metadataBytes = await readTarEntry(entry, limits.maxPathBytes, "candidate repository metadata");
+				retainedEntryBytes += metadataBytes.byteLength;
+				repositoryMetadata = parseRepositoryMetadata(metadataBytes, limits);
+			} else if (name === repositoryBundleEntry) {
+				if (entry.header.mode !== 384 || repositoryBundle) throw new Error("candidate workspace archive repository bundle is invalid");
+				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
+				repositoryBundle = await readTarEntry(entry, limits.maxRepositoryBundleBytes, "candidate Git bundle");
+				retainedEntryBytes += repositoryBundle.byteLength;
+			} else if (name === repositoryIndexEntry) {
+				if (entry.header.mode !== 384 || repositoryIndex) throw new Error("candidate workspace archive repository index is invalid");
+				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
+				repositoryIndex = await readTarEntry(entry, limits.maxArchiveBytes, "candidate Git index manifest");
+				retainedEntryBytes += repositoryIndex.byteLength;
+			} else if (name.startsWith(repositoryIndexPrefix)) {
+				if (!repositoryMetadata?.workingTree || !repositoryIndex || indexFiles.length >= limits.maxFiles) throw new Error("candidate Git index evidence is incomplete or exceeds maxFiles");
+				const path = safeArchivePath(name.slice(6), limits.maxPathBytes);
+				if (entry.header.mode !== 420 && entry.header.mode !== 493) throw new Error("candidate Git index contains an unsupported mode");
+				assertWorkspacePathOrder(path, previousIndexPath, indexPaths, "candidate Git index paths must be unique and sorted");
+				previousIndexPath = path;
+				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
+				if (entry.header.size === void 0 || entry.header.size > limits.maxTotalFileBytes - indexBytes) throw new Error("candidate Git index exceeds maxTotalFileBytes");
+				if (entry.header.size > limits.maxFileBytes) throw new Error("candidate Git index exceeds maxFileBytes");
+				const fileBytes = await readTarEntry(entry, limits.maxFileBytes, `Git index file ${path}`);
+				retainedEntryBytes += fileBytes.byteLength;
+				indexBytes += fileBytes.byteLength;
+				indexFiles.push({
+					path,
+					mode: entry.header.mode,
+					bytes: fileBytes
+				});
+			} else throw new Error(`candidate workspace tar contains an unsupported entry: ${name}`);
+		}
+		if (Boolean(repositoryMetadata) !== Boolean(repositoryBundle)) throw new Error("candidate workspace archive repository evidence is incomplete");
+		if (Boolean(repositoryMetadata?.workingTree) !== Boolean(repositoryIndex)) throw new Error("candidate workspace archive repository index evidence is incomplete");
+		const repository = repositoryMetadata && repositoryBundle ? repositoryFromTar(repositoryMetadata, repositoryBundle, repositoryIndex, indexFiles) : void 0;
+		return {
+			files,
+			...repository ? { repository } : {}
+		};
+	})();
+	parser.end(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+	const result = await decoded;
+	await verifyCanonicalWorkspaceArchive(result.files, result.repository, bytes, limits.maxArchiveBytes);
+	return result;
+}
+function assertRetainedArchiveSize(archiveBytes, retainedEntryBytes, entryBytes, limits) {
+	if (!Number.isSafeInteger(entryBytes) || entryBytes === void 0 || entryBytes < 0 || entryBytes > limits.maxArchiveBytes - archiveBytes - retainedEntryBytes) throw new Error("candidate workspace archive exceeds maxArchiveBytes while decoding");
+}
+function parseRepositoryMetadata(bytes, limits) {
+	let value;
+	try {
+		value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+	} catch (error) {
+		throw new Error("candidate workspace archive repository metadata is invalid", { cause: error });
+	}
+	if (!isRecord(value) || !["bundle,headCommit,headTree,kind", "bundle,headCommit,headTree,kind,workingTree"].includes(Object.keys(value).sort().join(",")) || value.kind !== archiveKind || typeof value.headCommit !== "string" || typeof value.headTree !== "string" || !isRecord(value.bundle) || Object.keys(value.bundle).sort().join(",") !== "byteLength,sha256" || typeof value.bundle.sha256 !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.bundle.sha256) || !Number.isSafeInteger(value.bundle.byteLength) || value.bundle.byteLength <= 0 || value.bundle.byteLength > limits.maxRepositoryBundleBytes) throw new Error("candidate workspace archive repository is invalid");
+	if (!Buffer.from(canonicalCandidateBytes$1(value)).equals(Buffer.from(bytes))) throw new Error("candidate workspace archive repository metadata is not canonical");
+	assertGitObjectId(value.headCommit, "repository HEAD");
+	assertGitObjectId(value.headTree, "repository HEAD tree");
+	if (value.headCommit.length !== value.headTree.length) throw new Error("candidate repository HEAD and tree use different object formats");
+	let workingTree;
+	if ("workingTree" in value) {
+		const working = value.workingTree;
+		if (!isRecord(working) || Object.keys(working).join(",") !== "indexManifest" || !isRecord(working.indexManifest) || Object.keys(working.indexManifest).sort().join(",") !== "byteLength,sha256" || typeof working.indexManifest.sha256 !== "string" || !/^sha256:[a-f0-9]{64}$/.test(working.indexManifest.sha256) || !Number.isSafeInteger(working.indexManifest.byteLength) || working.indexManifest.byteLength < 0 || working.indexManifest.byteLength > limits.maxArchiveBytes) throw new Error("candidate workspace archive repository index is invalid");
+		workingTree = { indexManifest: {
+			sha256: working.indexManifest.sha256,
+			byteLength: working.indexManifest.byteLength
+		} };
+	}
+	return {
+		kind: archiveKind,
+		headCommit: value.headCommit,
+		headTree: value.headTree,
+		bundle: {
+			sha256: value.bundle.sha256,
+			byteLength: value.bundle.byteLength
+		},
+		...workingTree ? { workingTree } : {}
+	};
+}
+function repositoryFromTar(metadata, bundle, indexManifest, indexFiles) {
+	verifyBytes(bundle, metadata.bundle.sha256, metadata.bundle.byteLength, "candidate Git bundle");
+	if (metadata.workingTree && indexManifest) {
+		verifyBytes(indexManifest, metadata.workingTree.indexManifest.sha256, metadata.workingTree.indexManifest.byteLength, "candidate Git index manifest");
+		if (!Buffer.from(indexManifest).equals(Buffer.from(canonicalCandidateBytes$1(candidateWorkspaceManifest(indexFiles))))) throw new Error("candidate Git index files do not match the captured manifest");
+	}
+	return {
+		headCommit: metadata.headCommit,
+		headTree: metadata.headTree,
+		bundle: {
+			...metadata.bundle,
+			bytes: bundle
+		},
+		...metadata.workingTree && indexManifest ? { workingTree: { files: indexFiles } } : {}
+	};
+}
+async function writeTarEntry(archive, name, mode, bytes) {
+	await new Promise((resolveEntry, rejectEntry) => {
+		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) {
+	const size = entry.header.size;
+	if (!Number.isSafeInteger(size) || size === void 0 || size < 0 || size > maxBytes) throw new Error(`${label} has an invalid tar size`);
+	const bytes = await collectStream(entry, maxBytes, label);
+	if (bytes.byteLength !== size) throw new Error(`${label} differs from its tar size`);
+	return bytes;
+}
+async function collectStream(stream, maxBytes, label) {
+	const chunks = [];
+	let totalBytes = 0;
+	for await (const chunk of stream) {
+		if (!(chunk instanceof Uint8Array)) throw new Error(`${label} emitted a non-byte chunk`);
+		if (chunk.byteLength > maxBytes - totalBytes) {
+			const error = /* @__PURE__ */ new Error(`${label} exceeds its size limit`);
+			if ("destroy" in stream && typeof stream.destroy === "function") stream.destroy(error);
+			throw error;
+		}
+		const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		chunks.push(bytes);
+		totalBytes += bytes.byteLength;
+	}
+	return Buffer.concat(chunks, totalBytes);
+}
+async function streamEqualsBytes(stream, expected, maxBytes, label) {
+	const expectedBuffer = Buffer.from(expected.buffer, expected.byteOffset, expected.byteLength);
+	let equal = true;
+	let offset = 0;
+	for await (const chunk of stream) {
+		if (!(chunk instanceof Uint8Array)) throw new Error(`${label} emitted a non-byte chunk`);
+		if (chunk.byteLength > maxBytes - offset) {
+			const error = /* @__PURE__ */ new Error(`${label} exceeds its size limit`);
+			if ("destroy" in stream && typeof stream.destroy === "function") stream.destroy(error);
+			throw error;
+		}
+		const observed = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+		if (offset + observed.byteLength > expectedBuffer.byteLength || !observed.equals(expectedBuffer.subarray(offset, offset + observed.byteLength))) equal = false;
+		offset += observed.byteLength;
+	}
+	return equal && offset === expectedBuffer.byteLength;
+}
+function assertArchiveMatchesSnapshot(files, snapshot) {
+	const material = candidateWorkspaceManifest(files);
+	const materialBytes = canonicalCandidateBytes$1(material);
+	verifyBytes(materialBytes, snapshot.manifest.sha256, snapshot.manifest.byteLength, "candidate workspace manifest");
+	if (canonicalCandidateDigest$1(material) !== snapshot.digest || !Buffer.from(materialBytes).equals(Buffer.from(canonicalCandidateBytes$1(snapshot.material)))) throw new Error("candidate workspace archive does not match its snapshot manifest");
+}
+function assertWorkspaceFilesWithinLimits(files, limits) {
+	if (files.length > limits.maxFiles) throw new Error("candidate workspace exceeds maxFiles");
+	let totalBytes = 0;
+	let previousPath;
+	const observedPaths = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		const path = safeArchivePath(file.path, limits.maxPathBytes);
+		assertWorkspacePathOrder(path, previousPath, observedPaths, "candidate workspace paths must be unique and sorted");
+		previousPath = path;
+		if (!isWorkspaceFileMode(file.mode)) throw new Error(`candidate workspace file has unsupported mode: ${path}`);
+		if (file.bytes.byteLength > limits.maxFileBytes) throw new Error(`candidate workspace file exceeds maxFileBytes: ${path}`);
+		totalBytes += file.bytes.byteLength;
+		if (totalBytes > limits.maxTotalFileBytes) throw new Error("candidate workspace exceeds maxTotalFileBytes");
+	}
+}
+function normalizeWorkspaceFiles(input, limits) {
+	if (!Array.isArray(input)) throw new Error("candidate workspace files must be an array");
+	const fileCount = input.length;
+	if (fileCount > limits.maxFiles) throw new Error("candidate workspace exceeds maxFiles");
+	let totalBytes = 0;
+	const files = [];
+	for (let index = 0; index < fileCount; index++) {
+		const inputFile = input[index];
+		if (!isRecord(inputFile) || Object.keys(inputFile).sort().join(",") !== "bytes,mode,path") throw new Error(`candidate workspace file ${index} is invalid`);
+		const descriptors = Object.getOwnPropertyDescriptors(inputFile);
+		if (!("value" in (descriptors.path ?? {})) || !("value" in (descriptors.mode ?? {})) || !("value" in (descriptors.bytes ?? {}))) throw new Error(`candidate workspace file ${index} must use fixed values`);
+		const path = safeArchivePath(descriptors.path?.value, limits.maxPathBytes);
+		const mode = descriptors.mode?.value;
+		const inputBytes = descriptors.bytes?.value;
+		if (!isWorkspaceFileMode(mode)) throw new Error(`candidate workspace file has unsupported mode: ${path}`);
+		const view = inspectWorkspaceBytes(inputBytes, path);
+		if (view.byteLength > limits.maxFileBytes) throw new Error(`candidate workspace file exceeds maxFileBytes: ${path}`);
+		if (view.byteLength > limits.maxTotalFileBytes - totalBytes) throw new Error("candidate workspace exceeds maxTotalFileBytes");
+		if (view.byteLength > Math.max(0, limits.maxArchiveBytes - 1024)) throw new Error("candidate workspace archive exceeds maxArchiveBytes");
+		totalBytes += view.byteLength;
+		files.push({
+			path,
+			mode,
+			bytes: detachWorkspaceBytes(view)
+		});
+	}
+	files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+	assertWorkspaceFilesWithinLimits(files, limits);
+	return files;
+}
+function isWorkspaceFileMode(value) {
+	return Number.isSafeInteger(value) && value >= 0 && value <= 511;
+}
+function workspaceLimits(overrides) {
+	const limits = {
+		...defaultLimits,
+		...overrides
+	};
+	for (const [name, value] of Object.entries(limits)) if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`candidate workspace ${name} must be a positive safe integer`);
+	return Object.freeze(limits);
+}
+function safeArchivePath(value, maxPathBytes) {
+	if (typeof value !== "string" || !value || !isWellFormedUnicode(value) || Buffer.byteLength(value, "utf8") > maxPathBytes || isAbsolute(value) || win32.isAbsolute(value) || value.includes("\\") || value.includes("\0") || hasControlCharacter(value) || value.split("/").some((part) => !part || part === "." || part === "..") || [".git", ".sidecar"].includes(value.split("/")[0]?.toLowerCase() ?? "")) throw new Error(`candidate workspace archive contains an unsafe path: ${String(value)}`);
+	return value;
+}
+function assertWorkspacePathOrder(path, previousPath, observedPaths, errorMessage) {
+	if (previousPath !== void 0 && previousPath >= path) throw new Error(errorMessage);
+	for (let slash = path.indexOf("/"); slash !== -1; slash = path.indexOf("/", slash + 1)) if (observedPaths.has(path.slice(0, slash))) throw new Error(errorMessage);
+	observedPaths.add(path);
+}
+function inspectWorkspaceBytes(input, path) {
+	let buffer;
+	let byteOffset;
+	let byteLength;
+	try {
+		buffer = typedArrayBufferGetter.call(input);
+		byteOffset = typedArrayByteOffsetGetter.call(input);
+		byteLength = typedArrayByteLengthGetter.call(input);
+	} catch {
+		throw new Error(`candidate workspace file bytes are invalid: ${path}`);
+	}
+	if (isSharedArrayBuffer(buffer)) throw new Error(`candidate workspace file uses shared bytes: ${path}`);
+	if (!isAnyArrayBuffer(buffer)) throw new Error(`candidate workspace file bytes are invalid: ${path}`);
+	return {
+		buffer,
+		byteOffset,
+		byteLength
+	};
+}
+function detachWorkspaceBytes(input) {
+	const { buffer, byteOffset, byteLength } = input;
+	const copy = new Uint8Array(byteLength);
+	Uint8Array.prototype.set.call(copy, new Uint8Array(buffer, byteOffset, byteLength));
+	return copy;
+}
+function assertGitObjectId(value, label) {
+	if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(value)) throw new Error(`candidate repository ${label} is not a Git object id`);
+}
+function requireTypedArrayGetter(name) {
+	const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+	const getter = Object.getOwnPropertyDescriptor(typedArrayPrototype, name)?.get;
+	if (!getter) throw new Error(`typed array intrinsic ${name} accessor is unavailable`);
+	return getter;
+}
+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/git-materialize.ts
+async function verifyCandidateCode(code, repositories, patchBytes) {
+	if (code.kind === "disabled") return void 0;
+	const repositoryRoot = await verifiedRepositoryRoot(code.repository, repositories);
+	await assertCommitAndBaseTree(repositoryRoot, code.baseCommit, code.baseTree);
+	if (code.kind === "no-op") {
+		await assertSafeTree(repositoryRoot, code.baseTree);
+		return code.baseTree;
+	}
+	if (!patchBytes) throw new Error("git-patch candidate is missing verified patch bytes");
+	const temporary = await mkdtemp(join(tmpdir(), "agent-candidate-git-"));
+	try {
+		const indexFile = join(temporary, "index");
+		await runCandidateGit(repositoryRoot, ["read-tree", code.baseTree], void 0, { GIT_INDEX_FILE: indexFile });
+		await runCandidateGit(repositoryRoot, [
+			"apply",
+			"--cached",
+			"--binary",
+			"--whitespace=nowarn",
+			"-"
+		], patchBytes, { GIT_INDEX_FILE: indexFile });
+		const candidateTree = (await runCandidateGit(repositoryRoot, ["write-tree"], void 0, { GIT_INDEX_FILE: indexFile })).stdout.toString("utf8").trim();
+		if (candidateTree !== code.candidateTree) throw new Error(`git patch materialized tree ${candidateTree} does not match ${code.candidateTree}`);
+		await assertSafeTree(repositoryRoot, candidateTree);
+		return candidateTree;
+	} finally {
+		await rm(temporary, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function readCandidateGitHubResource(resource, repositories) {
+	const repositoryRoot = await verifiedRepositoryRoot(resource.repository, repositories);
+	if ((await runCandidateGit(repositoryRoot, [
+		"cat-file",
+		"-t",
+		resource.commit
+	])).stdout.toString("utf8").trim() !== "commit") throw new Error(`GitHub resource commit is not a commit object: ${resource.commit}`);
+	const listing = (await runCandidateGit(repositoryRoot, [
+		"ls-tree",
+		"-z",
+		resource.commit,
+		"--",
+		resource.path
+	])).stdout;
+	const entries = parseTreeEntries(listing);
+	if (entries.length !== 1 || entries[0]?.path !== resource.path) throw new Error(`GitHub resource path is not one exact file: ${resource.path}`);
+	const entry = entries[0];
+	if (entry?.type !== "blob" || entry.mode !== "100644" && entry.mode !== "100755") throw new Error(`GitHub resource path is not a regular Git blob: ${resource.path}`);
+	const bytes = (await runCandidateGit(repositoryRoot, [
+		"cat-file",
+		"blob",
+		entry.object
+	])).stdout;
+	verifyBytes(bytes, resource.sha256, resource.byteLength, `GitHub resource ${resource.path}`);
+	return Uint8Array.from(bytes);
+}
+async function verifyTaskCheckout(taskRoot, expected) {
+	const root = resolve(taskRoot);
+	const head = (await runCandidateGit(root, ["rev-parse", "HEAD"])).stdout.toString("utf8").trim();
+	if (head !== expected.baseCommit) throw new Error(`task checkout HEAD ${head} does not match ${expected.baseCommit}`);
+	const tree = (await runCandidateGit(root, ["rev-parse", "HEAD^{tree}"])).stdout.toString("utf8").trim();
+	if (tree !== expected.baseTree) throw new Error(`task checkout base tree ${tree} does not match ${expected.baseTree}`);
+}
+/**
+* Apply an evaluator-captured binary diff in a detached object database and
+* prove its result tree exactly matches the captured after-state manifest.
+*/
+async function verifyTaskOutcomePatch(input) {
+	const repositoryRoot = resolve(input.repositoryRoot);
+	await verifyTaskCheckout(repositoryRoot, input);
+	const gitDir = resolve((await runCandidateGit(repositoryRoot, ["rev-parse", "--absolute-git-dir"])).stdout.toString("utf8").trim());
+	if (await realpath(gitDir) !== gitDir || gitDir.includes(":")) throw new Error("task Git object store has an unsupported path");
+	await assertNoGitIndirection(repositoryRoot, gitDir, "task repository");
+	const temporary = await mkdtemp(join(tmpdir(), "agent-candidate-task-outcome-"));
+	try {
+		const objectDirectory = join(temporary, "objects");
+		const indexFile = join(temporary, "index");
+		await mkdir(objectDirectory);
+		const gitEnvironment = {
+			GIT_INDEX_FILE: indexFile,
+			GIT_OBJECT_DIRECTORY: objectDirectory,
+			GIT_ALTERNATE_OBJECT_DIRECTORIES: join(gitDir, "objects")
+		};
+		await runCandidateGit(repositoryRoot, ["read-tree", input.baseTree], void 0, gitEnvironment);
+		if (input.patch.byteLength > 0) await runCandidateGit(repositoryRoot, [
+			"apply",
+			"--cached",
+			"--binary",
+			"--whitespace=nowarn",
+			"-"
+		], input.patch, gitEnvironment);
+		const resultTree = (await runCandidateGit(repositoryRoot, ["write-tree"], void 0, gitEnvironment)).stdout.toString("utf8").trim();
+		if (resultTree !== input.resultTree) throw new Error(`task outcome patch materialized tree ${resultTree} does not match ${input.resultTree}`);
+		await assertSafeTree(repositoryRoot, resultTree, gitEnvironment);
+		const observed = await workspaceManifestFromGitTree(repositoryRoot, resultTree, gitEnvironment);
+		if (!Buffer.from(canonicalCandidateBytes$1(observed)).equals(Buffer.from(canonicalCandidateBytes$1(input.afterState)))) throw new Error("task outcome after-state does not match the materialized result tree");
+		const resultCommit = (await runCandidateGit(repositoryRoot, [
+			"commit-tree",
+			resultTree,
+			"-p",
+			input.baseCommit
+		], Buffer.from("candidate task outcome\n", "utf8"), {
+			...gitEnvironment,
+			GIT_AUTHOR_NAME: "Tangle Evaluator",
+			GIT_AUTHOR_EMAIL: "evaluator@tangle.tools",
+			GIT_AUTHOR_DATE: "2000-01-01T00:00:00Z",
+			GIT_COMMITTER_NAME: "Tangle Evaluator",
+			GIT_COMMITTER_EMAIL: "evaluator@tangle.tools",
+			GIT_COMMITTER_DATE: "2000-01-01T00:00:00Z"
+		})).stdout.toString("utf8").trim();
+		if ((await runCandidateGit(repositoryRoot, ["rev-parse", `${resultCommit}^{tree}`], void 0, gitEnvironment)).stdout.toString("utf8").trim() !== resultTree) throw new Error("task outcome evaluator commit does not bind the verified result tree");
+		return {
+			resultTree,
+			resultCommit
+		};
+	} finally {
+		await rm(temporary, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function verifiedRepositoryRoot(repository, repositories) {
+	const repositoryRoot = resolve(await repositories.resolve(repository));
+	if (!(await stat(repositoryRoot)).isDirectory()) throw new Error("candidate repository path is not a directory");
+	const origin = (await runCandidateGit(repositoryRoot, [
+		"remote",
+		"get-url",
+		"origin"
+	])).stdout.toString("utf8").trim();
+	const actual = parseGitHubRemote(origin);
+	if (!actual || actual.owner !== repository.owner || actual.repo !== repository.repo) throw new Error(`local repository origin ${origin || "<missing>"} does not match github.com/${repository.owner}/${repository.repo}`);
+	await assertNoGitIndirection(repositoryRoot, resolve((await runCandidateGit(repositoryRoot, ["rev-parse", "--absolute-git-dir"])).stdout.toString("utf8").trim()), "candidate repository");
+	return repositoryRoot;
+}
+async function assertNoGitIndirection(repositoryRoot, gitDir, label) {
+	if ((await runCandidateGit(repositoryRoot, [
+		"for-each-ref",
+		"--format=%(refname)",
+		"refs/replace"
+	])).stdout.toString("utf8").trim()) throw new Error(`${label} contains Git replace refs`);
+	const commonDir = await realpath(resolve(repositoryRoot, (await runCandidateGit(repositoryRoot, ["rev-parse", "--git-common-dir"])).stdout.toString("utf8").trim()));
+	if (commonDir.includes(":")) throw new Error(`${label} Git common directory has an unsupported path`);
+	for (const objectRoot of /* @__PURE__ */ new Set([gitDir, commonDir])) for (const name of ["alternates", "http-alternates"]) {
+		const path = join(objectRoot, "objects", "info", name);
+		try {
+			if ((await readFile(path, "utf8")).trim()) throw new Error(`${label} uses forbidden Git ${name}`);
+		} catch (error) {
+			if (!isNoEntry(error)) throw error;
+		}
+	}
+}
+async function assertCommitAndBaseTree(repositoryRoot, commit, expectedTree) {
+	if ((await runCandidateGit(repositoryRoot, [
+		"cat-file",
+		"-t",
+		commit
+	])).stdout.toString("utf8").trim() !== "commit") throw new Error(`candidate base object is not a commit: ${commit}`);
+	const actualTree = (await runCandidateGit(repositoryRoot, ["rev-parse", `${commit}^{tree}`])).stdout.toString("utf8").trim();
+	if (actualTree !== expectedTree) throw new Error(`candidate base commit tree ${actualTree} does not match ${expectedTree}`);
+}
+async function assertSafeTree(repositoryRoot, tree, environment = {}) {
 	const listing = (await runCandidateGit(repositoryRoot, [
 		"ls-tree",
 		"-rz",
@@ -1269,14 +1717,7 @@ function parseTreeEntries(bytes) {
 	});
 }
 function assertSafeGitPath(path) {
-	if (!path || path.startsWith("/") || path.includes("\\") || path.includes("\0") || hasControlCharacter$1(path) || path.split("/").some((part) => !part || part === "." || part === "..") || path.split("/")[0]?.toLowerCase() === ".git") throw new Error(`candidate Git tree contains an unsafe path: ${path}`);
-}
-function hasControlCharacter$1(value) {
-	for (let index = 0; index < value.length; index++) {
-		const code = value.charCodeAt(index);
-		if (code < 32 || code === 127) return true;
-	}
-	return false;
+	if (!path || path.startsWith("/") || path.includes("\\") || path.includes("\0") || hasControlCharacter(path) || path.split("/").some((part) => !part || part === "." || part === "..") || path.split("/")[0]?.toLowerCase() === ".git") throw new Error(`candidate Git tree contains an unsafe path: ${path}`);
 }
 function parseGitHubRemote(value) {
 	const match = value.match(/^(?:https?:\/\/github\.com\/|ssh:\/\/git@github\.com\/|git@github\.com:)([^/]+)\/([^/]+?)(?:\.git)?$/);
@@ -1371,91 +1812,21 @@ function isNoEntry(error) {
 	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 //#endregion
-//#region src/candidate-execution/output-artifacts.ts
-/** Persist evaluator evidence, read it back, and bind the returned locator to the exact bytes. */
-async function persistCandidateOutputArtifact(port, input) {
-	input.signal?.throwIfAborted();
-	const bytes = Uint8Array.from(input.bytes);
-	const expectedDigest = sha256Bytes$1(bytes);
-	const ref = agentCandidateArtifactRefSchema.parse(await port.put({
-		executionId: input.executionId,
-		purpose: input.purpose,
-		bytes: Uint8Array.from(bytes),
-		...input.signal ? { signal: input.signal } : {}
-	}));
-	input.signal?.throwIfAborted();
-	if (ref.sha256 !== expectedDigest || ref.byteLength !== bytes.byteLength) throw new Error("candidate output locator does not identify the submitted bytes");
-	const stored = await port.read(ref);
-	input.signal?.throwIfAborted();
-	verifyBytes(stored, expectedDigest, bytes.byteLength, "persisted candidate output");
-	return immutableCandidateValue(ref);
-}
-//#endregion
-//#region src/candidate-execution/workspace-archive.ts
-const archiveKind = "agent-candidate-workspace-archive";
-const workspaceEntryPrefix = "workspace/";
-const repositoryMetadataEntry = "metadata/repository.json";
-const repositoryBundleEntry = "metadata/repository.bundle";
-const repositoryIndexEntry = "metadata/repository.index.json";
-const repositoryIndexPrefix = "index/";
-const fixedTarTime = /* @__PURE__ */ new Date(0);
-const defaultLimits = Object.freeze({
-	maxArchiveBytes: 512 * 1024 * 1024,
-	maxEmbeddedArtifactBytes: 1024 * 1024,
-	maxFiles: 5e4,
-	maxFileBytes: 128 * 1024 * 1024,
-	maxTotalFileBytes: 256 * 1024 * 1024,
-	maxPathBytes: 4096,
-	maxRepositoryBundleBytes: 128 * 1024 * 1024
-});
+//#region src/candidate-execution/workspace-archive-local.ts
 /** Capture one exact regular-file workspace for immutable candidate execution. */
-async function captureAgentCandidateWorkspace(rootInput, options = {}) {
-	const root = resolve(rootInput);
-	const limits = workspaceLimits(options.limits);
-	if (options.repositoryContents !== void 0 && options.repositoryContents !== "head" && options.repositoryContents !== "working-tree") throw new Error("candidate repositoryContents is invalid");
-	if (options.repositoryContents !== void 0 && !options.includeRepository) throw new Error("candidate repositoryContents requires includeRepository");
-	const captured = options.includeRepository ? await captureRepository(root, limits, options.repositoryContents === "working-tree") : await captureMaterializedWorkspace(root, { limits: {
-		maxFiles: limits.maxFiles,
-		maxFileBytes: limits.maxFileBytes,
-		maxTotalFileBytes: limits.maxTotalFileBytes
-	} });
-	assertWorkspaceFilesWithinLimits(captured.files, limits);
-	const repository = "repository" in captured ? captured.repository : void 0;
-	return captureWorkspaceFiles(captured.files, repository, limits, options.artifactPersistence);
-}
-/** Capture detached files returned by a remote executor into the standard archive. */
-async function captureAgentCandidateWorkspaceFiles(input, options = {}) {
-	const limits = workspaceLimits(options.limits);
-	return captureWorkspaceFiles(normalizeWorkspaceFiles(input, limits), void 0, limits, options.artifactPersistence);
-}
-async function captureWorkspaceFiles(files, repository, limits, artifactPersistence) {
-	const material = candidateWorkspaceManifest(files);
-	const manifest = canonicalCandidateBytes$1(material);
-	const archive = await encodeWorkspaceArchive(files, repository, limits.maxArchiveBytes);
-	if (!artifactPersistence && (manifest.byteLength > limits.maxEmbeddedArtifactBytes || archive.byteLength > limits.maxEmbeddedArtifactBytes)) throw new Error("candidate workspace artifacts exceed maxEmbeddedArtifactBytes; artifactPersistence is required");
-	const manifestArtifact = await captureWorkspaceArtifact("manifest", manifest, artifactPersistence);
-	const archiveArtifact = await captureWorkspaceArtifact("archive", archive, artifactPersistence);
-	const snapshot = deepFreezeCandidate({
-		kind: "agent-candidate-workspace-snapshot",
-		digest: canonicalCandidateDigest$1(material),
-		material,
-		manifest: manifestArtifact,
-		archive: archiveArtifact
-	});
-	return Object.freeze({
-		snapshot,
-		archive
-	});
-}
-async function captureWorkspaceArtifact(kind, bytes, persistence) {
-	if (!persistence) return embeddedCandidateArtifact(bytes);
-	if (!persistence.executionId.trim()) throw new Error("candidate workspace artifact persistence requires an executionId");
-	return persistCandidateOutputArtifact(persistence.outputArtifacts, {
-		executionId: persistence.executionId,
-		purpose: kind === "manifest" ? "candidate-workspace-manifest" : "candidate-workspace-archive",
-		bytes,
-		...persistence.signal ? { signal: persistence.signal } : {}
-	});
+async function captureAgentCandidateWorkspace(rootInput, options = {}) {
+	const root = resolve(rootInput);
+	const limits = workspaceLimits(options.limits);
+	if (options.repositoryContents !== void 0 && options.repositoryContents !== "head" && options.repositoryContents !== "working-tree") throw new Error("candidate repositoryContents is invalid");
+	if (options.repositoryContents !== void 0 && !options.includeRepository) throw new Error("candidate repositoryContents requires includeRepository");
+	const captured = options.includeRepository ? await captureRepository(root, limits, options.repositoryContents === "working-tree") : await captureMaterializedWorkspace(root, { limits: {
+		maxFiles: limits.maxFiles,
+		maxFileBytes: limits.maxFileBytes,
+		maxTotalFileBytes: limits.maxTotalFileBytes
+	} });
+	assertWorkspaceFilesWithinLimits(captured.files, limits);
+	const repository = "repository" in captured ? captured.repository : void 0;
+	return captureWorkspaceFiles(captured.files, repository, limits, options.artifactPersistence);
 }
 /** Create the standard bounded materializer for candidate execution ports. */
 function createAgentCandidateWorkspacePort(options = {}) {
@@ -1495,20 +1866,6 @@ async function materializeAgentCandidateWorkspace(input) {
 		throw error;
 	}
 }
-/** Verify a portable archive before its source environment may be discarded. */
-async function verifyAgentCandidateWorkspaceArchive(input) {
-	await decodeVerifiedWorkspaceArchive({
-		...input,
-		limits: workspaceLimits(input.limits)
-	});
-}
-async function decodeVerifiedWorkspaceArchive(input) {
-	verifyBytes(input.archive, input.snapshot.archive.sha256, input.snapshot.archive.byteLength, "candidate workspace archive");
-	const decoded = await parseWorkspaceArchive(input.archive, input.limits);
-	if (decoded.repository && input.role !== "task") throw new Error("only task workspaces may carry a Git repository");
-	assertArchiveMatchesSnapshot(decoded.files, input.snapshot);
-	return decoded;
-}
 async function captureRepository(requestedRoot, limits, workingTree) {
 	const requestedStats = await lstat(requestedRoot);
 	if (!requestedStats.isDirectory() || requestedStats.isSymbolicLink()) throw new Error("candidate repository root must be a real directory");
@@ -1611,309 +1968,78 @@ async function readRepositoryWorkingState(root, limits) {
 		if (size > limits.maxFileBytes) throw new Error(`candidate Git index file exceeds maxFileBytes: ${entry.path}`);
 		if (size > limits.maxTotalFileBytes - totalBytes) throw new Error("candidate Git index exceeds maxTotalFileBytes");
 		totalBytes += size;
-		return size;
-	});
-	const files = [];
-	for (const [index, entry] of entries.entries()) {
-		const bytes = (await runCandidateGit(root, [
-			"cat-file",
-			"blob",
-			entry.object
-		], void 0, env, { maxOutputBytes: limits.maxFileBytes })).stdout;
-		if (bytes.byteLength !== byteLengths[index]) throw new Error("candidate Git index blob size changed");
-		files.push({
-			path: entry.path,
-			mode: entry.mode,
-			bytes: Uint8Array.from(bytes)
-		});
-	}
-	files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-	assertWorkspaceFilesWithinLimits(files, limits);
-	const defaultExcludes = join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "git", "ignore");
-	const excludes = new TextDecoder("utf-8", { fatal: true }).decode((await runCandidateGit(root, [
-		"config",
-		"--includes",
-		"--path",
-		"--default",
-		defaultExcludes,
-		"--get",
-		"core.excludesFile"
-	], void 0, {}, {
-		maxOutputBytes: limits.maxPathBytes,
-		readUserExclusions: true
-	})).stdout).replace(/\n$/u, "");
-	const paths = new TextDecoder("utf-8", { fatal: true }).decode((await runCandidateGit(root, [
-		"-c",
-		`core.excludesFile=${excludes}`,
-		"ls-files",
-		"--cached",
-		"--others",
-		"--exclude-standard",
-		"-z"
-	], void 0, env, { maxOutputBytes: listingLimit })).stdout);
-	for (const path of paths.split("\0").filter(Boolean)) safeArchivePath(path, limits.maxPathBytes);
-	return {
-		paths,
-		index,
-		files
-	};
-}
-async function captureRepositoryWorkingTree(root, limits) {
-	const state = await readRepositoryWorkingState(root, limits);
-	return {
-		state,
-		files: [...(await captureMaterializedWorkspace(root, {
-			ignoredProtectedRootEntries: [".git"],
-			selectedPaths: await existingRepositoryPaths(root, state.paths, limits),
-			limits
-		})).files].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)
-	};
-}
-async function existingRepositoryPaths(root, listing, limits) {
-	const paths = [...new Set(listing.split("\0").filter(Boolean))].sort();
-	if (paths.length > limits.maxFiles) throw new Error("candidate workspace exceeds maxFiles");
-	const selectedPaths = [];
-	for (const path of paths) {
-		const safe = safeArchivePath(path, limits.maxPathBytes);
-		try {
-			await lstat(workspacePath(root, safe));
-			selectedPaths.push(safe);
-		} catch (error) {
-			if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
-		}
-	}
-	return selectedPaths;
-}
-async function encodeWorkspaceArchive(files, repository, maxArchiveBytes) {
-	const archive = pack();
-	const output = collectStream(archive, maxArchiveBytes, "candidate workspace archive");
-	try {
-		await writeWorkspaceArchiveEntries(archive, files, repository);
-		archive.finalize();
-		return await output;
-	} catch (error) {
-		archive.destroy(error instanceof Error ? error : new Error(String(error)));
-		await output.catch(() => void 0);
-		throw error;
-	}
-}
-async function verifyCanonicalWorkspaceArchive(files, repository, expected, maxArchiveBytes) {
-	const archive = pack();
-	const comparison = streamEqualsBytes(archive, expected, maxArchiveBytes, "candidate workspace archive");
-	try {
-		await writeWorkspaceArchiveEntries(archive, files, repository);
-		archive.finalize();
-		if (!await comparison) throw new Error("candidate workspace tar is not canonical");
-	} catch (error) {
-		archive.destroy(error instanceof Error ? error : new Error(String(error)));
-		await comparison.catch(() => void 0);
-		throw error;
-	}
-}
-async function writeWorkspaceArchiveEntries(archive, files, repository) {
-	for (const file of files) await writeTarEntry(archive, `${workspaceEntryPrefix}${file.path}`, file.mode, file.bytes);
-	if (!repository) return;
-	const indexManifest = repository.workingTree ? canonicalCandidateBytes$1(candidateWorkspaceManifest(repository.workingTree.files)) : void 0;
-	const metadata = canonicalCandidateBytes$1({
-		kind: archiveKind,
-		headCommit: repository.headCommit,
-		headTree: repository.headTree,
-		bundle: {
-			sha256: repository.bundle.sha256,
-			byteLength: repository.bundle.byteLength
-		},
-		...indexManifest ? { workingTree: { indexManifest: {
-			sha256: sha256Bytes$1(indexManifest),
-			byteLength: indexManifest.byteLength
-		} } } : {}
-	});
-	await writeTarEntry(archive, repositoryMetadataEntry, 384, metadata);
-	await writeTarEntry(archive, repositoryBundleEntry, 384, repository.bundle.bytes);
-	if (repository.workingTree && indexManifest) {
-		await writeTarEntry(archive, repositoryIndexEntry, 384, indexManifest);
-		for (const file of repository.workingTree.files) await writeTarEntry(archive, `${repositoryIndexPrefix}${file.path}`, file.mode, file.bytes);
-	}
-}
-async function parseWorkspaceArchive(bytes, limits) {
-	if (bytes.byteLength > limits.maxArchiveBytes) throw new Error("candidate workspace archive exceeds maxArchiveBytes");
-	const parser = extract();
-	const files = [];
-	const observedEntryNames = /* @__PURE__ */ new Set();
-	const observedPaths = /* @__PURE__ */ new Set();
-	let totalBytes = 0;
-	let retainedEntryBytes = 0;
-	let previousPath;
-	let repositoryMetadata;
-	let repositoryBundle;
-	let repositoryIndex;
-	const indexFiles = [];
-	const indexPaths = /* @__PURE__ */ new Set();
-	let previousIndexPath;
-	let indexBytes = 0;
-	const decoded = (async () => {
-		for await (const entry of parser) {
-			const name = entry.header.name;
-			if (entry.header.type !== "file" || typeof name !== "string" || observedEntryNames.has(name)) throw new Error("candidate workspace tar contains an invalid entry");
-			observedEntryNames.add(name);
-			if (name.startsWith(workspaceEntryPrefix)) {
-				if (files.length >= limits.maxFiles) throw new Error("candidate workspace archive has an invalid file count");
-				const path = safeArchivePath(name.slice(10), limits.maxPathBytes);
-				if (!isWorkspaceFileMode(entry.header.mode)) throw new Error(`candidate workspace archive has an unsupported mode: ${path}`);
-				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
-				const fileBytes = await readTarEntry(entry, limits.maxFileBytes, `workspace file ${path}`);
-				retainedEntryBytes += fileBytes.byteLength;
-				assertWorkspacePathOrder(path, previousPath, observedPaths, "candidate workspace archive paths must be unique and sorted");
-				previousPath = path;
-				if (fileBytes.byteLength > limits.maxTotalFileBytes - totalBytes) throw new Error("candidate workspace archive exceeds maxTotalFileBytes");
-				totalBytes += fileBytes.byteLength;
-				files.push({
-					path,
-					mode: entry.header.mode,
-					bytes: fileBytes
-				});
-			} else if (name === repositoryMetadataEntry) {
-				if (entry.header.mode !== 384 || repositoryMetadata) throw new Error("candidate workspace archive repository metadata is invalid");
-				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
-				const metadataBytes = await readTarEntry(entry, limits.maxPathBytes, "candidate repository metadata");
-				retainedEntryBytes += metadataBytes.byteLength;
-				repositoryMetadata = parseRepositoryMetadata(metadataBytes, limits);
-			} else if (name === repositoryBundleEntry) {
-				if (entry.header.mode !== 384 || repositoryBundle) throw new Error("candidate workspace archive repository bundle is invalid");
-				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
-				repositoryBundle = await readTarEntry(entry, limits.maxRepositoryBundleBytes, "candidate Git bundle");
-				retainedEntryBytes += repositoryBundle.byteLength;
-			} else if (name === repositoryIndexEntry) {
-				if (entry.header.mode !== 384 || repositoryIndex) throw new Error("candidate workspace archive repository index is invalid");
-				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
-				repositoryIndex = await readTarEntry(entry, limits.maxArchiveBytes, "candidate Git index manifest");
-				retainedEntryBytes += repositoryIndex.byteLength;
-			} else if (name.startsWith(repositoryIndexPrefix)) {
-				if (!repositoryMetadata?.workingTree || !repositoryIndex || indexFiles.length >= limits.maxFiles) throw new Error("candidate Git index evidence is incomplete or exceeds maxFiles");
-				const path = safeArchivePath(name.slice(6), limits.maxPathBytes);
-				if (entry.header.mode !== 420 && entry.header.mode !== 493) throw new Error("candidate Git index contains an unsupported mode");
-				assertWorkspacePathOrder(path, previousIndexPath, indexPaths, "candidate Git index paths must be unique and sorted");
-				previousIndexPath = path;
-				assertRetainedArchiveSize(bytes.byteLength, retainedEntryBytes, entry.header.size, limits);
-				if (entry.header.size === void 0 || entry.header.size > limits.maxTotalFileBytes - indexBytes) throw new Error("candidate Git index exceeds maxTotalFileBytes");
-				if (entry.header.size > limits.maxFileBytes) throw new Error("candidate Git index exceeds maxFileBytes");
-				const fileBytes = await readTarEntry(entry, limits.maxFileBytes, `Git index file ${path}`);
-				retainedEntryBytes += fileBytes.byteLength;
-				indexBytes += fileBytes.byteLength;
-				indexFiles.push({
-					path,
-					mode: entry.header.mode,
-					bytes: fileBytes
-				});
-			} else throw new Error(`candidate workspace tar contains an unsupported entry: ${name}`);
-		}
-		if (Boolean(repositoryMetadata) !== Boolean(repositoryBundle)) throw new Error("candidate workspace archive repository evidence is incomplete");
-		if (Boolean(repositoryMetadata?.workingTree) !== Boolean(repositoryIndex)) throw new Error("candidate workspace archive repository index evidence is incomplete");
-		const repository = repositoryMetadata && repositoryBundle ? repositoryFromTar(repositoryMetadata, repositoryBundle, repositoryIndex, indexFiles) : void 0;
-		return {
-			files,
-			...repository ? { repository } : {}
-		};
-	})();
-	parser.end(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
-	const result = await decoded;
-	await verifyCanonicalWorkspaceArchive(result.files, result.repository, bytes, limits.maxArchiveBytes);
-	return result;
-}
-function assertRetainedArchiveSize(archiveBytes, retainedEntryBytes, entryBytes, limits) {
-	if (!Number.isSafeInteger(entryBytes) || entryBytes === void 0 || entryBytes < 0 || entryBytes > limits.maxArchiveBytes - archiveBytes - retainedEntryBytes) throw new Error("candidate workspace archive exceeds maxArchiveBytes while decoding");
-}
-function parseRepositoryMetadata(bytes, limits) {
-	let value;
-	try {
-		value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
-	} catch (error) {
-		throw new Error("candidate workspace archive repository metadata is invalid", { cause: error });
-	}
-	if (!isRecord$1(value) || !["bundle,headCommit,headTree,kind", "bundle,headCommit,headTree,kind,workingTree"].includes(Object.keys(value).sort().join(",")) || value.kind !== archiveKind || typeof value.headCommit !== "string" || typeof value.headTree !== "string" || !isRecord$1(value.bundle) || Object.keys(value.bundle).sort().join(",") !== "byteLength,sha256" || typeof value.bundle.sha256 !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.bundle.sha256) || !Number.isSafeInteger(value.bundle.byteLength) || value.bundle.byteLength <= 0 || value.bundle.byteLength > limits.maxRepositoryBundleBytes) throw new Error("candidate workspace archive repository is invalid");
-	if (!Buffer.from(canonicalCandidateBytes$1(value)).equals(Buffer.from(bytes))) throw new Error("candidate workspace archive repository metadata is not canonical");
-	assertGitObjectId(value.headCommit, "repository HEAD");
-	assertGitObjectId(value.headTree, "repository HEAD tree");
-	if (value.headCommit.length !== value.headTree.length) throw new Error("candidate repository HEAD and tree use different object formats");
-	let workingTree;
-	if ("workingTree" in value) {
-		const working = value.workingTree;
-		if (!isRecord$1(working) || Object.keys(working).join(",") !== "indexManifest" || !isRecord$1(working.indexManifest) || Object.keys(working.indexManifest).sort().join(",") !== "byteLength,sha256" || typeof working.indexManifest.sha256 !== "string" || !/^sha256:[a-f0-9]{64}$/.test(working.indexManifest.sha256) || !Number.isSafeInteger(working.indexManifest.byteLength) || working.indexManifest.byteLength < 0 || working.indexManifest.byteLength > limits.maxArchiveBytes) throw new Error("candidate workspace archive repository index is invalid");
-		workingTree = { indexManifest: {
-			sha256: working.indexManifest.sha256,
-			byteLength: working.indexManifest.byteLength
-		} };
+		return size;
+	});
+	const files = [];
+	for (const [index, entry] of entries.entries()) {
+		const bytes = (await runCandidateGit(root, [
+			"cat-file",
+			"blob",
+			entry.object
+		], void 0, env, { maxOutputBytes: limits.maxFileBytes })).stdout;
+		if (bytes.byteLength !== byteLengths[index]) throw new Error("candidate Git index blob size changed");
+		files.push({
+			path: entry.path,
+			mode: entry.mode,
+			bytes: Uint8Array.from(bytes)
+		});
 	}
+	files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+	assertWorkspaceFilesWithinLimits(files, limits);
+	const defaultExcludes = join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "git", "ignore");
+	const excludes = new TextDecoder("utf-8", { fatal: true }).decode((await runCandidateGit(root, [
+		"config",
+		"--includes",
+		"--path",
+		"--default",
+		defaultExcludes,
+		"--get",
+		"core.excludesFile"
+	], void 0, {}, {
+		maxOutputBytes: limits.maxPathBytes,
+		readUserExclusions: true
+	})).stdout).replace(/\n$/u, "");
+	const paths = new TextDecoder("utf-8", { fatal: true }).decode((await runCandidateGit(root, [
+		"-c",
+		`core.excludesFile=${excludes}`,
+		"ls-files",
+		"--cached",
+		"--others",
+		"--exclude-standard",
+		"-z"
+	], void 0, env, { maxOutputBytes: listingLimit })).stdout);
+	for (const path of paths.split("\0").filter(Boolean)) safeArchivePath(path, limits.maxPathBytes);
 	return {
-		kind: archiveKind,
-		headCommit: value.headCommit,
-		headTree: value.headTree,
-		bundle: {
-			sha256: value.bundle.sha256,
-			byteLength: value.bundle.byteLength
-		},
-		...workingTree ? { workingTree } : {}
+		paths,
+		index,
+		files
 	};
 }
-function repositoryFromTar(metadata, bundle, indexManifest, indexFiles) {
-	verifyBytes(bundle, metadata.bundle.sha256, metadata.bundle.byteLength, "candidate Git bundle");
-	if (metadata.workingTree && indexManifest) {
-		verifyBytes(indexManifest, metadata.workingTree.indexManifest.sha256, metadata.workingTree.indexManifest.byteLength, "candidate Git index manifest");
-		if (!Buffer.from(indexManifest).equals(Buffer.from(canonicalCandidateBytes$1(candidateWorkspaceManifest(indexFiles))))) throw new Error("candidate Git index files do not match the captured manifest");
-	}
+async function captureRepositoryWorkingTree(root, limits) {
+	const state = await readRepositoryWorkingState(root, limits);
 	return {
-		headCommit: metadata.headCommit,
-		headTree: metadata.headTree,
-		bundle: {
-			...metadata.bundle,
-			bytes: bundle
-		},
-		...metadata.workingTree && indexManifest ? { workingTree: { files: indexFiles } } : {}
+		state,
+		files: [...(await captureMaterializedWorkspace(root, {
+			ignoredProtectedRootEntries: [".git"],
+			selectedPaths: await existingRepositoryPaths(root, state.paths, limits),
+			limits
+		})).files].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)
 	};
 }
-async function writeTarEntry(archive, name, mode, bytes) {
-	await new Promise((resolveEntry, rejectEntry) => {
-		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) {
-	const size = entry.header.size;
-	if (!Number.isSafeInteger(size) || size === void 0 || size < 0 || size > maxBytes) throw new Error(`${label} has an invalid tar size`);
-	const bytes = await collectStream(entry, maxBytes, label);
-	if (bytes.byteLength !== size) throw new Error(`${label} differs from its tar size`);
-	return bytes;
-}
-async function collectStream(stream, maxBytes, label) {
-	const chunks = [];
-	let totalBytes = 0;
-	for await (const chunk of stream) {
-		if (!(chunk instanceof Uint8Array)) throw new Error(`${label} emitted a non-byte chunk`);
-		if (chunk.byteLength > maxBytes - totalBytes) {
-			const error = /* @__PURE__ */ new Error(`${label} exceeds its size limit`);
-			if ("destroy" in stream && typeof stream.destroy === "function") stream.destroy(error);
-			throw error;
-		}
-		const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		chunks.push(bytes);
-		totalBytes += bytes.byteLength;
-	}
-	return Buffer.concat(chunks, totalBytes);
-}
-async function streamEqualsBytes(stream, expected, maxBytes, label) {
-	const expectedBuffer = Buffer.from(expected.buffer, expected.byteOffset, expected.byteLength);
-	let equal = true;
-	let offset = 0;
-	for await (const chunk of stream) {
-		if (!(chunk instanceof Uint8Array)) throw new Error(`${label} emitted a non-byte chunk`);
-		if (chunk.byteLength > maxBytes - offset) {
-			const error = /* @__PURE__ */ new Error(`${label} exceeds its size limit`);
-			if ("destroy" in stream && typeof stream.destroy === "function") stream.destroy(error);
-			throw error;
+async function existingRepositoryPaths(root, listing, limits) {
+	const paths = [...new Set(listing.split("\0").filter(Boolean))].sort();
+	if (paths.length > limits.maxFiles) throw new Error("candidate workspace exceeds maxFiles");
+	const selectedPaths = [];
+	for (const path of paths) {
+		const safe = safeArchivePath(path, limits.maxPathBytes);
+		try {
+			await lstat(workspacePath(root, safe));
+			selectedPaths.push(safe);
+		} catch (error) {
+			if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
 		}
-		const observed = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-		if (offset + observed.byteLength > expectedBuffer.byteLength || !observed.equals(expectedBuffer.subarray(offset, offset + observed.byteLength))) equal = false;
-		offset += observed.byteLength;
 	}
-	return equal && offset === expectedBuffer.byteLength;
+	return selectedPaths;
 }
 async function prepareEmptyDestination(destination, options = {}) {
 	await mkdir(options.createDestination === false ? dirname(destination) : destination, {
@@ -2033,143 +2159,11 @@ async function materializeRepository(repository, destination, limits, signal) {
 		});
 	}
 }
-function assertArchiveMatchesSnapshot(files, snapshot) {
-	const material = candidateWorkspaceManifest(files);
-	const materialBytes = canonicalCandidateBytes$1(material);
-	verifyBytes(materialBytes, snapshot.manifest.sha256, snapshot.manifest.byteLength, "candidate workspace manifest");
-	if (canonicalCandidateDigest$1(material) !== snapshot.digest || !Buffer.from(materialBytes).equals(Buffer.from(canonicalCandidateBytes$1(snapshot.material)))) throw new Error("candidate workspace archive does not match its snapshot manifest");
-}
-function assertWorkspaceFilesWithinLimits(files, limits) {
-	if (files.length > limits.maxFiles) throw new Error("candidate workspace exceeds maxFiles");
-	let totalBytes = 0;
-	let previousPath;
-	const observedPaths = /* @__PURE__ */ new Set();
-	for (const file of files) {
-		const path = safeArchivePath(file.path, limits.maxPathBytes);
-		assertWorkspacePathOrder(path, previousPath, observedPaths, "candidate workspace paths must be unique and sorted");
-		previousPath = path;
-		if (!isWorkspaceFileMode(file.mode)) throw new Error(`candidate workspace file has unsupported mode: ${path}`);
-		if (file.bytes.byteLength > limits.maxFileBytes) throw new Error(`candidate workspace file exceeds maxFileBytes: ${path}`);
-		totalBytes += file.bytes.byteLength;
-		if (totalBytes > limits.maxTotalFileBytes) throw new Error("candidate workspace exceeds maxTotalFileBytes");
-	}
-}
-function normalizeWorkspaceFiles(input, limits) {
-	if (!Array.isArray(input)) throw new Error("candidate workspace files must be an array");
-	const fileCount = input.length;
-	if (fileCount > limits.maxFiles) throw new Error("candidate workspace exceeds maxFiles");
-	let totalBytes = 0;
-	const files = [];
-	for (let index = 0; index < fileCount; index++) {
-		const inputFile = input[index];
-		if (!isRecord$1(inputFile) || Object.keys(inputFile).sort().join(",") !== "bytes,mode,path") throw new Error(`candidate workspace file ${index} is invalid`);
-		const descriptors = Object.getOwnPropertyDescriptors(inputFile);
-		if (!("value" in (descriptors.path ?? {})) || !("value" in (descriptors.mode ?? {})) || !("value" in (descriptors.bytes ?? {}))) throw new Error(`candidate workspace file ${index} must use fixed values`);
-		const path = safeArchivePath(descriptors.path?.value, limits.maxPathBytes);
-		const mode = descriptors.mode?.value;
-		const inputBytes = descriptors.bytes?.value;
-		if (!isWorkspaceFileMode(mode)) throw new Error(`candidate workspace file has unsupported mode: ${path}`);
-		const view = inspectWorkspaceBytes(inputBytes, path);
-		if (view.byteLength > limits.maxFileBytes) throw new Error(`candidate workspace file exceeds maxFileBytes: ${path}`);
-		if (view.byteLength > limits.maxTotalFileBytes - totalBytes) throw new Error("candidate workspace exceeds maxTotalFileBytes");
-		if (view.byteLength > Math.max(0, limits.maxArchiveBytes - 1024)) throw new Error("candidate workspace archive exceeds maxArchiveBytes");
-		totalBytes += view.byteLength;
-		files.push({
-			path,
-			mode,
-			bytes: detachWorkspaceBytes(view)
-		});
-	}
-	files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
-	assertWorkspaceFilesWithinLimits(files, limits);
-	return files;
-}
-function isWorkspaceFileMode(value) {
-	return Number.isSafeInteger(value) && value >= 0 && value <= 511;
-}
-function workspaceLimits(overrides) {
-	const limits = {
-		...defaultLimits,
-		...overrides
-	};
-	for (const [name, value] of Object.entries(limits)) if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`candidate workspace ${name} must be a positive safe integer`);
-	return Object.freeze(limits);
-}
-function safeArchivePath(value, maxPathBytes) {
-	if (typeof value !== "string" || !value || !isWellFormedUnicode(value) || Buffer.byteLength(value, "utf8") > maxPathBytes || isAbsolute(value) || win32.isAbsolute(value) || value.includes("\\") || value.includes("\0") || hasControlCharacter(value) || value.split("/").some((part) => !part || part === "." || part === "..") || [".git", ".sidecar"].includes(value.split("/")[0]?.toLowerCase() ?? "")) throw new Error(`candidate workspace archive contains an unsafe path: ${String(value)}`);
-	return value;
-}
-function assertWorkspacePathOrder(path, previousPath, observedPaths, errorMessage) {
-	if (previousPath !== void 0 && previousPath >= path) throw new Error(errorMessage);
-	for (let slash = path.indexOf("/"); slash !== -1; slash = path.indexOf("/", slash + 1)) if (observedPaths.has(path.slice(0, slash))) throw new Error(errorMessage);
-	observedPaths.add(path);
-}
-function inspectWorkspaceBytes(input, path) {
-	let buffer;
-	let byteOffset;
-	let byteLength;
-	try {
-		buffer = typedArrayBufferGetter.call(input);
-		byteOffset = typedArrayByteOffsetGetter.call(input);
-		byteLength = typedArrayByteLengthGetter.call(input);
-	} catch {
-		throw new Error(`candidate workspace file bytes are invalid: ${path}`);
-	}
-	if (isSharedArrayBuffer(buffer)) throw new Error(`candidate workspace file uses shared bytes: ${path}`);
-	if (!isAnyArrayBuffer(buffer)) throw new Error(`candidate workspace file bytes are invalid: ${path}`);
-	return {
-		buffer,
-		byteOffset,
-		byteLength
-	};
-}
-function detachWorkspaceBytes(input) {
-	const { buffer, byteOffset, byteLength } = input;
-	const copy = new Uint8Array(byteLength);
-	Uint8Array.prototype.set.call(copy, new Uint8Array(buffer, byteOffset, byteLength));
-	return copy;
-}
 function workspacePath(root, relativePath) {
 	const path = resolve(root, relativePath);
 	if (!path.startsWith(`${root}${sep}`)) throw new Error(`candidate workspace archive path escapes its destination: ${relativePath}`);
 	return path;
 }
-function assertGitObjectId(value, label) {
-	if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(value)) throw new Error(`candidate repository ${label} is not a Git object id`);
-}
-function hasControlCharacter(value) {
-	for (let index = 0; index < value.length; index++) {
-		const code = value.charCodeAt(index);
-		if (code < 32 || code === 127) return true;
-	}
-	return false;
-}
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function requireTypedArrayGetter(name) {
-	const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
-	const getter = Object.getOwnPropertyDescriptor(typedArrayPrototype, name)?.get;
-	if (!getter) throw new Error(`typed array intrinsic ${name} accessor is unavailable`);
-	return getter;
-}
-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/workspace-streams.ts
 /**
@@ -2533,10 +2527,7 @@ function refuseNonPublicConfigValues(values, path, context) {
 function refuseSandboxProfileField(field, context = "candidate profile") {
 	throw new ValidationError(`${context} field ${field} is refused: Sandbox's Interface 4.0.0 cannot carry it yet, and Runtime does not drop it`);
 }
-function isRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 //#endregion
-export { isAsyncIterable as $, verifyMaterializedWorkspace as A, omitTopLevelDigest as B, candidateWorkspaceManifest as C, armDeadlineTimer as Ct, scanMaterializedWorkspaceManifest as D, singleFlightTeardown as Dt, readVerifiedArtifact as E, isDeadlineAbortReason as Et, canonicalCandidateDigest$1 as F, chargedTokens as G, verifyCanonicalCandidateDocument as H, canonicalCandidateDocument as I, deleteBoxSafe as J, cloneSpend as K, deepFreezeCandidate as L, markPutStreamVerified as M, verifiedArtifactChunks as N, verifyBytes as O, teardownExecutor as Ot, canonicalCandidateBytes$1 as P, isAbortError as Q, embeddedCandidateArtifact as R, artifactCacheKey as S, ROOT_DEADLINE_REASON as St, readMaterializedWorkspaceFiles as T, checkInIdleMs as Tt, addSpend as U, sha256Bytes$1 as V, addTokenUsage as W, fnv1a32Hex as X, errorMessage as Y, hasCompleteCacheBreakdown as Z, verifyTaskCheckout as _, ACCEPTED_RESULT_GRACE_MS as _t, materializeAgentCandidateWorkspaceFromArtifacts as a, sleep as at, isWellFormedUnicode as b, DEFAULT_CHECK_IN_IDLE_MS as bt, verifyAgentCandidateWorkspaceTree as c, throwIfAborted as ct, createAgentCandidateWorkspacePort as d, zeroSpend as dt, mapWithConcurrency as et, verifyAgentCandidateWorkspaceArchive as f, zeroTokenUsage as ft, verifyCandidateCode as g, withBudgetResources as gt, readCandidateGitHubResource as h, resourceTelemetry as ht, captureAgentCandidateWorkspaceTreeToArtifacts as i, roundBoxMinutes as it, verifyWorkspaceSnapshotArtifacts as j, verifyMaterializedProfileWorkspace as k, teardownSurfaces as kt, captureAgentCandidateWorkspace as l, unmeteredSpend as lt, persistCandidateOutputArtifact as m, assertResources as mt, refuseSandboxProfileField as n, randomSuffix as nt, readAgentCandidateWorkspaceArtifactFiles as o, stringifySafe as ot, workspaceLimits as p, addResourceSpend as pt, cloneTokenUsage as q, captureAgentCandidateWorkspaceToArtifacts as r, randomUuid as rt, verifyAgentCandidateWorkspaceArtifacts as s, throwAbort as st, assertSandboxProfileCompatibility as t, promptCacheTokenClasses as tt, captureAgentCandidateWorkspaceFiles as u, withTimeout as ut, verifyTaskOutcomePatch as v, CHILD_DEADLINE_REASON as vt, captureMaterializedWorkspace as w, boundedChildDeadlineAt as wt, WorkspaceScanLimitError as x, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as xt, assertExactObjectKeys as y, DEADLINE_CHECK_IN_MESSAGE as yt, immutableCandidateValue as z };
+export { hasCompleteCacheBreakdown as $, verifyMaterializedWorkspace as A, teardownSurfaces as At, omitTopLevelDigest as B, candidateWorkspaceManifest as C, ROOT_DEADLINE_REASON as Ct, scanMaterializedWorkspaceManifest as D, isDeadlineAbortReason as Dt, readVerifiedArtifact as E, checkInIdleMs as Et, canonicalCandidateDigest$1 as F, addSpend as G, verifyCanonicalCandidateDocument as H, canonicalCandidateDocument as I, cloneSpend as J, addTokenUsage as K, deepFreezeCandidate as L, markPutStreamVerified as M, verifiedArtifactChunks as N, verifyBytes as O, singleFlightTeardown as Ot, canonicalCandidateBytes$1 as P, fnv1a32Hex as Q, embeddedCandidateArtifact as R, artifactCacheKey as S, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as St, readMaterializedWorkspaceFiles as T, boundedChildDeadlineAt as Tt, hasControlCharacter as U, sha256Bytes$1 as V, abortError as W, deleteBoxSafe as X, cloneTokenUsage as Y, errorMessage as Z, workspaceLimits as _, resourceTelemetry as _t, materializeAgentCandidateWorkspaceFromArtifacts as a, randomUuid as at, isWellFormedUnicode as b, CHILD_DEADLINE_REASON as bt, verifyAgentCandidateWorkspaceTree as c, stringifySafe as ct, readCandidateGitHubResource as d, unmeteredSpend as dt, isAbortError as et, verifyCandidateCode as f, withTimeout as ft, verifyAgentCandidateWorkspaceArchive as g, assertResources as gt, captureAgentCandidateWorkspaceFiles as h, addResourceSpend as ht, captureAgentCandidateWorkspaceTreeToArtifacts as i, randomSuffix as it, verifyWorkspaceSnapshotArtifacts as j, verifyMaterializedProfileWorkspace as k, teardownExecutor as kt, captureAgentCandidateWorkspace as l, throwAbort as lt, verifyTaskOutcomePatch as m, zeroTokenUsage as mt, refuseSandboxProfileField as n, mapWithConcurrency as nt, readAgentCandidateWorkspaceArtifactFiles as o, roundBoxMinutes as ot, verifyTaskCheckout as p, zeroSpend as pt, chargedTokens as q, captureAgentCandidateWorkspaceToArtifacts as r, promptCacheTokenClasses as rt, verifyAgentCandidateWorkspaceArtifacts as s, sleep as st, assertSandboxProfileCompatibility as t, isAsyncIterable as tt, createAgentCandidateWorkspacePort as u, throwIfAborted as ut, persistCandidateOutputArtifact as v, withBudgetResources as vt, captureMaterializedWorkspace as w, armDeadlineTimer as wt, WorkspaceScanLimitError as x, DEADLINE_CHECK_IN_MESSAGE as xt, assertExactObjectKeys as y, ACCEPTED_RESULT_GRACE_MS as yt, immutableCandidateValue as z };
 
-//# sourceMappingURL=sandbox-profile-compat-QTkLe1Z6.js.map
+//# sourceMappingURL=sandbox-profile-compat-BzVBFqrz.js.map