@tangle-network/agent-runtime 0.293.4 → 0.295.0

package/dist/{runtime-10G-vbmJ.js → runtime-CXKCdGTg.js}

@@ -1,27 +1,28 @@
-import { Ai as writeAllBytes, Da as zeroSpend, Dn as runBrainLoop, Dt as rollingDispatch, En as routerBrain, Fa as armDeadlineTimer, Fn as createPushTraceSource, Ft as createWorktreeCliExecutor, G as settledToIteration, Gn as assertContentAddress, Hn as InMemoryResultBlobStore, Kn as encodeResultBlob, M as withDriverExecutor, Mt as createExecutor, Nt as createExecutorRegistry, O as verdictFromJudgeScore, Oi as prepareJsonlAppend, Or as contentAddress, Qi as detachedSnapshot, Sa as stringifySafe, Tn as readPromptOptions, Un as InMemorySpawnJournal, Wn as SpawnEventIndex, Xi as executableAgentSpecSnapshot, Yi as executableAgentProfileSnapshot, Zi as detachedFrozen, _ as CheckUnavailableError, _a as hasCompleteCacheBreakdown, ba as randomSuffix, bn as probeSandboxCapabilities, er as isTraceAnalysisStore, gn as defaultSelectWinner, ha as cloneSpend, ki as readCommittedJsonLines, la as notifySandboxEventObserver, ma as chargedTokens, pa as addSpend, qn as insideCursorNamespace, r as createSupervisor, va as isAbortError, vn as runAgentRounds, wn as assertBoxlessPromptOptions, xa as sleep, yn as createSandboxLineage } from "./supervisor-B-UbeBqD.js";
+import { Ai as writeAllBytes, Da as zeroSpend, Dn as runBrainLoop, Dt as rollingDispatch, En as routerBrain, Fa as armDeadlineTimer, Fn as createPushTraceSource, Ft as createWorktreeCliExecutor, G as settledToIteration, Gn as assertContentAddress, Hn as InMemoryResultBlobStore, Kn as encodeResultBlob, M as withDriverExecutor, Mt as createExecutor, Nt as createExecutorRegistry, O as verdictFromJudgeScore, Oi as prepareJsonlAppend, Or as contentAddress, Qi as detachedSnapshot, Sa as stringifySafe, Tn as readPromptOptions, Un as InMemorySpawnJournal, Wn as SpawnEventIndex, Xi as executableAgentSpecSnapshot, Yi as executableAgentProfileSnapshot, Zi as detachedFrozen, _ as CheckUnavailableError, _a as hasCompleteCacheBreakdown, ba as randomSuffix, bn as probeSandboxCapabilities, er as isTraceAnalysisStore, gn as defaultSelectWinner, ha as cloneSpend, ki as readCommittedJsonLines, la as notifySandboxEventObserver, ma as chargedTokens, pa as addSpend, qn as insideCursorNamespace, r as createSupervisor, va as isAbortError, vn as runAgentRounds, wn as assertBoxlessPromptOptions, xa as sleep, yn as createSandboxLineage } from "./supervisor-Da7iAPSw.js";
 import { i as ConfigError, m as ValidationError, n as AnalystError, s as PlannerError } from "./errors-DodWX-cb.js";
-import { Q as sample, X as refine, Z as runAgentic, c as reconcileInterruptedSearchCalls, ct as strategyAuthorMethod, et as ObservationError, it as profileChatClient, nt as observe, o as dedicatedLane, r as runtimeShipDecision, rt as renderReport, u as searchExecutor } from "./search-method-3EtnGKdL.js";
+import { Q as sample, X as refine, Z as runAgentic, c as reconcileInterruptedSearchCalls, ct as strategyAuthorMethod, et as ObservationError, it as profileChatClient, nt as observe, o as dedicatedLane, r as runtimeShipDecision, rt as renderReport, u as searchExecutor } from "./search-method-B0VM-hHV.js";
 import { c as profileModelExecutionSettings, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, p as canonicalObservedModelParts, t as assertExecutableAgentProfile } from "./model-policy-DydyWTQg.js";
-import { A as sha256Bytes$1, O as immutableCandidateValue, f as WorkspaceScanLimitError, h as captureMaterializedWorkspace, w as canonicalCandidateDigest$1 } from "./workspace-archive-MhowMCmp.js";
+import { D as canonicalCandidateDigest$1, N as sha256Bytes$1, h as WorkspaceScanLimitError, j as immutableCandidateValue, v as captureMaterializedWorkspace } from "./workspace-streams-D4TMTrJV.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction-DylCC_ot.js";
-import { S as foldCoordinationRecords, y as createInMemoryRunContext } from "./coordination-driver-BpEJv7GR.js";
-import { C as gateOnDeliverable, r as supervise, w as mapExecutorResult } from "./supervise-Cu0yOTkc.js";
+import { S as foldCoordinationRecords, y as createInMemoryRunContext } from "./coordination-driver-Do3g6Qif.js";
+import { C as gateOnDeliverable, r as supervise, w as mapExecutorResult } from "./supervise-BwfqpTVR.js";
 import "./run-layout-DSCWdbX2.js";
-import "./provision-supervisor-CIwZLCGR.js";
-import "./delegate-DEP51NR7.js";
-import "./graph-oFWfYVpn.js";
+import "./provision-supervisor-B_3hmSz6.js";
+import "./delegate-CCaU8M4O.js";
+import "./graph-dNmpMnzl.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, sha256Bytes, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { CODING_HARNESSES, DEFAULT_TRACE_ANALYST_KINDS, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, createTraceAnalyst, expandProfileAxes, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { createAgentRunOutcomeTracker } from "@tangle-network/sandbox/runtime";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash, createHmac, randomUUID } from "node:crypto";
 import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
 import { appendFileSync, chmodSync, constants, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readlinkSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { chmod, link, lstat, mkdir, mkdtemp, open, opendir, readFile, readdir, readlink, realpath, rm, stat, symlink, unlink, writeFile } from "node:fs/promises";
+import { chmod, link, lstat, mkdir, mkdtemp, open, opendir, readFile, readdir, readlink, realpath, rename, rm, stat, symlink, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { isDeepStrictEqual, promisify } from "node:util";
 import { redact } from "@tangle-network/agent-eval/traces";
+import { Readable } from "node:stream";
 import { collectAgentResponseText } from "@tangle-network/sandbox";
 import { SearchRecorder, asha, beam, createRunCostLedger, estimateNode, fsCampaignStorage, openSearchLedger, renderSearchSummary, runProfileMatrix, runSearch, searchClaimReserveUsd, searchModelIdentity, surfaceDiff } from "@tangle-network/agent-eval/campaign";
 import { defineEvaluationClaim, summarizeEvaluationUnits } from "@tangle-network/agent-eval/experiment";
@@ -4960,8 +4961,12 @@ function requireSpend(rolled, id, root) {
 }
 //#endregion
 //#region src/runtime/private-cas.ts
-const DIGEST = /^sha256:([0-9a-f]{64})$/u;
+const DIGEST$1 = /^sha256:([0-9a-f]{64})$/u;
+const HEX = /^[0-9a-f]{64}$/u;
+const SHARD = /^[0-9a-f]{2}$/u;
 const SAFE_NAMESPACE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/u;
+const RECEIPT_SCHEMA = "agent-runtime.private-cas-durable-receipt.v1";
+const DURABLE_ATTEMPTS = 3;
 async function realDirectory(path) {
 	const entry = await lstat(path);
 	if (!entry.isDirectory() || entry.isSymbolicLink()) throw new Error(`private CAS directory is not a real directory: ${path}`);
@@ -4980,21 +4985,364 @@ async function checkDirectories(path, create) {
 		await realDirectory(current);
 	}
 }
-/** Private host-local content-addressed storage scoped to one recorded run identity. */
-function createPrivateCasArtifactPort(root, namespace) {
+const missing = (error) => error?.code === "ENOENT";
+const message = (error) => error instanceof Error ? error.message : String(error);
+const sha256 = (bytes) => `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+async function syncDirectory(directory) {
+	const handle = await open(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+	try {
+		await handle.sync();
+	} finally {
+		await handle.close();
+	}
+}
+/** Read one local object, or undefined when the host no longer holds it. */
+async function readLocal(path) {
+	let file;
+	try {
+		file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+	} catch (error) {
+		if (missing(error)) return void 0;
+		throw error;
+	}
+	try {
+		return await file.readFile();
+	} finally {
+		await file.close();
+	}
+}
+/**
+* Private content-addressed storage scoped to one recorded run identity.
+*
+* Bytes are written to the host first. With a durable store, every object is also copied off the
+* host as it is written, and `localBudgetBytes` bounds what the host keeps: an object's local copy
+* is deleted only after its durable receipt exists, and reads fall back to the durable store.
+*/
+function createPrivateCasArtifactPort(root, namespace, options = {}) {
 	if (!isAbsolute(root)) throw new Error("private CAS root must be absolute");
 	if (!SAFE_NAMESPACE.test(namespace) || namespace === "." || namespace === "..") throw new Error("private CAS namespace must be one safe identifier");
+	const { durable, localBudgetBytes } = options;
+	if (localBudgetBytes !== void 0 && (durable === void 0 || !Number.isSafeInteger(localBudgetBytes) || localBudgetBytes < 0)) throw new Error("private CAS localBudgetBytes needs a durable store and a non-negative integer");
 	const store = join(resolve(root), "sha256");
-	const destination = (digest) => {
-		const match = DIGEST.exec(digest);
+	const receipts = join(resolve(root), "durable", "sha256");
+	const hexOf = (digest) => {
+		const match = DIGEST$1.exec(digest);
 		if (!match) throw new Error("private CAS digest must be sha256:<64 lowercase hex>");
-		return join(store, match[1].slice(0, 2), match[1]);
+		return match[1];
+	};
+	const destination = (digest) => {
+		const hex = hexOf(digest);
+		return join(store, hex.slice(0, 2), hex);
+	};
+	const hasReceipt = async (hex) => {
+		try {
+			return (await lstat(join(receipts, hex))).isFile();
+		} catch (error) {
+			if (missing(error)) return false;
+			throw error;
+		}
+	};
+	const writeReceipt = async (digest, byteLength) => {
+		await checkDirectories(receipts, true);
+		const hex = hexOf(digest);
+		const temporary = join(receipts, `.${hex}.${randomUUID()}.tmp`);
+		const file = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+		try {
+			await file.writeFile(`${JSON.stringify({
+				schema: RECEIPT_SCHEMA,
+				location: durable.location,
+				namespace,
+				digest,
+				byteLength,
+				storedAt: (/* @__PURE__ */ new Date()).toISOString()
+			})}\n`);
+			await file.sync();
+		} finally {
+			await file.close();
+		}
+		await rename(temporary, join(receipts, hex));
+		await syncDirectory(receipts);
+	};
+	const storeDurably = async (digest, bytes, signal) => {
+		let failure;
+		for (let attempt = 1; attempt <= DURABLE_ATTEMPTS; attempt++) {
+			signal?.throwIfAborted();
+			try {
+				await durable.put({
+					namespace,
+					digest,
+					bytes,
+					...signal === void 0 ? {} : { signal }
+				});
+				await writeReceipt(digest, bytes.byteLength);
+				return;
+			} catch (error) {
+				failure = error;
+				if (signal?.aborted) throw error;
+				if (attempt < DURABLE_ATTEMPTS) await new Promise((settle) => setTimeout(settle, 1e3 * 4 ** (attempt - 1)));
+			}
+		}
+		throw failure;
 	};
+	const localObjects = async () => {
+		let shards;
+		try {
+			shards = await readdir(store);
+		} catch (error) {
+			if (missing(error)) return [];
+			throw error;
+		}
+		const objects = [];
+		for (const shard of shards.filter((name) => SHARD.test(name))) for (const hex of await readdir(join(store, shard))) {
+			if (!HEX.test(hex) || hex.slice(0, 2) !== shard) continue;
+			const path = join(store, shard, hex);
+			try {
+				const entry = await lstat(path);
+				if (entry.isFile()) objects.push({
+					hex,
+					path,
+					size: entry.size,
+					modifiedMs: entry.mtimeMs
+				});
+			} catch (error) {
+				if (!missing(error)) throw error;
+			}
+		}
+		return objects;
+	};
+	const sweep = async (signal) => {
+		const objects = await localObjects();
+		const pending = [];
+		let uploaded = 0;
+		let refusal;
+		const durableHex = /* @__PURE__ */ new Set();
+		for (const object of objects) {
+			if (await hasReceipt(object.hex)) {
+				durableHex.add(object.hex);
+				continue;
+			}
+			if (durable === void 0) continue;
+			const digest = `sha256:${object.hex}`;
+			if (refusal !== void 0) {
+				pending.push({
+					digest,
+					error: `not attempted after an earlier refusal: ${refusal}`
+				});
+				continue;
+			}
+			try {
+				if (durable.putStream && durable.getStream) {
+					const ref = {
+						locator: {
+							kind: "private-cas",
+							namespace,
+							digest
+						},
+						sha256: digest,
+						byteLength: object.size
+					};
+					let failure;
+					for (let attempt = 1; attempt <= DURABLE_ATTEMPTS; attempt++) {
+						signal?.throwIfAborted();
+						const chunks = readObject(object.path, ref, signal);
+						try {
+							await durable.putStream({
+								namespace,
+								digest,
+								byteLength: object.size,
+								chunks,
+								signal
+							});
+							await writeReceipt(digest, object.size);
+							failure = void 0;
+							break;
+						} catch (error) {
+							failure = error;
+							if (signal?.aborted) throw error;
+							if (attempt < DURABLE_ATTEMPTS) await new Promise((settle) => setTimeout(settle, 1e3 * 4 ** (attempt - 1)));
+						} finally {
+							await chunks.return(void 0);
+						}
+					}
+					if (failure !== void 0) throw failure;
+				} else {
+					const bytes = await readLocal(object.path);
+					if (bytes === void 0) continue;
+					if (sha256(bytes) !== digest) {
+						pending.push({
+							digest,
+							error: "local object failed digest verification; it stays on the host"
+						});
+						continue;
+					}
+					await storeDurably(digest, bytes, signal);
+				}
+				durableHex.add(object.hex);
+				uploaded++;
+			} catch (error) {
+				if (signal?.aborted) throw error;
+				refusal = message(error);
+				pending.push({
+					digest,
+					error: refusal
+				});
+			}
+		}
+		let localBytes = objects.reduce((total, object) => total + object.size, 0);
+		let evicted = 0;
+		if (localBudgetBytes !== void 0) for (const object of [...objects].sort((a, b) => a.modifiedMs - b.modifiedMs)) {
+			if (localBytes <= localBudgetBytes) break;
+			if (!durableHex.has(object.hex) || !await hasReceipt(object.hex)) continue;
+			try {
+				await unlink(object.path);
+			} catch (error) {
+				if (!missing(error)) throw error;
+			}
+			localBytes -= object.size;
+			evicted++;
+		}
+		let receiptCount = 0;
+		try {
+			receiptCount = (await readdir(receipts)).filter((name) => HEX.test(name)).length;
+		} catch (error) {
+			if (!missing(error)) throw error;
+		}
+		return {
+			durable: receiptCount,
+			uploaded,
+			pending,
+			evicted,
+			localObjects: objects.length - evicted,
+			localBytes
+		};
+	};
+	let passes = Promise.resolve();
+	const offload = (signal) => {
+		const pass = passes.then(() => sweep(signal));
+		passes = pass.catch(() => void 0);
+		return pass;
+	};
+	const verified = (bytes, ref) => {
+		if (sha256(bytes) !== ref.sha256 || bytes.byteLength !== ref.byteLength) throw new Error("private CAS object failed digest or length verification");
+		return bytes;
+	};
+	async function* readStream(ref, options = {}) {
+		const { signal } = options;
+		signal?.throwIfAborted();
+		if (ref.locator.kind !== "private-cas" || ref.locator.namespace !== namespace || ref.locator.digest !== ref.sha256) throw new Error("private CAS locator does not match its digest and namespace");
+		const path = destination(ref.sha256);
+		try {
+			await checkDirectories(join(store, hexOf(ref.sha256).slice(0, 2)), false);
+			yield* readObject(path, ref, signal);
+			return;
+		} catch (error) {
+			if (!missing(error)) throw error;
+		}
+		if (!durable?.getStream) throw new Error(`private CAS object is not on this host; streaming durable reads are unavailable: ${ref.sha256}`);
+		const chunks = await durable.getStream({
+			namespace,
+			digest: ref.sha256,
+			signal
+		});
+		if (!chunks) throw new Error(`private CAS object is neither on this host nor in ${durable.location}: ${ref.sha256}`);
+		yield* checkedChunks(chunks, ref, signal);
+	}
+	async function* readObject(path, ref, signal) {
+		signal?.throwIfAborted();
+		const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+		try {
+			const stats = await file.stat();
+			if (!stats.isFile() || stats.size !== ref.byteLength) throw new Error("private CAS object failed digest or length verification");
+			yield* checkedChunks(file.createReadStream({
+				autoClose: false,
+				highWaterMark: 64 * 1024
+			}), ref, signal);
+		} finally {
+			await file.close();
+		}
+	}
+	async function* checkedChunks(chunks, ref, signal) {
+		const hash = createHash("sha256");
+		let byteLength = 0;
+		for await (const chunk of chunks) {
+			signal?.throwIfAborted();
+			if (!(chunk instanceof Uint8Array)) throw new Error("private CAS emitted a non-byte chunk");
+			byteLength += chunk.byteLength;
+			if (byteLength > ref.byteLength) throw new Error("private CAS object failed digest or length verification");
+			hash.update(chunk);
+			yield chunk;
+		}
+		signal?.throwIfAborted();
+		if (`sha256:${hash.digest("hex")}` !== ref.sha256 || byteLength !== ref.byteLength) throw new Error("private CAS object failed digest or length verification");
+	}
+	async function putStream(input) {
+		const { signal } = input;
+		signal?.throwIfAborted();
+		await checkDirectories(store, true);
+		const temporary = join(store, `.${randomUUID()}.tmp`);
+		try {
+			const file = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+			const hash = createHash("sha256");
+			let byteLength = 0;
+			try {
+				for await (const chunk of input.chunks) {
+					signal?.throwIfAborted();
+					if (!(chunk instanceof Uint8Array)) throw new Error("private CAS received a non-byte chunk");
+					hash.update(chunk);
+					byteLength += chunk.byteLength;
+					if (!Number.isSafeInteger(byteLength)) throw new Error("private CAS object is too large");
+					await file.writeFile(chunk);
+				}
+				signal?.throwIfAborted();
+				await file.sync();
+			} finally {
+				await file.close();
+			}
+			const sha = hash.digest("hex");
+			const digest = `sha256:${sha}`;
+			const ref = {
+				locator: {
+					kind: "private-cas",
+					namespace,
+					digest
+				},
+				sha256: digest,
+				byteLength
+			};
+			for await (const _chunk of readObject(temporary, ref, signal));
+			const path = destination(digest);
+			const directory = join(store, sha.slice(0, 2));
+			await checkDirectories(directory, true);
+			signal?.throwIfAborted();
+			try {
+				await link(temporary, path);
+			} catch (error) {
+				if (error.code !== "EEXIST") throw error;
+				for await (const _chunk of readStream(ref, { signal }));
+			}
+			const dir = await open(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+			try {
+				await dir.sync();
+			} finally {
+				await dir.close();
+			}
+			if (durable !== void 0) await offload(signal);
+			return ref;
+		} finally {
+			await unlink(temporary).catch((error) => {
+				if (error.code !== "ENOENT") throw error;
+			});
+		}
+	}
 	const port = {
+		...durable === void 0 || durable.putStream && durable.getStream ? {
+			putStream,
+			readStream
+		} : {},
 		async put({ bytes, signal }) {
 			signal?.throwIfAborted();
-			const sha = createHash("sha256").update(bytes).digest("hex");
-			const digest = `sha256:${sha}`;
+			const digest = sha256(bytes);
+			const sha = hexOf(digest);
 			const path = destination(digest);
 			const directory = join(store, sha.slice(0, 2));
 			await checkDirectories(directory, true);
@@ -5013,12 +5361,7 @@ function createPrivateCasArtifactPort(root, namespace) {
 				} catch (error) {
 					if (error.code !== "EEXIST") throw error;
 				}
-				const dir = await open(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-				try {
-					await dir.sync();
-				} finally {
-					await dir.close();
-				}
+				await syncDirectory(directory);
 			} finally {
 				await unlink(temporary).catch(() => void 0);
 			}
@@ -5032,21 +5375,33 @@ function createPrivateCasArtifactPort(root, namespace) {
 				byteLength: bytes.byteLength
 			};
 			await port.read(ref);
+			if (durable !== void 0) {
+				if (!await hasReceipt(sha)) await storeDurably(digest, bytes, signal).catch(() => void 0);
+				await offload(signal);
+			}
 			return ref;
 		},
 		async read(ref) {
 			if (ref.locator.kind !== "private-cas" || ref.locator.namespace !== namespace || ref.locator.digest !== ref.sha256) throw new Error("private CAS locator does not match its digest and namespace");
 			const path = destination(ref.sha256);
-			await checkDirectories(join(store, DIGEST.exec(ref.sha256)[1].slice(0, 2)), false);
-			const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+			const shard = join(store, hexOf(ref.sha256).slice(0, 2));
+			let local;
 			try {
-				const bytes = await file.readFile();
-				if (`sha256:${createHash("sha256").update(bytes).digest("hex")}` !== ref.sha256 || bytes.byteLength !== ref.byteLength) throw new Error("private CAS object failed digest or length verification");
-				return bytes;
-			} finally {
-				await file.close();
+				await checkDirectories(shard, false);
+				local = await readLocal(path);
+			} catch (error) {
+				if (!missing(error)) throw error;
 			}
-		}
+			if (local !== void 0) return verified(local, ref);
+			if (durable === void 0) throw new Error(`private CAS object is not on this host: ${ref.sha256}`);
+			const stored = await durable.get({
+				namespace,
+				digest: ref.sha256
+			});
+			if (stored === void 0) throw new Error(`private CAS object is neither on this host nor in ${durable.location}: ${ref.sha256}`);
+			return verified(stored, ref);
+		},
+		offload
 	};
 	return port;
 }
@@ -5265,6 +5620,192 @@ function printBenchmarkReport(report) {
 	}
 }
 //#endregion
+//#region src/runtime/s3-private-cas-store.ts
+const DIGEST = /^sha256:([0-9a-f]{64})$/u;
+const BUCKET = /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/u;
+const PREFIX = /^(?:[A-Za-z0-9._-]+\/)*$/u;
+const NAMESPACE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/u;
+const EMPTY_PAYLOAD = createHash("sha256").update("").digest("hex");
+const CONTENT_TYPE = "application/octet-stream";
+const METADATA_DIGEST = "x-amz-meta-sha256";
+const hex = (value) => createHash("sha256").update(value).digest("hex");
+const hmac = (key, value) => createHmac("sha256", key).update(value).digest();
+const encode = (segment) => encodeURIComponent(segment).replace(/[!'()*]/gu, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`);
+/**
+* Durable private CAS bytes in one S3-compatible bucket under `<prefix><namespace>/sha256/<hex>`.
+*
+* Every write declares its SHA-256 as the signed payload hash, so the store refuses bytes that
+* do not match the digest. A write is confirmed by reading back the object's length and digest
+* metadata. Reads return raw bytes; the private CAS port verifies them.
+*/
+function createS3PrivateCasStore(options) {
+	const endpoint = new URL(options.endpoint);
+	if (endpoint.protocol !== "https:" || endpoint.username || endpoint.password || endpoint.search || endpoint.hash || endpoint.pathname !== "/" && endpoint.pathname !== "") throw new Error("S3 private CAS endpoint must be a bare https origin");
+	if (!BUCKET.test(options.bucket)) throw new Error("S3 private CAS bucket name is invalid");
+	const prefix = options.prefix ?? "";
+	if (!PREFIX.test(prefix)) throw new Error("S3 private CAS prefix must be empty or end in /");
+	if (!options.accessKeyId || !options.secretAccessKey) throw new Error("S3 private CAS needs an access key id and secret");
+	const region = options.region ?? "auto";
+	const timeoutMs = options.timeoutMs ?? 12e4;
+	const send = options.fetch ?? fetch;
+	const key = (namespace, digest) => {
+		if (!NAMESPACE.test(namespace)) throw new Error("S3 private CAS namespace is invalid");
+		const match = DIGEST.exec(digest);
+		if (!match) throw new Error("S3 private CAS digest must be sha256:<64 lowercase hex>");
+		return `${prefix}${namespace}/sha256/${match[1]}`;
+	};
+	const request = async (method, objectKey, { body, byteLength, payloadHash = EMPTY_PAYLOAD, headers = {}, signal } = {}) => {
+		const path = `/${[options.bucket, ...objectKey.split("/")].map(encode).join("/")}`;
+		const url = new URL(path, endpoint);
+		const amzDate = (/* @__PURE__ */ new Date()).toISOString().replace(/[:-]|\.\d{3}/gu, "");
+		const day = amzDate.slice(0, 8);
+		const signed = {
+			host: url.host,
+			"x-amz-content-sha256": payloadHash,
+			"x-amz-date": amzDate,
+			...Object.fromEntries(Object.entries(headers).map(([name, value]) => [name.toLowerCase(), value]))
+		};
+		const names = Object.keys(signed).sort();
+		const canonical = [
+			method,
+			path,
+			"",
+			names.map((name) => `${name}:${signed[name].trim()}\n`).join(""),
+			names.join(";"),
+			payloadHash
+		].join("\n");
+		const scope = `${day}/${region}/s3/aws4_request`;
+		const signature = createHmac("sha256", hmac(hmac(hmac(hmac(`AWS4${options.secretAccessKey}`, day), region), "s3"), "aws4_request")).update([
+			"AWS4-HMAC-SHA256",
+			amzDate,
+			scope,
+			hex(canonical)
+		].join("\n")).digest("hex");
+		const { host: _host, ...sent } = signed;
+		const deadline = AbortSignal.timeout(timeoutMs + Math.ceil((byteLength ?? (body instanceof Uint8Array ? body.byteLength : 0)) / (1024 * 1024)) * 1e3);
+		return await send(url, {
+			method,
+			headers: {
+				...sent,
+				authorization: `AWS4-HMAC-SHA256 Credential=${options.accessKeyId}/${scope}, SignedHeaders=${names.join(";")}, Signature=${signature}`
+			},
+			...body === void 0 ? {} : { body },
+			...body instanceof ReadableStream ? { duplex: "half" } : {},
+			signal: signal === void 0 ? deadline : AbortSignal.any([signal, deadline])
+		});
+	};
+	const refusal = async (response, action) => {
+		const reader = response.body?.getReader();
+		let detail = "";
+		try {
+			while (reader && detail.length < 300) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				detail += new TextDecoder().decode(value.subarray(0, 300));
+			}
+		} catch {} finally {
+			await reader?.cancel().catch(() => void 0);
+		}
+		detail = detail.replace(/\s+/gu, " ").slice(0, 300);
+		return /* @__PURE__ */ new Error(`S3 private CAS ${action} returned ${response.status}${detail ? `: ${detail}` : ""}`);
+	};
+	/** Whether the bucket holds this exact object; refuses a same-key object of other bytes. */
+	const holds = async (objectKey, digest, byteLength, signal) => {
+		const response = await request("HEAD", objectKey, signal === void 0 ? {} : { signal });
+		if (response.status === 404) return false;
+		if (!response.ok) throw await refusal(response, "HEAD");
+		const length = Number(response.headers.get("content-length"));
+		const recorded = response.headers.get(METADATA_DIGEST);
+		if (length !== byteLength || recorded !== null && recorded !== digest) throw new Error(`S3 private CAS object ${objectKey} has another length or digest`);
+		return recorded === digest;
+	};
+	return {
+		location: `s3://${options.bucket}/${prefix}`,
+		async putStream({ namespace, digest, byteLength, chunks, signal }) {
+			const objectKey = key(namespace, digest);
+			if (await holds(objectKey, digest, byteLength, signal)) return;
+			async function* checked() {
+				const hash = createHash("sha256");
+				let total = 0;
+				for await (const chunk of chunks) {
+					signal?.throwIfAborted();
+					total += chunk.byteLength;
+					if (total > byteLength) throw new Error("S3 private CAS stream exceeds its declared length");
+					hash.update(chunk);
+					yield chunk;
+				}
+				if (total !== byteLength || `sha256:${hash.digest("hex")}` !== digest) throw new Error("S3 private CAS stream failed digest or length verification");
+			}
+			const body = Readable.from(checked());
+			try {
+				const response = await request("PUT", objectKey, {
+					body: Readable.toWeb(body),
+					byteLength,
+					payloadHash: DIGEST.exec(digest)[1],
+					headers: {
+						"content-type": CONTENT_TYPE,
+						"content-length": String(byteLength),
+						[METADATA_DIGEST]: digest
+					},
+					...signal === void 0 ? {} : { signal }
+				});
+				if (!response.ok) throw await refusal(response, "PUT");
+				await response.body?.cancel().catch(() => void 0);
+				if (!await holds(objectKey, digest, byteLength, signal)) throw new Error(`S3 private CAS object ${objectKey} is absent after its write`);
+			} finally {
+				body.destroy();
+			}
+		},
+		async getStream({ namespace, digest, signal }) {
+			const response = await request("GET", key(namespace, digest), signal === void 0 ? {} : { signal });
+			if (response.status === 404) {
+				await response.body?.cancel().catch(() => void 0);
+				return;
+			}
+			if (!response.ok) throw await refusal(response, "GET");
+			if (!response.body) throw new Error("S3 private CAS GET returned no body");
+			return (async function* () {
+				const reader = response.body.getReader();
+				try {
+					while (true) {
+						signal?.throwIfAborted();
+						const { done, value } = await reader.read();
+						if (done) break;
+						yield value;
+					}
+				} finally {
+					await reader.cancel().catch(() => void 0);
+				}
+			})();
+		},
+		async put({ namespace, digest, bytes, signal }) {
+			const objectKey = key(namespace, digest);
+			if (await holds(objectKey, digest, bytes.byteLength, signal)) return;
+			const response = await request("PUT", objectKey, {
+				body: bytes,
+				payloadHash: DIGEST.exec(digest)[1],
+				headers: {
+					"content-type": CONTENT_TYPE,
+					[METADATA_DIGEST]: digest
+				},
+				...signal === void 0 ? {} : { signal }
+			});
+			if (!response.ok) throw await refusal(response, "PUT");
+			await response.body?.cancel().catch(() => void 0);
+			if (!await holds(objectKey, digest, bytes.byteLength, signal)) throw new Error(`S3 private CAS object ${objectKey} is absent after its write`);
+		},
+		async get({ namespace, digest, signal }) {
+			const response = await request("GET", key(namespace, digest), signal === void 0 ? {} : { signal });
+			if (response.status === 404) {
+				await response.body?.cancel().catch(() => void 0);
+				return;
+			}
+			if (!response.ok) throw await refusal(response, "GET");
+			return new Uint8Array(await response.arrayBuffer());
+		}
+	};
+}
+//#endregion
 //#region src/runtime/box-read-retry.ts
 /**
 * One bounded-retry read over a sandbox box's filesystem, shared by every caller that reads a
@@ -8397,6 +8938,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { InMemoryCorpus as $, mcpSecretEnvMetadataKey as $t, unsafeInProcessRunner as A, runIsolatedCheck as At, SandboxRunAbortError as B, renderPairwiseMarkdown as Bt, withUntrackedArtifacts as C, superviseDispatch as Ct, patchDelivered as D, declaredCheckDigest as Dt, createSqlRunContext as E, declaredCheckDeliverable as Et, strategyTournament as F, leaderboard as Ft, equalKOnCost as G, SqlResultBlobStore as Gt, printBenchmarkReport as H, defaultAuditorInstruction as Ht, assertStrategyContract as I, pairwiseSignificance as It, runPersonified as J, connectStdioMcp as Jt, trajectoryReport as K, SqlSpawnJournal as Kt, authorStrategy as L, renderLeaderboardHtml as Lt, chatWorkerSeam as M, deterministicCompletion as Mt, createChatSessionStore as N, sentinelCompletion as Nt, runCoderChecks as O, declaredCheckJudge as Ot, runStrategyEvolution as P, stopSentinel as Pt, FileCorpus as Q, envKeyProvider as Qt, strategyAuthorContract as R, renderLeaderboardMarkdown as Rt, copyUntrackedIntoClone as S, loopDispatch as St, createFencedSqlRunContext as T, checkProgramDigest as Tt, runBenchmark as U, SqlRunOwnershipError as Ut, openSandboxRun as V, auditIntent as Vt, createPrivateCasArtifactPort as W, openSqlRunStore as Wt, createShapeRegistry as X, createMcpEnvironment as Xt, builtinShapes as Y, materializeLocalMcp as Yt, registerShape as Z, sanitizeMcpToolSchema as Zt, NOTE_MAX_CHARS as _, defineLeaderboard as _t, localShell as a, pipeline as at, composeWorkerEvidence as b, inlineSandboxClient as bt, createVerifierEnvironment as c, widen as ct, harvestSurfaceDiffs as d, createScopeAnalyst as dt, resolveMcpServerLaunch as en, renderCorpusToInstructions as et, analystsFromRegistry as f, registryScopeAnalyst as ft, EVIDENCE_MAX_CHARS as g, harvestCorpus as gt, worktreeFanout as h, HarvestError as ht, jjWorkspace as i, panel as it, chatTransportExecutor as j, completionAuthorizes as jt, codeModeSupervisorTools as k, readDeclaredCheck as kt, boxSurfaceReader as l, assertTraceDerivedFindings as lt, superviseSurface as m, inProcessSandboxClient as mt, makeFinding$1 as n, secretEnvOfMcpServer as nn, flatWidenGate as nt, runInWorkspace as o, selectValidWinner as ot, failuresAnalyst as p, observationFromRegistry as pt, definePersona as q, McpSpawnFault as qt, gitWorkspace as r, createTangleSandboxExactProcessProvider as rn, loopUntil as rt, createWaterfallCollector as s, verify as st, computeFindingId$1 as t, resolveSecretEnv as tn, fanout as tt, fsSurfaceReader as u, buildSteerContext as ut, VERIFY_TAIL_CHARS as v, resolveSandboxClient as vt, analyzeTrace as w, assertDeclaredCheck as wt, settledWorkerOut as x, loopCampaignDispatch as xt, closingWorkerNote as y, localSandboxClient as yt, strategyAuthorSystemPrompt as z, renderLeaderboardSvg as zt };
+export { FileCorpus as $, envKeyProvider as $t, unsafeInProcessRunner as A, readDeclaredCheck as At, SandboxRunAbortError as B, renderLeaderboardSvg as Bt, withUntrackedArtifacts as C, loopDispatch as Ct, patchDelivered as D, declaredCheckDeliverable as Dt, createSqlRunContext as E, checkProgramDigest as Et, strategyTournament as F, stopSentinel as Ft, createPrivateCasArtifactPort as G, openSqlRunStore as Gt, createS3PrivateCasStore as H, auditIntent as Ht, assertStrategyContract as I, leaderboard as It, definePersona as J, McpSpawnFault as Jt, equalKOnCost as K, SqlResultBlobStore as Kt, authorStrategy as L, pairwiseSignificance as Lt, chatWorkerSeam as M, completionAuthorizes as Mt, createChatSessionStore as N, deterministicCompletion as Nt, runCoderChecks as O, declaredCheckDigest as Ot, runStrategyEvolution as P, sentinelCompletion as Pt, registerShape as Q, sanitizeMcpToolSchema as Qt, strategyAuthorContract as R, renderLeaderboardHtml as Rt, copyUntrackedIntoClone as S, loopCampaignDispatch as St, createFencedSqlRunContext as T, assertDeclaredCheck as Tt, printBenchmarkReport as U, defaultAuditorInstruction as Ut, openSandboxRun as V, renderPairwiseMarkdown as Vt, runBenchmark as W, SqlRunOwnershipError as Wt, builtinShapes as X, materializeLocalMcp as Xt, runPersonified as Y, connectStdioMcp as Yt, createShapeRegistry as Z, createMcpEnvironment as Zt, NOTE_MAX_CHARS as _, harvestCorpus as _t, localShell as a, panel as at, composeWorkerEvidence as b, localSandboxClient as bt, createVerifierEnvironment as c, verify as ct, harvestSurfaceDiffs as d, buildSteerContext as dt, mcpSecretEnvMetadataKey as en, InMemoryCorpus as et, analystsFromRegistry as f, createScopeAnalyst as ft, EVIDENCE_MAX_CHARS as g, HarvestError as gt, worktreeFanout as h, inProcessSandboxClient as ht, jjWorkspace as i, createTangleSandboxExactProcessProvider as in, loopUntil as it, chatTransportExecutor as j, runIsolatedCheck as jt, codeModeSupervisorTools as k, declaredCheckJudge as kt, boxSurfaceReader as l, widen as lt, superviseSurface as m, observationFromRegistry as mt, makeFinding$1 as n, resolveSecretEnv as nn, fanout as nt, runInWorkspace as o, pipeline as ot, failuresAnalyst as p, registryScopeAnalyst as pt, trajectoryReport as q, SqlSpawnJournal as qt, gitWorkspace as r, secretEnvOfMcpServer as rn, flatWidenGate as rt, createWaterfallCollector as s, selectValidWinner as st, computeFindingId$1 as t, resolveMcpServerLaunch as tn, renderCorpusToInstructions as tt, fsSurfaceReader as u, assertTraceDerivedFindings as ut, VERIFY_TAIL_CHARS as v, defineLeaderboard as vt, analyzeTrace as w, superviseDispatch as wt, settledWorkerOut as x, inlineSandboxClient as xt, closingWorkerNote as y, resolveSandboxClient as yt, strategyAuthorSystemPrompt as z, renderLeaderboardMarkdown as zt };
 
-//# sourceMappingURL=runtime-10G-vbmJ.js.map
+//# sourceMappingURL=runtime-CXKCdGTg.js.map