@ls-stack/agent-eval 0.55.0 → 0.55.2

package/dist/{runOrchestration-BWyE5lRX.mjs → runExecution-C31dpemR.mjs}

@@ -10,7 +10,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { getCompositeKey } from "@ls-stack/utils/getCompositeKey";
 import { existsSync } from "node:fs";
 import { brotliCompressSync, brotliDecompressSync } from "node:zlib";
-import { Result, resultify } from "t-result";
+import { resultify } from "t-result";
 import { fileURLToPath, pathToFileURL } from "node:url";
 //#region ../sdk/src/defineEval.ts
 const evalRegistry = /* @__PURE__ */ new Map();
@@ -275,12 +275,15 @@ const traceCacheRefSchema = z.object({
 z.object({
 	key: z.string(),
 	namespace: z.string(),
-	operationType: cacheOperationTypeSchema,
-	operationName: z.string(),
-	spanName: z.string().optional(),
-	spanKind: traceSpanKindSchema.optional(),
 	storedAt: z.string(),
-	sizeBytes: z.number()
+	lastAccessedAt: z.string()
+});
+z.object({
+	removedCacheFiles: z.number(),
+	removedDebugFiles: z.number(),
+	removedBlobFiles: z.number(),
+	removedIndexRows: z.number(),
+	rewrittenIndexes: z.number()
 });
 /** Zod schema for `SerializedCacheSpan`, defined lazily for recursion. */
 const serializedCacheSpanSchema = z.object({
@@ -1377,6 +1380,7 @@ const agentEvalsConfigSchema = z.object({
 		dir: z.string().optional(),
 		maxEntriesPerNamespace: z.preprocess((value) => typeof value === "number" && Number.isFinite(value) ? value : void 0, z.number().optional()),
 		maxEntriesByNamespace: z.record(z.string(), z.number()).optional(),
+		pruneIdleDelayMs: z.preprocess((value) => typeof value === "number" && Number.isFinite(value) ? value : void 0, z.number().optional()),
 		maxEntriesPerEval: z.preprocess((value) => typeof value === "number" && Number.isFinite(value) ? value : void 0, z.number().optional())
 	}).optional()
 });
@@ -1692,10 +1696,10 @@ function evaluateTagExpression(expression, tags) {
 }
 function tagMatchesPattern(tag, pattern) {
 	if (!pattern.includes("*")) return tag === pattern;
-	const source = pattern.split("*").map(escapeRegex$1).join(".*");
+	const source = pattern.split("*").map(escapeRegex).join(".*");
 	return new RegExp(`^${source}$`).test(tag);
 }
-function escapeRegex$1(value) {
+function escapeRegex(value) {
 	return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
 }
 //#endregion
@@ -4926,8 +4930,13 @@ const cacheSerializationMarker = "__aecs";
 const supportedCacheSerializationPrefix = "v1:";
 const externalJsonCacheSerializationMarker = "v1:ExternalJson";
 const externalJsonBlobExtension = ".json.br";
+const externalJsonBlobDirName = "cache-blobs";
 const cacheEntryExtension = ".json.br";
 const debugEntryExtension = ".json";
+const cacheIndexFilePrefix = ".index-";
+async function commitPendingCacheWrites(params) {
+	for (const pendingWrite of params.pendingWrites) await params.backingStore.write(pendingWrite.entry, pendingWrite.debugKey);
+}
 /**
 * Create a filesystem-backed cache adapter rooted at `<workspaceRoot>/<dir>`.
 *
@@ -4938,8 +4947,14 @@ const debugEntryExtension = ".json";
 function createFsCacheStore(options) {
 	const cacheDir = resolve(options.workspaceRoot, options.dir ?? ".agent-evals/cache");
 	const debugDir = resolve(options.workspaceRoot, options.debugDir ?? ".agent-evals/cache-debug");
-	const blobDir = resolve(options.workspaceRoot, options.blobDir ?? ".agent-evals/cache-blobs");
-	const externalJsonStore = createExternalJsonBlobStore(blobDir);
+	const blobDir = options.blobDir === void 0 ? join(cacheDir, externalJsonBlobDirName) : resolve(options.workspaceRoot, options.blobDir);
+	const legacyBlobDir = resolve(options.workspaceRoot, ".agent-evals/cache-blobs");
+	const fallbackBlobDirs = options.blobDir === void 0 && legacyBlobDir !== blobDir ? [legacyBlobDir] : [];
+	const blobDirs = [blobDir, ...fallbackBlobDirs];
+	const externalJsonStore = createExternalJsonBlobStore({
+		fallbackDirs: fallbackBlobDirs,
+		primaryDir: blobDir
+	});
 	const defaultMaxEntries = normalizeMaxEntries(options.maxEntriesPerNamespace);
 	return {
 		externalJsonStore,
@@ -4953,11 +4968,22 @@ function createFsCacheStore(options) {
 			return blobDir;
 		},
 		async lookup(namespace, keyHash) {
-			const entry = await readCacheEntry(cacheDir, namespace, keyHash);
-			return entry === null ? null : await materializeExternalJsonCacheEntryOrNull(entry, externalJsonStore);
+			const entry = await readIndexedCacheEntry({
+				cacheDir,
+				key: keyHash,
+				namespace
+			});
+			if (entry === null) return null;
+			const materialized = await materializeExternalJsonCacheEntryOrNull(entry, externalJsonStore);
+			if (materialized !== null) await updateCacheIndexLastAccessedAt(cacheDir, namespace, keyHash);
+			return materialized;
 		},
 		async lookupWithDebug(namespace, keyHash) {
-			const rawEntry = await readCacheEntry(cacheDir, namespace, keyHash);
+			const rawEntry = await readIndexedCacheEntry({
+				cacheDir,
+				key: keyHash,
+				namespace
+			});
 			if (rawEntry === null) return null;
 			const entry = await materializeExternalJsonCacheEntryOrNull(rawEntry, externalJsonStore);
 			if (entry === null) return null;
@@ -4972,8 +4998,17 @@ function createFsCacheStore(options) {
 			};
 		},
 		async write(entry, debugKey) {
-			const maxEntries = maxEntriesForNamespace(entry.namespace, defaultMaxEntries, options.maxEntriesByNamespace);
-			await withCacheFileLock(namespaceLockPath(cacheDir, entry.namespace), () => writeCompressedCacheEntry(cacheDir, entry));
+			await withCacheFileLock(namespaceLockPath(cacheDir, entry.namespace), async () => {
+				await writeCompressedCacheEntry(cacheDir, entry);
+				if (!usesSupportedCacheSerialization(entry.recording)) return;
+				const index = await readNamespaceIndex(cacheDir, entry.namespace);
+				index.entries[entry.key] = {
+					storedAt: entry.storedAt,
+					lastAccessedAt: entry.storedAt,
+					blobRefs: await collectExternalJsonBlobRefs(entry, blobDirs)
+				};
+				await writeNamespaceIndex(cacheDir, index);
+			});
 			if (debugKey !== void 0) {
 				if ((await resultify(() => writeDebugKeyEntry({
 					debugDir,
@@ -4984,36 +5019,11 @@ function createFsCacheStore(options) {
 					key: entry.key
 				}));
 			}
-			await pruneEntriesForNamespace({
-				cacheDir,
-				debugDir,
-				namespace: entry.namespace,
-				maxEntries,
-				protectedKey: entry.key
-			});
-			await pruneExternalJsonBlobs(cacheDir, blobDir);
 		},
 		async list() {
-			const files = await listCacheEntryFiles(cacheDir);
 			const items = [];
-			for (const filePath of files) {
-				const fileEntry = await readCacheEntryFilePath(filePath);
-				if (fileEntry === null || !entryMatchesPath(filePath, fileEntry.entry)) continue;
-				const entry = fileEntry.entry;
-				const operationType = entry.operationType ?? "span";
-				const operationName = entry.operationName ?? entry.spanName ?? entry.namespace;
-				items.push({
-					key: entry.key,
-					namespace: entry.namespace,
-					operationType,
-					operationName,
-					spanName: entry.spanName,
-					spanKind: entry.spanKind,
-					storedAt: entry.storedAt,
-					sizeBytes: fileEntry.sizeBytes
-				});
-			}
-			items.sort((a, b) => a.storedAt < b.storedAt ? 1 : -1);
+			for (const index of await listCacheIndexes(cacheDir)) for (const [key, entry] of Object.entries(index.entries)) items.push(toCacheListItem(index.namespace, key, entry));
+			items.sort((a, b) => a.lastAccessedAt < b.lastAccessedAt ? 1 : -1);
 			return items;
 		},
 		async clear(filter) {
@@ -5026,21 +5036,46 @@ function createFsCacheStore(options) {
 					recursive: true,
 					force: true
 				});
-				await rm(blobDir, {
+				await Promise.all(blobDirs.map((dir) => rm(dir, {
 					recursive: true,
 					force: true
-				});
+				})));
 				return;
 			}
 			if (filter.namespace !== void 0) {
 				await clearCacheEntries(cacheDir, filter);
 				await clearDebugEntries(debugDir, filter);
-				await pruneExternalJsonBlobs(cacheDir, blobDir);
+				await pruneUnreferencedExternalJsonBlobs(cacheDir, blobDirs);
 				return;
 			}
 			await clearCacheEntries(cacheDir, filter);
 			await clearDebugEntries(debugDir, filter);
-			await pruneExternalJsonBlobs(cacheDir, blobDir);
+			await pruneUnreferencedExternalJsonBlobs(cacheDir, blobDirs);
+		},
+		async pruneExternalJsonBlobs() {
+			await pruneUnreferencedExternalJsonBlobs(cacheDir, blobDirs);
+		},
+		async pruneRetention() {
+			for (const index_ of await listCacheIndexes(cacheDir)) {
+				const namespace = index_.namespace;
+				const maxEntries = maxEntriesForNamespace(namespace, defaultMaxEntries, options.maxEntriesByNamespace);
+				const keptKeys = await withCacheFileLock(namespaceLockPath(cacheDir, namespace), async () => {
+					return pruneCacheEntriesForNamespace({
+						cacheDir,
+						index: await readNamespaceIndex(cacheDir, namespace),
+						maxEntries
+					});
+				});
+				await withCacheFileLock(namespaceLockPath(debugDir, namespace), () => pruneDebugEntriesForNamespace(debugDir, namespace, keptKeys));
+			}
+			await pruneUnreferencedExternalJsonBlobs(cacheDir, blobDirs);
+		},
+		async repair() {
+			return repairIndexedCache({
+				blobDirs,
+				cacheDir,
+				debugDir
+			});
 		}
 	};
 }
@@ -5068,10 +5103,16 @@ function createBufferedCacheStore(backingStore) {
 			return Promise.resolve();
 		},
 		async commit() {
-			for (const pending of pendingEntries.values()) await backingStore.write(pending.entry, pending.debugKey);
+			await commitPendingCacheWrites({
+				backingStore,
+				pendingWrites: [...pendingEntries.values()].map((pending) => ({ ...pending }))
+			});
 		},
 		getPendingEntries() {
 			return [...pendingEntries.values()].map((pending) => pending.entry);
+		},
+		getPendingWrites() {
+			return [...pendingEntries.values()].map((pending) => ({ ...pending }));
 		}
 	};
 }
@@ -5117,11 +5158,31 @@ function entryPath(params) {
 	if (filePath !== namespaceDir && !filePath.startsWith(`${namespaceDir}${sep}`)) throw new Error(`Cache entry key escapes namespace directory: ${params.key}`);
 	return filePath;
 }
-async function readCacheEntry(cacheDir, namespace, key) {
-	return (await readCacheEntryFilePath(cacheEntryPath(cacheDir, namespace, key), {
-		namespace,
-		key
-	}))?.entry ?? null;
+function cacheIndexPath(cacheDir, namespace) {
+	return join(namespaceDirPath(cacheDir, namespace), `${cacheIndexFilePrefix}${hashNamespace(namespace)}${debugEntryExtension}`);
+}
+async function readIndexedCacheEntry(params) {
+	return withCacheFileLock(namespaceLockPath(params.cacheDir, params.namespace), async () => {
+		if ((await readNamespaceIndex(params.cacheDir, params.namespace)).entries[params.key] === void 0) return null;
+		const fileEntry = await readCacheEntryFilePath(cacheEntryPath(params.cacheDir, params.namespace, params.key), {
+			namespace: params.namespace,
+			key: params.key
+		});
+		if (fileEntry === null) return null;
+		return fileEntry.entry;
+	});
+}
+async function updateCacheIndexLastAccessedAt(cacheDir, namespace, key) {
+	await withCacheFileLock(namespaceLockPath(cacheDir, namespace), async () => {
+		const index = await readNamespaceIndex(cacheDir, namespace);
+		const entry = index.entries[key];
+		if (entry === void 0) return;
+		index.entries[key] = {
+			...entry,
+			lastAccessedAt: new Date(getRealDateNowMs()).toISOString()
+		};
+		await writeNamespaceIndex(cacheDir, index);
+	});
 }
 async function readCacheEntryFilePath(filePath, expected) {
 	if (!existsSync(filePath)) return null;
@@ -5136,10 +5197,7 @@ async function readCacheEntryFilePath(filePath, expected) {
 	const entry = parsed.data;
 	if (!usesSupportedCacheSerialization(entry.recording)) return null;
 	if (expected !== void 0 && (entry.namespace !== expected.namespace || entry.key !== expected.key)) return null;
-	return {
-		entry,
-		sizeBytes: compressedResult.value.byteLength
-	};
+	return { entry };
 }
 async function writeCompressedCacheEntry(cacheDir, entry) {
 	const filePath = cacheEntryPath(cacheDir, entry.namespace, entry.key);
@@ -5188,23 +5246,132 @@ async function writeAtomicFile(filePath, contents) {
 	await writeFile(tmpPath, contents);
 	await rename(tmpPath, filePath);
 }
+const emptyCacheIndex = (namespace) => ({
+	version: 1,
+	namespace,
+	entries: {}
+});
+async function readNamespaceIndex(cacheDir, namespace) {
+	const indexPath = cacheIndexPath(cacheDir, namespace);
+	if (!existsSync(indexPath)) return emptyCacheIndex(namespace);
+	const rawResult = await resultify(() => readFile(indexPath, "utf8"));
+	if (rawResult.error) return emptyCacheIndex(namespace);
+	return parseCacheIndexFile(safeJsonParse(rawResult.value), namespace) ?? emptyCacheIndex(namespace);
+}
+async function writeNamespaceIndex(cacheDir, index) {
+	const entries = Object.entries(index.entries);
+	if (entries.length === 0) {
+		await rm(cacheIndexPath(cacheDir, index.namespace), { force: true });
+		await removeDirIfEmpty(namespaceDirPath(cacheDir, index.namespace));
+		return;
+	}
+	const sortedEntries = entries.toSorted(([a], [b]) => a < b ? -1 : 1);
+	const normalizedEntries = Object.fromEntries(sortedEntries.map(([key, entry]) => [key, entry]));
+	await writeAtomicFile(cacheIndexPath(cacheDir, index.namespace), JSON.stringify({
+		...index,
+		entries: normalizedEntries
+	}, null, 2));
+}
+async function listCacheIndexes(cacheDir) {
+	if (!existsSync(cacheDir)) return [];
+	const entriesResult = await resultify(() => readdir(cacheDir, { withFileTypes: true }));
+	if (entriesResult.error) return [];
+	const records = [];
+	for (const entry of entriesResult.value) {
+		if (!entry.isDirectory()) continue;
+		const namespaceDir = join(cacheDir, entry.name);
+		for (const indexFilePath of await listCacheIndexFiles(namespaceDir)) {
+			const rawResult = await resultify(() => readFile(indexFilePath, "utf8"));
+			if (rawResult.error) continue;
+			const parsed = parseCacheIndexFile(safeJsonParse(rawResult.value));
+			if (parsed === null) continue;
+			records.push(parsed);
+		}
+	}
+	return records;
+}
+function hashNamespace(namespace) {
+	return createHash("sha256").update(namespace).digest("hex");
+}
+function parseCacheIndexFile(value, expectedNamespace) {
+	if (!isRecordLike(value)) return null;
+	if (value.version !== 1 || typeof value.namespace !== "string") return null;
+	if (expectedNamespace !== void 0 && value.namespace !== expectedNamespace) return null;
+	if (!isRecordLike(value.entries)) return null;
+	const entries = {};
+	for (const [key, entryValue] of Object.entries(value.entries)) {
+		const entry = parseCacheIndexEntry(entryValue);
+		if (entry === null) return null;
+		entries[key] = entry;
+	}
+	return {
+		version: 1,
+		namespace: value.namespace,
+		entries
+	};
+}
+function parseCacheIndexEntry(value) {
+	if (!isRecordLike(value)) return null;
+	if (typeof value.storedAt !== "string" || typeof value.lastAccessedAt !== "string") return null;
+	if (!Array.isArray(value.blobRefs)) return null;
+	const blobRefs = [];
+	for (const blobRef of value.blobRefs) {
+		if (typeof blobRef !== "string") return null;
+		blobRefs.push(blobRef);
+	}
+	return {
+		storedAt: value.storedAt,
+		lastAccessedAt: value.lastAccessedAt,
+		blobRefs
+	};
+}
+function toCacheListItem(namespace, key, entry) {
+	return {
+		key,
+		namespace,
+		storedAt: entry.storedAt,
+		lastAccessedAt: entry.lastAccessedAt
+	};
+}
+function keyFromEntryFilePath(filePath, extension) {
+	const name = basename(filePath);
+	if (!name.endsWith(extension)) return null;
+	return name.slice(0, -extension.length);
+}
+function debugNamespaceFromPath(debugDir, filePath) {
+	return basename(dirname(resolve(debugDir, relative(debugDir, filePath))));
+}
 async function clearCacheEntries(cacheDir, filter) {
-	const files = filter.namespace === void 0 ? await listCacheEntryFiles(cacheDir) : await listCacheEntryFiles(namespaceDirPath(cacheDir, filter.namespace));
-	for (const filePath of files) {
-		const fileEntry = await readCacheEntryFilePath(filePath);
-		if (fileEntry === null) continue;
-		const entry = fileEntry.entry;
-		if (!entryMatchesFilter(entry, filter)) continue;
-		await withCacheFileLock(namespaceLockPath(cacheDir, entry.namespace), () => rm(filePath, { force: true }));
+	const indexes = filter.namespace === void 0 ? await listCacheIndexes(cacheDir) : [await readNamespaceIndex(cacheDir, filter.namespace)];
+	for (const record of indexes) {
+		const namespace = record.namespace;
+		await withCacheFileLock(namespaceLockPath(cacheDir, namespace), async () => {
+			const index = await readNamespaceIndex(cacheDir, namespace);
+			const matchingKeys = Object.keys(index.entries).filter((key) => {
+				return index.entries[key] !== void 0 && entryMatchesFilter({
+					namespace,
+					key
+				}, filter);
+			});
+			for (const key of matchingKeys) {
+				await rm(cacheEntryPath(cacheDir, namespace, key), { force: true });
+				delete index.entries[key];
+			}
+			await writeNamespaceIndex(cacheDir, index);
+		});
 	}
-	if (filter.namespace !== void 0) await removeDirIfEmpty(namespaceDirPath(cacheDir, filter.namespace));
 }
 async function clearDebugEntries(debugDir, filter) {
-	const files = filter.namespace === void 0 ? await listDebugEntryFiles(debugDir) : await listDebugEntryFiles(namespaceDirPath(debugDir, filter.namespace));
+	const files = await listDebugEntryFiles(filter.namespace === void 0 ? debugDir : namespaceDirPath(debugDir, filter.namespace));
 	for (const filePath of files) {
-		const entry = await readDebugEntryFilePath(filePath);
-		if (entry === null || !entryMatchesFilter(entry, filter)) continue;
-		await withCacheFileLock(namespaceLockPath(debugDir, entry.namespace), () => rm(filePath, { force: true }));
+		const namespace = filter.namespace === void 0 ? debugNamespaceFromPath(debugDir, filePath) : filter.namespace;
+		const key = keyFromEntryFilePath(filePath, debugEntryExtension);
+		if (key === null) continue;
+		if (!entryMatchesFilter({
+			namespace,
+			key
+		}, filter)) continue;
+		await withCacheFileLock(namespaceLockPath(debugDir, namespace), () => rm(filePath, { force: true }));
 	}
 	if (filter.namespace !== void 0) await removeDirIfEmpty(namespaceDirPath(debugDir, filter.namespace));
 }
@@ -5212,49 +5379,86 @@ function entryMatchesFilter(entry, filter) {
 	if (filter.namespace !== void 0 && entry.namespace !== filter.namespace) return false;
 	return filter.key === void 0 || entry.key === filter.key;
 }
-async function pruneEntriesForNamespace(params) {
-	const { cacheDir, debugDir, namespace, maxEntries, protectedKey } = params;
-	await withCacheFileLock(namespaceLockPath(cacheDir, namespace), async () => {
-		const keptKeys = await pruneCacheEntriesForNamespace(cacheDir, namespace, maxEntries, protectedKey);
-		await withCacheFileLock(namespaceLockPath(debugDir, namespace), () => pruneDebugEntriesForNamespace(debugDir, namespace, keptKeys));
-	});
-}
-async function pruneCacheEntriesForNamespace(cacheDir, namespace, maxEntries, protectedKey) {
-	const entries = await listCacheEntriesForNamespace(cacheDir, namespace);
-	const sorted = entries.toSorted((a, b) => a.entry.storedAt < b.entry.storedAt ? 1 : -1);
+async function pruneCacheEntriesForNamespace(params) {
+	const { cacheDir, index, maxEntries } = params;
+	const entries = Object.entries(index.entries);
+	const sorted = entries.toSorted(([, a], [, b]) => a.lastAccessedAt < b.lastAccessedAt ? 1 : -1);
 	const keptKeys = /* @__PURE__ */ new Set();
-	const protectedEntry = entries.find((item) => item.entry.key === protectedKey);
-	if (protectedEntry !== void 0) keptKeys.add(protectedEntry.entry.key);
-	for (const item of sorted) {
+	for (const [key] of sorted) {
 		if (keptKeys.size >= maxEntries) break;
-		keptKeys.add(item.entry.key);
+		keptKeys.add(key);
+	}
+	for (const [key] of entries) if (!keptKeys.has(key)) {
+		await rm(cacheEntryPath(cacheDir, index.namespace, key), { force: true });
+		delete index.entries[key];
 	}
-	for (const item of entries) if (!keptKeys.has(item.entry.key)) await rm(item.filePath, { force: true });
-	await removeDirIfEmpty(namespaceDirPath(cacheDir, namespace));
+	await writeNamespaceIndex(cacheDir, index);
 	return keptKeys;
 }
 async function pruneDebugEntriesForNamespace(debugDir, namespace, keptKeys) {
 	const files = await listDebugEntryFiles(namespaceDirPath(debugDir, namespace));
 	for (const filePath of files) {
-		const entry = await readDebugEntryFilePath(filePath);
-		if (entry !== null && entry.namespace === namespace && !keptKeys.has(entry.key)) await rm(filePath, { force: true });
+		const key = keyFromEntryFilePath(filePath, debugEntryExtension);
+		if (key !== null && !keptKeys.has(key)) await rm(filePath, { force: true });
 	}
 	await removeDirIfEmpty(namespaceDirPath(debugDir, namespace));
 }
-async function listCacheEntriesForNamespace(cacheDir, namespace) {
-	const files = await listCacheEntryFiles(namespaceDirPath(cacheDir, namespace));
-	const entries = [];
-	for (const filePath of files) {
-		const fileEntry = await readCacheEntryFilePath(filePath);
-		if (fileEntry !== null && fileEntry.entry.namespace === namespace && entryMatchesPath(filePath, fileEntry.entry)) entries.push({
-			filePath,
-			entry: fileEntry.entry
+async function repairIndexedCache(params) {
+	const summary = {
+		removedCacheFiles: 0,
+		removedDebugFiles: 0,
+		removedBlobFiles: 0,
+		removedIndexRows: 0,
+		rewrittenIndexes: 0
+	};
+	for (const index_ of await listCacheIndexes(params.cacheDir)) {
+		const result = await withCacheFileLock(namespaceLockPath(params.cacheDir, index_.namespace), async () => {
+			const index = await readNamespaceIndex(params.cacheDir, index_.namespace);
+			let removedRows = 0;
+			for (const key of Object.keys(index.entries)) if (!existsSync(cacheEntryPath(params.cacheDir, index.namespace, key))) {
+				delete index.entries[key];
+				removedRows++;
+			}
+			if (removedRows === 0) return {
+				removedRows,
+				rewritten: false
+			};
+			await writeNamespaceIndex(params.cacheDir, index);
+			return {
+				removedRows,
+				rewritten: true
+			};
 		});
+		summary.removedIndexRows += result.removedRows;
+		if (result.rewritten) summary.rewrittenIndexes++;
+	}
+	const indexes = await listCacheIndexes(params.cacheDir);
+	const indexedCacheFiles = /* @__PURE__ */ new Set();
+	const indexedDebugFiles = /* @__PURE__ */ new Set();
+	const indexedBlobRefs = /* @__PURE__ */ new Set();
+	for (const index_ of indexes) for (const [key, entry] of Object.entries(index_.entries)) {
+		indexedCacheFiles.add(cacheEntryPath(params.cacheDir, index_.namespace, key));
+		indexedDebugFiles.add(debugEntryPath(params.debugDir, index_.namespace, key));
+		for (const blobRef of entry.blobRefs) indexedBlobRefs.add(blobRef);
+	}
+	for (const filePath of await listCacheEntryFiles(params.cacheDir, "allNamespaces")) if (!indexedCacheFiles.has(filePath)) {
+		await rm(filePath, { force: true });
+		summary.removedCacheFiles++;
+		await removeDirIfEmpty(dirname(filePath));
+	}
+	for (const filePath of await listDebugEntryFiles(params.debugDir)) if (!indexedDebugFiles.has(filePath)) {
+		await rm(filePath, { force: true });
+		summary.removedDebugFiles++;
+		await removeDirIfEmpty(dirname(filePath));
+	}
+	for (const blobDir of params.blobDirs) {
+		if (!existsSync(blobDir)) continue;
+		for (const blobRef of await listExternalJsonBlobPaths(blobDir)) if (!indexedBlobRefs.has(blobRef)) {
+			await rm(resolveStorePath(blobDir, blobRef), { force: true });
+			summary.removedBlobFiles++;
+		}
 	}
-	return entries;
-}
-function entryMatchesPath(filePath, entry) {
-	return basename(filePath) === `${entry.key}${cacheEntryExtension}` && basename(dirname(filePath)) === sanitizeSegment$1(entry.namespace);
+	return summary;
 }
 function usesSupportedCacheSerialization(value) {
 	if (Array.isArray(value)) return value.every(usesSupportedCacheSerialization);
@@ -5262,14 +5466,14 @@ function usesSupportedCacheSerialization(value) {
 	if (Object.hasOwn(value, cacheSerializationMarker) && (typeof value[cacheSerializationMarker] !== "string" || !value[cacheSerializationMarker].startsWith(supportedCacheSerializationPrefix))) return false;
 	return Object.values(value).every(usesSupportedCacheSerialization);
 }
-function createExternalJsonBlobStore(blobDir) {
+function createExternalJsonBlobStore(params) {
 	return {
 		async write(rawJson) {
 			const rawBytes = Buffer.from(rawJson, "utf8");
 			const hash = hashExternalJson(rawBytes);
 			const path = externalJsonBlobPath(hash);
 			const compressed = brotliCompressSync(rawBytes);
-			const filePath = resolveStorePath(blobDir, path);
+			const filePath = resolveStorePath(params.primaryDir, path);
 			if (!existsSync(filePath)) await writeAtomicFile(filePath, compressed);
 			return {
 				compressedLength: compressed.byteLength,
@@ -5279,10 +5483,15 @@ function createExternalJsonBlobStore(blobDir) {
 			};
 		},
 		async read(ref) {
-			const rawBytes = brotliDecompressSync(await readFile(resolveStorePath(blobDir, ref.path)));
-			const rawJson = rawBytes.toString("utf8");
-			if (rawBytes.byteLength !== ref.length || hashExternalJson(rawBytes) !== ref.hash) throw new Error(`External cache blob failed integrity check: ${ref.hash}`);
-			return rawJson;
+			for (const dir of [params.primaryDir, ...params.fallbackDirs]) {
+				const compressedResult = await resultify(() => readFile(resolveStorePath(dir, ref.path)));
+				if (compressedResult.error) continue;
+				const rawBytesResult = resultify(() => brotliDecompressSync(compressedResult.value));
+				if (rawBytesResult.error) continue;
+				const rawBytes = rawBytesResult.value;
+				if (rawBytes.byteLength === ref.length && hashExternalJson(rawBytes) === ref.hash) return rawBytes.toString("utf8");
+			}
+			throw new Error(`External cache blob failed integrity check: ${ref.hash}`);
 		}
 	};
 }
@@ -5308,28 +5517,55 @@ async function materializeExternalJsonCacheEntryOrNull(entry, store) {
 	const result = await resultify(() => materializeExternalJsonCacheEntry(entry, store));
 	return result.error ? null : result.value;
 }
-async function pruneExternalJsonBlobs(cacheDir, blobDir) {
-	if (!existsSync(blobDir)) return;
+async function pruneUnreferencedExternalJsonBlobs(cacheDir, blobDirs) {
 	const referenced = await collectReferencedExternalJsonBlobPaths(cacheDir);
-	for (const path of await listExternalJsonBlobPaths(blobDir)) if (!referenced.has(path)) await rm(resolveStorePath(blobDir, path), { force: true });
+	for (const blobDir of blobDirs) {
+		if (!existsSync(blobDir)) continue;
+		for (const path of await listExternalJsonBlobPaths(blobDir)) if (!referenced.has(path)) await rm(resolveStorePath(blobDir, path), { force: true });
+	}
 }
 async function collectReferencedExternalJsonBlobPaths(cacheDir) {
 	const paths = /* @__PURE__ */ new Set();
-	for (const filePath of await listCacheEntryFiles(cacheDir)) {
-		const fileEntry = await readCacheEntryFilePath(filePath);
-		if (fileEntry === null || !entryMatchesPath(filePath, fileEntry.entry)) continue;
-		collectExternalJsonBlobPaths(fileEntry.entry, paths);
-	}
+	for (const index_ of await listCacheIndexes(cacheDir)) for (const entry of Object.values(index_.entries)) for (const blobRef of entry.blobRefs) paths.add(blobRef);
 	return paths;
 }
-function collectExternalJsonBlobPaths(value, paths) {
+async function collectExternalJsonBlobRefs(value, blobDirs) {
+	const paths = /* @__PURE__ */ new Set();
+	const pendingBlobPaths = [];
+	collectExternalJsonBlobPaths(value, paths, pendingBlobPaths);
+	while (pendingBlobPaths.length > 0) {
+		const blobPath = pendingBlobPaths.pop();
+		if (blobPath === void 0) continue;
+		const rawJson = await readExternalJsonBlobByPath(blobDirs, blobPath);
+		if (rawJson === null) continue;
+		const json = safeJsonParse(rawJson);
+		if (json === null) continue;
+		collectExternalJsonBlobPaths(json, paths, pendingBlobPaths);
+	}
+	return [...paths].sort();
+}
+function collectExternalJsonBlobPaths(value, paths, pendingBlobPaths) {
 	if (Array.isArray(value)) {
-		for (const item of value) collectExternalJsonBlobPaths(item, paths);
+		for (const item of value) collectExternalJsonBlobPaths(item, paths, pendingBlobPaths);
 		return;
 	}
 	if (!isRecordLike(value)) return;
-	if (value[cacheSerializationMarker] === externalJsonCacheSerializationMarker && typeof value.path === "string") paths.add(value.path);
-	for (const entryValue of Object.values(value)) collectExternalJsonBlobPaths(entryValue, paths);
+	if (value[cacheSerializationMarker] === externalJsonCacheSerializationMarker && typeof value.path === "string") {
+		if (!paths.has(value.path)) {
+			paths.add(value.path);
+			pendingBlobPaths.push(value.path);
+		}
+	}
+	for (const entryValue of Object.values(value)) collectExternalJsonBlobPaths(entryValue, paths, pendingBlobPaths);
+}
+async function readExternalJsonBlobByPath(blobDirs, path) {
+	for (const blobDir of blobDirs) {
+		const compressedResult = await resultify(() => readFile(resolveStorePath(blobDir, path)));
+		if (compressedResult.error) continue;
+		const rawResult = resultify(() => brotliDecompressSync(compressedResult.value).toString("utf8"));
+		if (!rawResult.error) return rawResult.value;
+	}
+	return null;
 }
 async function listExternalJsonBlobPaths(blobDir) {
 	const paths = [];
@@ -5348,12 +5584,33 @@ async function collectExternalJsonBlobFilePaths(root, dir, paths) {
 		if (entry.isFile() && entry.name.endsWith(externalJsonBlobExtension)) paths.push(relative(root, path));
 	}
 }
-async function listCacheEntryFiles(rootDir) {
-	return listFilesWithExtension(rootDir, cacheEntryExtension);
+async function listCacheEntryFiles(rootDir, scope) {
+	if (scope === "namespace") return listDirectFilesWithExtension(rootDir, cacheEntryExtension);
+	if (!existsSync(rootDir)) return [];
+	const entriesResult = await resultify(() => readdir(rootDir, { withFileTypes: true }));
+	if (entriesResult.error) return [];
+	const files = [];
+	for (const entry of entriesResult.value) {
+		if (!entry.isDirectory()) continue;
+		files.push(...await listDirectFilesWithExtension(join(rootDir, entry.name), cacheEntryExtension));
+	}
+	return files;
 }
 async function listDebugEntryFiles(rootDir) {
 	return listFilesWithExtension(rootDir, debugEntryExtension);
 }
+async function listCacheIndexFiles(rootDir) {
+	if (!existsSync(rootDir)) return [];
+	const entriesResult = await resultify(() => readdir(rootDir, { withFileTypes: true }));
+	if (entriesResult.error) return [];
+	return entriesResult.value.filter((entry) => entry.isFile() && entry.name.startsWith(cacheIndexFilePrefix) && entry.name.endsWith(debugEntryExtension)).map((entry) => join(rootDir, entry.name));
+}
+async function listDirectFilesWithExtension(rootDir, extension) {
+	if (!existsSync(rootDir)) return [];
+	const entriesResult = await resultify(() => readdir(rootDir, { withFileTypes: true }));
+	if (entriesResult.error) return [];
+	return entriesResult.value.filter((entry) => entry.isFile() && entry.name.endsWith(extension)).map((entry) => join(rootDir, entry.name));
+}
 async function listFilesWithExtension(rootDir, extension) {
 	if (!existsSync(rootDir)) return [];
 	const entriesResult = await resultify(() => readdir(rootDir, { withFileTypes: true }));
@@ -5387,6 +5644,7 @@ async function withCacheFileLock(filePath, fn) {
 		force: true
 	});
 	if (result.error) throw result.error;
+	return result.value;
 }
 async function acquireLock(lockPath) {
 	const startedAt = Date.now();
@@ -5412,80 +5670,6 @@ function isRecordLike(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
-//#region ../runner/src/chartValidation.ts
-function isValidColumnMetric(metric, columnsByKey, evalId, warnings) {
-	const columnDef = columnsByKey.get(metric.key);
-	if (!columnDef) {
-		warnings.push(`[${evalId}] chart metric references unknown column "${metric.key}" — dropped`);
-		return false;
-	}
-	if (metric.aggregate === "passThresholdRate") {
-		if (columnDef.isScore !== true || typeof columnDef.passThreshold !== "number") {
-			warnings.push(`[${evalId}] chart metric "${metric.key}" uses "passThresholdRate" but the column is not a score with passThreshold — dropped`);
-			return false;
-		}
-	}
-	return true;
-}
-function isValidTooltipExtra(extra, columnsByKey, evalId, warnings) {
-	const columnDef = columnsByKey.get(extra.key);
-	if (!columnDef) {
-		warnings.push(`[${evalId}] chart tooltip extra references unknown column "${extra.key}" — dropped`);
-		return false;
-	}
-	if (extra.aggregate === "passThresholdRate") {
-		if (columnDef.isScore !== true || typeof columnDef.passThreshold !== "number") {
-			warnings.push(`[${evalId}] chart tooltip extra "${extra.key}" uses "passThresholdRate" but the column is not a score with passThreshold — dropped`);
-			return false;
-		}
-	}
-	return true;
-}
-function sanitizeChart(chart, columnsByKey, evalId, warnings) {
-	const metrics = chart.metrics.filter((metric) => {
-		if (metric.source === "builtin") return true;
-		return isValidColumnMetric(metric, columnsByKey, evalId, warnings);
-	});
-	if (metrics.length === 0) {
-		warnings.push(`[${evalId}] chart had no valid metrics after validation — chart dropped`);
-		return null;
-	}
-	const tooltipExtras = chart.tooltipExtras?.filter((extra) => {
-		if (extra.source === "builtin") return true;
-		return isValidTooltipExtra(extra, columnsByKey, evalId, warnings);
-	});
-	return {
-		...chart,
-		metrics,
-		tooltipExtras: tooltipExtras?.length ? tooltipExtras : void 0
-	};
-}
-/**
-* Validate and sanitize an authored `charts` config against the eval's
-* declared columns. Drops metrics/extras that reference unknown columns or
-* misuse `passThresholdRate`, and drops entire charts whose metrics are all
-* invalid. Returns `charts: undefined` when nothing valid remains so the UI
-* falls back to rendering no chart (matching the opt-in default).
-*/
-function validateCharts(params) {
-	const { charts, columnDefs, evalId } = params;
-	if (!charts || charts.length === 0) return {
-		charts: void 0,
-		warnings: []
-	};
-	const columnsByKey = new Map(columnDefs.map((def) => [def.key, def]));
-	const warnings = [];
-	const sanitized = [];
-	for (const chart of charts) {
-		const result = sanitizeChart(chart, columnsByKey, evalId, warnings);
-		if (result) sanitized.push(result);
-	}
-	return {
-		charts: sanitized.length > 0 ? sanitized : void 0,
-		warnings
-	};
-}
-//#endregion
 //#region ../runner/src/columnBuilder.ts
 /**
 * Normalize a user-provided score definition (either a function or an
@@ -5991,112 +6175,6 @@ function addDefaultOutputs(params) {
 	});
 }
 //#endregion
-//#region ../runner/src/discovery.ts
-const evalIdMatchRegex = /\bid\s*:\s*['"]([^'"]+)['"]/;
-const evalTitleMatchRegex = /\btitle\s*:\s*['"]([^'"]+)['"]/;
-/** Parse static eval metadata and discovery issues from one eval file. */
-function parseEvalDiscovery(filePath, content) {
-	const metas = [];
-	let searchIndex = 0;
-	while (searchIndex < content.length) {
-		const defineEvalIndex = content.indexOf("defineEval", searchIndex);
-		if (defineEvalIndex === -1) break;
-		const extracted = extractDefineEvalObject(content, defineEvalIndex);
-		if (!extracted) {
-			searchIndex = defineEvalIndex + 10;
-			continue;
-		}
-		const id = evalIdMatchRegex.exec(extracted.objectText)?.[1];
-		if (id !== void 0) {
-			const result = {
-				filePath,
-				id
-			};
-			const title = evalTitleMatchRegex.exec(extracted.objectText)?.[1];
-			if (title !== void 0) result.title = title;
-			metas.push(result);
-		}
-		searchIndex = extracted.nextIndex;
-	}
-	const countsById = /* @__PURE__ */ new Map();
-	for (const meta of metas) countsById.set(meta.id, (countsById.get(meta.id) ?? 0) + 1);
-	const duplicateIds = new Set([...countsById].filter(([, count]) => count > 1).map(([id]) => id));
-	const issues = [...duplicateIds].map((evalId) => ({
-		type: "duplicate-eval-id",
-		severity: "error",
-		filePath,
-		evalId,
-		message: `Duplicate eval id "${evalId}" in ${filePath}. Eval ids must be unique within one file.`
-	}));
-	return {
-		metas: metas.filter((meta) => !duplicateIds.has(meta.id)),
-		issues
-	};
-}
-function extractDefineEvalObject(content, defineEvalIndex) {
-	const openParenIndex = content.indexOf("(", defineEvalIndex);
-	if (openParenIndex === -1) return void 0;
-	const objectStartIndex = content.indexOf("{", openParenIndex);
-	if (objectStartIndex === -1) return void 0;
-	let depth = 0;
-	let quote;
-	let inBlockComment = false;
-	let inLineComment = false;
-	let isEscaped = false;
-	for (let index = objectStartIndex; index < content.length; index++) {
-		const currentChar = content[index];
-		const nextChar = content[index + 1];
-		if (inLineComment) {
-			if (currentChar === "\n") inLineComment = false;
-			continue;
-		}
-		if (inBlockComment) {
-			if (currentChar === "*" && nextChar === "/") {
-				inBlockComment = false;
-				index++;
-			}
-			continue;
-		}
-		if (quote) {
-			if (isEscaped) {
-				isEscaped = false;
-				continue;
-			}
-			if (currentChar === "\\") {
-				isEscaped = true;
-				continue;
-			}
-			if (currentChar === quote) quote = void 0;
-			continue;
-		}
-		if (currentChar === "/" && nextChar === "/") {
-			inLineComment = true;
-			index++;
-			continue;
-		}
-		if (currentChar === "/" && nextChar === "*") {
-			inBlockComment = true;
-			index++;
-			continue;
-		}
-		if (currentChar === "\"" || currentChar === "'" || currentChar === "`") {
-			quote = currentChar;
-			continue;
-		}
-		if (currentChar === "{") {
-			depth++;
-			continue;
-		}
-		if (currentChar === "}") {
-			depth--;
-			if (depth === 0) return {
-				nextIndex: index + 1,
-				objectText: content.slice(objectStartIndex, index + 1)
-			};
-		}
-	}
-}
-//#endregion
 //#region ../runner/src/evalModuleLoader.ts
 /**
 * Import one eval module with a cache key derived from its current source so
@@ -6121,6 +6199,7 @@ const agentPackageUrlBySpecifier = new Map([
 	"@agent-evals/sdk",
 	"@agent-evals/shared",
 	"@agent-evals/runner",
+	"@agent-evals/runner/case-child",
 	"@agent-evals/runner/run-child"
 ].flatMap((specifier) => {
 	try {
@@ -6146,7 +6225,8 @@ function isIsolatableFilePath(filePath, workspaceRoot) {
 	if (isAgentEvalsPackageFilePath(filePath)) return false;
 	const relativePath = relative(workspaceRoot, filePath);
 	if (relativePath === "" || relativePath.startsWith("..") || isAbsolute(relativePath)) return false;
-	return !relativePath.split(pathSegmentSeparatorPattern).includes(".agent-evals");
+	const segments = relativePath.split(pathSegmentSeparatorPattern);
+	return !segments.includes(".agent-evals") && !segments.includes("node_modules");
 }
 function isAgentEvalsPackageFilePath(filePath) {
 	return agentPackageDirectoryPaths.some((packageDirectoryPath) => {
@@ -6184,6 +6264,9 @@ function registerModuleIsolationHooks() {
 		};
 	} });
 }
+function registerAgentEvalsPackageResolutionHooks() {
+	registerModuleIsolationHooks();
+}
 function clearWorkspaceRequireCacheOnce(context) {
 	if (clearedRequireCacheKeys.has(context.key)) return;
 	clearedRequireCacheKeys.add(context.key);
@@ -6205,432 +6288,6 @@ async function runWithModuleIsolation(context, fn) {
 	return await isolationStorage.run(context, fn);
 }
 //#endregion
-//#region ../runner/src/evalRegistryLoader.ts
-async function loadIsolatedEvalRegistry(params) {
-	return await runWithEvalRegistry(async (registry) => {
-		await runWithModuleIsolation(params.moduleIsolation, async () => {
-			await runInEvalRuntimeScope(params.runtimeScope, async () => {
-				await loadEvalModule(params.evalFilePath, params.sourceFingerprint);
-			});
-		});
-		return registry;
-	});
-}
-async function useIsolatedEvalDefinition(params) {
-	const entry = (await loadIsolatedEvalRegistry(params)).get(params.evalId);
-	if (entry === void 0) throw new Error(`Eval "${params.evalId}" was not registered after importing ${params.evalFilePath}`);
-	return await entry.use(async (evalDef) => {
-		return await params.use(evalDef);
-	});
-}
-//#endregion
-//#region ../runner/src/freshness.ts
-/**
-* Derive eval freshness from the latest run, current eval-file fingerprint,
-* current git commit, and an age threshold.
-*/
-function deriveEvalFreshness(params) {
-	const { latestRun, gitState, currentEvalSourceFingerprint, staleAfterDays, now = /* @__PURE__ */ new Date() } = params;
-	const stale = latestRun?.evalSourceFingerprint !== void 0 && latestRun.evalSourceFingerprint !== null && currentEvalSourceFingerprint !== null && currentEvalSourceFingerprint !== latestRun.evalSourceFingerprint;
-	const latestRunCommitSha = latestRun?.commitSha;
-	if (latestRunCommitSha === void 0 || latestRunCommitSha === null) return {
-		freshnessStatus: stale ? "stale" : "fresh",
-		stale,
-		outdated: false
-	};
-	if (gitState.commitSha === null) return {
-		freshnessStatus: stale ? "stale" : "fresh",
-		stale,
-		outdated: false
-	};
-	if (latestRunCommitSha === gitState.commitSha) return {
-		freshnessStatus: stale ? "stale" : "fresh",
-		stale,
-		outdated: false
-	};
-	const latestRunStartedAt = new Date(latestRun?.startedAt ?? "").getTime();
-	if (!Number.isFinite(latestRunStartedAt)) return {
-		freshnessStatus: stale ? "stale" : "fresh",
-		stale,
-		outdated: false
-	};
-	const outdated = now.getTime() - latestRunStartedAt >= staleAfterDays * 24 * 60 * 60 * 1e3;
-	return {
-		freshnessStatus: stale ? "stale" : outdated ? "outdated" : "fresh",
-		stale,
-		outdated
-	};
-}
-/** Return the timestamp used when ordering and displaying a run recency. */
-function getRunFreshnessTimestamp(manifest) {
-	return manifest.endedAt ?? manifest.startedAt;
-}
-//#endregion
-//#region ../runner/src/manualInput/walker.ts
-function isObject(value) {
-	return typeof value === "object" && value !== null;
-}
-function getZodDef(schema) {
-	if (!isObject(schema)) return null;
-	const zodHolder = schema._zod;
-	if (!isObject(zodHolder)) return null;
-	const def = zodHolder.def;
-	if (!isObject(def)) return null;
-	if (typeof def.type !== "string") return null;
-	return {
-		...def,
-		type: def.type
-	};
-}
-function getDescription(schema) {
-	if (!isObject(schema)) return void 0;
-	const description = schema.description;
-	return typeof description === "string" ? description : void 0;
-}
-function getInnerSchema(def) {
-	return def.innerType;
-}
-function getChecks(def) {
-	const checks = def.checks;
-	if (!Array.isArray(checks)) return [];
-	const out = [];
-	for (const check of checks) {
-		if (!isObject(check)) continue;
-		const zodHolder = check._zod;
-		if (!isObject(zodHolder)) continue;
-		const checkDef = zodHolder.def;
-		if (!isObject(checkDef)) continue;
-		if (typeof checkDef.check !== "string") continue;
-		out.push({
-			...checkDef,
-			check: checkDef.check
-		});
-	}
-	return out;
-}
-function findCheck(checks, name) {
-	return checks.find((check) => check.check === name);
-}
-function unwrap(schema) {
-	let current = schema;
-	let required = true;
-	let defaultValue = void 0;
-	for (let depth = 0; depth < 8; depth += 1) {
-		const def = getZodDef(current);
-		if (!def) return null;
-		if (def.type === "optional" || def.type === "nullable") {
-			required = false;
-			current = getInnerSchema(def);
-			continue;
-		}
-		if (def.type === "nullish") {
-			required = false;
-			current = getInnerSchema(def);
-			continue;
-		}
-		if (def.type === "default" || def.type === "prefault") {
-			const raw = def.defaultValue;
-			if (typeof raw === "function") defaultValue = Reflect.apply(raw, void 0, []);
-			else defaultValue = raw;
-			current = getInnerSchema(def);
-			continue;
-		}
-		if (def.type === "readonly" || def.type === "pipe") {
-			current = getInnerSchema(def) ?? def.in;
-			continue;
-		}
-		return {
-			schema: current,
-			def,
-			required,
-			defaultValue
-		};
-	}
-	return null;
-}
-function humaniseKey(key) {
-	const spaced = key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
-	if (!spaced) return key;
-	const lowered = spaced.toLowerCase();
-	return lowered.charAt(0).toUpperCase() + lowered.slice(1);
-}
-function normaliseSelectOptions(raw) {
-	if (!raw) return void 0;
-	return raw.map((entry) => {
-		if (typeof entry === "string") return {
-			value: entry,
-			label: entry
-		};
-		return {
-			value: entry.value,
-			label: entry.label ?? entry.value
-		};
-	});
-}
-function enumOptionsFromEntries(def) {
-	const entries = def.entries;
-	if (!isObject(entries)) return null;
-	const out = [];
-	for (const [label, value] of Object.entries(entries)) if (typeof value === "string") out.push({
-		value,
-		label
-	});
-	else if (typeof value === "number") out.push({
-		value: String(value),
-		label
-	});
-	else return null;
-	return out;
-}
-function literalUnionOptions(def) {
-	const options = def.options;
-	if (!Array.isArray(options)) return null;
-	const out = [];
-	for (const option of options) {
-		const optDef = getZodDef(option);
-		if (optDef?.type !== "literal") return null;
-		const values = optDef.values;
-		if (!Array.isArray(values) || values.length !== 1) return null;
-		const value = values[0];
-		if (typeof value === "string") out.push({
-			value,
-			label: value
-		});
-		else if (typeof value === "number") {
-			const stringValue = String(value);
-			out.push({
-				value: stringValue,
-				label: stringValue
-			});
-		} else return null;
-	}
-	return out.length > 0 ? out : null;
-}
-function literalSelectOptions(def) {
-	const values = def.values;
-	if (!Array.isArray(values)) return null;
-	const out = [];
-	for (const value of values) if (typeof value === "string") out.push({
-		value,
-		label: value
-	});
-	else if (typeof value === "number") {
-		const stringValue = String(value);
-		out.push({
-			value: stringValue,
-			label: stringValue
-		});
-	} else return null;
-	return out;
-}
-function readStringChecks(def) {
-	const checks = getChecks(def);
-	const out = {};
-	const min = findCheck(checks, "min_length");
-	if (min && typeof min.minimum === "number") out.minLength = min.minimum;
-	const max = findCheck(checks, "max_length");
-	if (max && typeof max.maximum === "number") out.maxLength = max.maximum;
-	return out;
-}
-const integerNumberFormats = new Set([
-	"int",
-	"safeint",
-	"int32",
-	"uint32",
-	"int64",
-	"uint64"
-]);
-function readNumberChecks(def) {
-	const checks = getChecks(def);
-	const out = {};
-	const gt = findCheck(checks, "greater_than");
-	if (gt && typeof gt.value === "number" && gt.inclusive === true) out.min = gt.value;
-	const lt = findCheck(checks, "less_than");
-	if (lt && typeof lt.value === "number" && lt.inclusive === true) out.max = lt.value;
-	const format = findCheck(checks, "number_format");
-	if (format && typeof format.format === "string" && integerNumberFormats.has(format.format)) out.integer = true;
-	return out;
-}
-function buildField(key, fieldSchema, override) {
-	const unwrapped = unwrap(fieldSchema);
-	if (!unwrapped) return Result.err(/* @__PURE__ */ new Error(`manualInput: field "${key}" uses an unsupported Zod schema (could not introspect)`));
-	const inner = unwrapped.def;
-	const description = override?.description ?? getDescription(unwrapped.schema);
-	const base = {
-		key,
-		label: override?.label ?? humaniseKey(key),
-		description,
-		placeholder: override?.placeholder,
-		required: unwrapped.required,
-		defaultValue: override?.defaultValue !== void 0 ? override.defaultValue : unwrapped.defaultValue
-	};
-	if (override?.asJson === true) {
-		const rows = override.rows;
-		return Result.ok({
-			...base,
-			kind: "json",
-			rows
-		});
-	}
-	if (override?.asFile === true) return Result.ok({
-		...base,
-		kind: "file",
-		accept: override.accept,
-		maxSizeBytes: override.maxSizeBytes
-	});
-	const overrideOptions = normaliseSelectOptions(override?.options);
-	if (overrideOptions) return Result.ok({
-		...base,
-		kind: "select",
-		options: overrideOptions
-	});
-	switch (inner.type) {
-		case "string": {
-			const checks = readStringChecks(inner);
-			if (override?.multiline === true) return Result.ok({
-				...base,
-				kind: "multiline",
-				rows: override.rows,
-				minLength: checks.minLength,
-				maxLength: checks.maxLength
-			});
-			return Result.ok({
-				...base,
-				kind: "text",
-				minLength: checks.minLength,
-				maxLength: checks.maxLength
-			});
-		}
-		case "number":
-		case "int":
-		case "bigint": {
-			const checks = readNumberChecks(inner);
-			return Result.ok({
-				...base,
-				kind: "number",
-				min: checks.min,
-				max: checks.max,
-				integer: checks.integer
-			});
-		}
-		case "boolean": return Result.ok({
-			...base,
-			kind: "boolean"
-		});
-		case "enum": {
-			const options = enumOptionsFromEntries(inner);
-			if (options) return Result.ok({
-				...base,
-				kind: "select",
-				options
-			});
-			return Result.ok({
-				...base,
-				kind: "json",
-				rows: override?.rows
-			});
-		}
-		case "literal": {
-			const options = literalSelectOptions(inner);
-			if (options && options.length > 0) return Result.ok({
-				...base,
-				kind: "select",
-				options
-			});
-			return Result.ok({
-				...base,
-				kind: "json",
-				rows: override?.rows
-			});
-		}
-		case "union": {
-			const options = literalUnionOptions(inner);
-			if (options) return Result.ok({
-				...base,
-				kind: "select",
-				options
-			});
-			return Result.ok({
-				...base,
-				kind: "json",
-				rows: override?.rows
-			});
-		}
-		default: return Result.ok({
-			...base,
-			kind: "json",
-			rows: override?.rows
-		});
-	}
-}
-function getObjectShape(schema) {
-	const def = getZodDef(schema);
-	if (!def) return null;
-	if (def.type !== "object") return null;
-	const shape = def.shape;
-	if (!isObject(shape)) return null;
-	return shape;
-}
-/**
-* Walk an eval's `manualInput` configuration and produce the wire-format
-* descriptor consumed by the web UI. The schema must resolve to a top-level
-* `z.object(...)`; nested objects, arrays, unions, and other unsupported
-* shapes inside fields fall back to the JSON textarea widget.
-*
-* Returns a `Result` so the caller (eval discovery) can surface a discovery
-* issue without throwing when the schema is incompatible.
-*/
-function buildManualInputDescriptor(config) {
-	const shape = getObjectShape(config.schema);
-	if (!shape) return Result.err(/* @__PURE__ */ new Error("manualInput.schema must be a top-level z.object(...). Wrap nested types in an object schema."));
-	const overrides = {};
-	const rawOverrides = config.fields;
-	if (rawOverrides) {
-		for (const [key, override] of Object.entries(rawOverrides)) if (override) overrides[key] = override;
-	}
-	const fields = [];
-	for (const [key, fieldSchema] of Object.entries(shape)) {
-		const fieldResult = buildField(key, fieldSchema, overrides[key]);
-		if (fieldResult.error) return fieldResult.errorResult();
-		fields.push(fieldResult.value);
-	}
-	return Result.ok({
-		title: config.title,
-		description: config.description,
-		submitLabel: config.submitLabel,
-		fields
-	});
-}
-/**
-* Resolve an eval's `manualInput` Zod schema against a raw user submission.
-* Returns the parsed value typed against the eval's `TInput` generic, or a
-* structured `Error` carrying the Zod issues for the caller to surface.
-*/
-function parseManualInputValues(config, raw) {
-	const parsed = config.schema.safeParse(raw);
-	if (!parsed.success) return Result.err(new ManualInputValidationError(parsed.error.issues.map(formatIssue)));
-	return Result.ok(parsed.data);
-}
-/**
-* Error thrown / returned when manual-input values fail validation against
-* the eval's `manualInput.schema`. Carries the structured Zod issues so the
-* CLI and HTTP layers can surface them per-field.
-*/
-var ManualInputValidationError = class extends Error {
-	issues;
-	constructor(issues) {
-		super(issues.length === 0 ? "manualInput validation failed" : `manualInput validation failed: ${issues.map((issue) => issue.path ? `${issue.path}: ${issue.message}` : issue.message).join("; ")}`);
-		this.name = "ManualInputValidationError";
-		this.issues = issues;
-	}
-};
-function formatIssue(issue) {
-	return {
-		path: issue.path.map((segment) => typeof segment === "string" || typeof segment === "number" ? String(segment) : "").filter((segment) => segment !== "").join("."),
-		message: issue.message
-	};
-}
-//#endregion
 //#region ../runner/src/outputArtifacts.ts
 const mimeTypeExtensionMap = {
 	"application/json": ".json",
@@ -6776,254 +6433,23 @@ function resolveTracePresentation(spans, globalTraceDisplay, evalTraceDisplay) {
 	};
 }
 //#endregion
-//#region ../runner/src/runMaintenance.ts
-async function persistRunState(runState) {
-	await writeFile(join(runState.runDir, "summary.json"), JSON.stringify(runState.summary, null, 2));
-	await writeFile(join(runState.runDir, "run.json"), JSON.stringify(runState.manifest, null, 2));
-	const casesJsonl = runState.cases.map((c) => JSON.stringify(c)).join("\n");
-	await writeFile(join(runState.runDir, "cases.jsonl"), casesJsonl);
-}
-/**
-* Recompute a persisted case's status after score definitions changed.
-*
-* Pass/fail gates are per-score: a case fails when any score with a declared
-* `passThreshold` reports a numeric value below that threshold. Scores
-* without a threshold are informational and never gate. Cancelled and
-* errored cases retain their terminal status.
-*/
-function recomputePersistedCaseStatus(caseRow, caseDetail, scoreThresholds) {
-	if (caseRow.status === "cancelled") return "cancelled";
-	if (caseDetail?.error !== null && caseDetail?.error !== void 0) return "error";
-	if ((caseDetail?.assertionFailures.length ?? 0) > 0) return "fail";
-	for (const [key, passThreshold] of scoreThresholds) {
-		const rawValue = caseRow.columns[key] ?? caseDetail?.columns[key];
-		if (typeof rawValue !== "number") continue;
-		if (rawValue < passThreshold) return "fail";
-	}
-	return caseRow.status === "error" ? "error" : "pass";
-}
-function runTouchesEval(params) {
-	if (params.caseRows.some((caseRow) => caseRow.evalKey === params.evalKey)) return true;
-	if (params.target.mode === "all") return params.evalExists;
-	if (params.target.mode === "evalIds") return params.target.evalKeys?.includes(params.evalKey) ?? false;
-	return false;
-}
-async function deleteTemporaryRuns(params) {
-	let deletedRuns = 0;
-	for (const [runId, run] of [...params.runs]) {
-		if (run.manifest.temporary !== true) continue;
-		if (run.manifest.status === "running") {
-			const endedAt = /* @__PURE__ */ new Date();
-			run.manifest.status = "cancelled";
-			run.manifest.endedAt = endedAt.toISOString();
-			run.summary.status = "cancelled";
-			run.summary.totalDurationMs = endedAt.getTime() - new Date(run.manifest.startedAt).getTime();
-			params.cancelRunningRun(run);
-		}
-		params.runs.delete(runId);
-		await rm(run.runDir, {
-			recursive: true,
-			force: true
-		});
-		deletedRuns += 1;
-	}
-	return deletedRuns;
-}
-async function recomputeEvalStatusesInRuns(params) {
-	let updatedRuns = 0;
-	for (const run of params.runs) {
-		if (!runTouchesEval({
-			target: run.manifest.target,
-			caseRows: run.cases,
-			evalKey: params.evalKey,
-			evalExists: params.evalExists
-		})) continue;
-		if (run.manifest.status === "running") continue;
-		let changed = false;
-		for (const caseRow of run.cases) {
-			if (caseRow.evalKey !== params.evalKey) continue;
-			const caseDetail = run.caseDetails.get(getCaseRowCaseKey(caseRow));
-			const nextStatus = recomputePersistedCaseStatus(caseRow, caseDetail, params.scoreThresholds);
-			if (caseRow.status === nextStatus) continue;
-			caseRow.status = nextStatus;
-			if (caseDetail) {
-				caseDetail.status = nextStatus;
-				await params.persistCaseDetail(run.runDir, caseDetail);
-			}
-			changed = true;
-		}
-		if (!changed) continue;
-		const derivedSummary = deriveScopedSummaryFromCases({ caseRows: run.cases });
-		run.summary.totalCases = derivedSummary.totalCases;
-		run.summary.passedCases = derivedSummary.passedCases;
-		run.summary.failedCases = derivedSummary.failedCases;
-		run.summary.errorCases = derivedSummary.errorCases;
-		run.summary.cancelledCases = derivedSummary.cancelledCases;
-		await persistRunState(run);
-		updatedRuns += 1;
-	}
-	return updatedRuns;
-}
-//#endregion
-//#region ../runner/src/runPersistence.ts
-const SHORT_ID_PATTERN = /^r(\d+)$/;
-/**
-* Generate a filesystem-safe, sortable run id combining a UTC timestamp
-* with a short random suffix.
-*/
-function generateRunId() {
-	const now = /* @__PURE__ */ new Date();
-	const pad = (n) => String(n).padStart(2, "0");
-	return `${`${String(now.getUTCFullYear())}-${pad(now.getUTCMonth() + 1)}-${pad(now.getUTCDate())}T${pad(now.getUTCHours())}-${pad(now.getUTCMinutes())}-${pad(now.getUTCSeconds())}Z`}_${Math.random().toString(36).slice(2, 8)}`;
-}
-function parseShortIdNum(shortId) {
-	if (shortId === void 0) return null;
-	const match = SHORT_ID_PATTERN.exec(shortId);
-	if (!match) return null;
-	const num = Number(match[1]);
-	if (!Number.isFinite(num)) return null;
-	return num;
-}
-/**
-* Return the next `shortId` number to assign based on the existing
-* loaded snapshots. Legacy runs that don't match the `r\d+` format are
-* ignored.
-*/
-function nextShortIdFromSnapshots(snapshots) {
-	let maxNum = -1;
-	for (const snapshot of snapshots) {
-		const num = parseShortIdNum(snapshot.manifest.shortId);
-		if (num !== null && num > maxNum) maxNum = num;
-	}
-	return maxNum + 1;
-}
-async function loadPersistedRunSnapshots(localStateDir) {
-	const runsDir = join(localStateDir, "runs");
-	const entriesResult = await resultify(() => readdir(runsDir, { withFileTypes: true }));
-	if (entriesResult.error) return [];
-	const snapshots = [];
-	const runDirs = entriesResult.value.filter((entry) => entry.isDirectory()).map((entry) => join(runsDir, entry.name)).toSorted();
-	for (const runDir of runDirs) {
-		const snapshot = await loadPersistedRunSnapshot(runDir);
-		if (!snapshot) continue;
-		snapshots.push(snapshot);
-	}
-	return snapshots;
-}
-async function persistCaseDetail(runDir, caseDetail, fileId = caseDetail.caseId) {
-	await writeFile(join(runDir, "case-details", `${encodeCaseDetailFileName(fileId)}.json`), JSON.stringify(caseDetail, null, 2));
-}
-function getLastRunStatuses(params) {
-	const latestRunInfos = getLatestRunInfos(params);
-	return new Map([...latestRunInfos].map(([evalId, info]) => [evalId, info.status]));
-}
-/**
-* Return the latest scoped run metadata for each eval based on persisted and
-* in-memory runs.
-*/
-function getLatestRunInfos(params) {
-	const { runs, knownEvals } = params;
-	const knownEvalMetas = [...knownEvals];
-	const manualScoreKeysByEval = new Map(knownEvalMetas.map((evalMeta) => [evalMeta.key, evalMeta.columnDefs.filter((columnDef) => columnDef.isManualScore === true).map((columnDef) => columnDef.key)]));
-	const orderedRuns = [...runs].toSorted((a, b) => new Date(getRunFreshnessTimestamp(a.manifest)).getTime() - new Date(getRunFreshnessTimestamp(b.manifest)).getTime());
-	const latestRunInfos = /* @__PURE__ */ new Map();
-	for (const run of orderedRuns) for (const evalKey of getRunEvalKeys(run, knownEvalMetas)) latestRunInfos.set(evalKey, {
-		status: getEvalStatusForRun(run, evalKey, manualScoreKeysByEval.get(evalKey) ?? []),
-		startedAt: getRunFreshnessTimestamp(run.manifest),
-		commitSha: run.manifest.commitSha ?? null,
-		evalSourceFingerprint: run.manifest.evalSourceFingerprints[evalKey] ?? null
-	});
-	return latestRunInfos;
-}
-function toLastRunStatus$1(status) {
-	return status === "pending" ? null : status;
-}
-async function loadPersistedRunSnapshot(runDir) {
-	const manifest = await readParsedJsonFile(join(runDir, "run.json"), { safeParse: runManifestSchema.safeParse.bind(runManifestSchema) });
-	if (!manifest) return null;
-	const summary = await readParsedJsonFile(join(runDir, "summary.json"), { safeParse: runSummarySchema.safeParse.bind(runSummarySchema) });
-	if (!summary) return null;
-	return {
-		runDir,
-		manifest,
-		summary,
-		cases: await readCaseRows(runDir),
-		caseDetails: await readCaseDetails(runDir)
-	};
-}
-async function readParsedJsonFile(filePath, schema) {
-	const fileResult = await resultify(() => readFile(filePath, "utf-8"));
-	if (fileResult.error) return null;
-	const jsonResult = resultify(() => JSON.parse(fileResult.value));
-	if (jsonResult.error) return null;
-	const parsed = schema.safeParse(jsonResult.value);
-	if (!parsed.success) return null;
-	return parsed.data;
-}
-async function readCaseRows(runDir) {
-	const fileResult = await resultify(() => readFile(join(runDir, "cases.jsonl"), "utf-8"));
-	if (fileResult.error) return [];
-	const rows = [];
-	for (const rawLine of fileResult.value.split("\n")) {
-		const line = rawLine.trim();
-		if (line.length === 0) continue;
-		const jsonResult = resultify(() => JSON.parse(line));
-		if (jsonResult.error) continue;
-		const parsed = caseRowSchema.safeParse(jsonResult.value);
-		if (!parsed.success) continue;
-		rows.push(parsed.data);
-	}
-	return rows;
-}
-async function readCaseDetails(runDir) {
-	const detailsDir = join(runDir, "case-details");
-	const entriesResult = await resultify(() => readdir(detailsDir, { withFileTypes: true }));
-	if (entriesResult.error) return /* @__PURE__ */ new Map();
-	const caseDetails = /* @__PURE__ */ new Map();
-	for (const entry of entriesResult.value) {
-		if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-		const detail = await readParsedJsonFile(join(detailsDir, entry.name), { safeParse: caseDetailSchema.safeParse.bind(caseDetailSchema) });
-		if (!detail) continue;
-		caseDetails.set(detail.caseKey ?? detail.caseId, detail);
-	}
-	return caseDetails;
-}
-function getRunEvalKeys(run, knownEvals) {
-	const knownEvalMetas = [...knownEvals];
-	const evalKeys = /* @__PURE__ */ new Set();
-	for (const caseRow of run.cases) if (caseRow.evalKey !== void 0) evalKeys.add(caseRow.evalKey);
-	if (run.manifest.target.mode === "evalIds") for (const evalKey of run.manifest.target.evalKeys ?? []) evalKeys.add(evalKey);
-	else if (run.manifest.target.mode === "all" && evalKeys.size === 0) for (const evalMeta of knownEvalMetas) evalKeys.add(evalMeta.key);
-	return [...evalKeys];
-}
-function getEvalStatusForRun(run, evalKey, manualScoreKeys) {
-	const evalCases = run.cases.filter((caseRow) => caseRow.evalKey === evalKey);
-	if (evalCases.length > 0) {
-		if (hasPendingManualScores(evalCases, manualScoreKeys)) return "unscored";
-		return toLastRunStatus$1(deriveStatusFromCaseRows({ caseRows: evalCases }));
-	}
-	return toLastRunStatus$1(deriveStatusFromChildStatuses({
-		statuses: [],
-		lifecycleStatus: run.manifest.status
-	}));
-}
-function hasPendingManualScores(caseRows, manualScoreKeys) {
-	if (manualScoreKeys.length === 0) return false;
-	return caseRows.some((caseRow) => manualScoreKeys.some((key) => {
-		const value = caseRow.columns[key];
-		return typeof value !== "number" || !Number.isFinite(value);
-	}));
-}
-function encodeCaseDetailFileName(caseId) {
-	return encodeURIComponent(caseId);
-}
-//#endregion
 //#region ../runner/src/stackFormatting.ts
 const orphanedAnsiSgrPattern = /\[(?:\d{1,3}(?:;\d{1,3})*)?m/g;
 function stripTerminalControlCodes(value) {
 	return stripVTControlCharacters(value).replaceAll(orphanedAnsiSgrPattern, "");
 }
 //#endregion
+//#region ../runner/src/caseChildProtocol.ts
+function isCaseChildParentMessage(value) {
+	return typeof value === "object" && value !== null && "type" in value && value.type === "start" && "context" in value;
+}
+function isCaseChildMessage(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("type" in value) || typeof value.type !== "string") return false;
+	if (value.type === "done") return "result" in value;
+	return value.type === "error" && "message" in value;
+}
+//#endregion
 //#region ../runner/src/runExecution.ts
 function filterEvalCases(cases, caseIds) {
 	if (!caseIds || caseIds.length === 0) return cases;
@@ -7335,645 +6761,4 @@ function toAssertionFailure(message, error = void 0, nameOverride = void 0) {
 	};
 }
 //#endregion
-//#region ../runner/src/runQueue.ts
-async function executeQueuedCases(params) {
-	const { queuedCases, concurrency, globalTraceDisplay } = params;
-	let nextCaseIndex = 0;
-	let workerError = void 0;
-	const workerCount = Math.min(concurrency, queuedCases.length);
-	const workers = Array.from({ length: workerCount }, async () => {
-		while (workerError === void 0) {
-			const queuedCase = queuedCases[nextCaseIndex];
-			nextCaseIndex += 1;
-			if (queuedCase === void 0) return;
-			try {
-				await executeQueuedCase({
-					queuedCase,
-					globalTraceDisplay
-				});
-			} catch (error) {
-				workerError = error instanceof Error ? error : new Error(String(error));
-				return;
-			}
-		}
-	});
-	await Promise.all(workers);
-	if (workerError instanceof Error) throw workerError;
-	if (workerError !== void 0) throw new Error(typeof workerError === "string" ? workerError : typeof workerError === "number" || typeof workerError === "boolean" || typeof workerError === "bigint" ? String(workerError) : workerError === null ? "null" : "Unknown queue worker error");
-}
-async function executeQueuedCase(params) {
-	const { queuedCase, globalTraceDisplay } = params;
-	const startTime = Date.now();
-	const result = await queuedCase.execute({
-		globalTraceDisplay,
-		startTime
-	});
-	await queuedCase.onComplete(result);
-}
-//#endregion
-//#region ../runner/src/tags.ts
-function getInvalidTagMessages(params) {
-	return (params.tags ?? []).flatMap((tag) => {
-		const validation = validateEvalTagName(tag);
-		return validation.ok ? [] : [`${params.source} tag "${tag}" is invalid: ${validation.message}`];
-	});
-}
-/** Resolve effective eval-level tags and discovery issues for one eval. */
-function resolveEvalTags(params) {
-	const configTags = params.configTags ?? [];
-	const removeTags = params.evalDef.removeTags ?? [];
-	const messages = [
-		...getInvalidTagMessages({
-			tags: configTags,
-			source: "config"
-		}),
-		...getInvalidTagMessages({
-			tags: params.evalDef.tags,
-			source: "eval"
-		}),
-		...getInvalidTagMessages({
-			tags: removeTags,
-			source: "removeTags"
-		})
-	];
-	const globalTagSet = new Set(configTags);
-	for (const tag of removeTags) if (!globalTagSet.has(tag)) messages.push(`removeTags tag "${tag}" is not defined in AgentEvalsConfig.tags.`);
-	const removeTagSet = new Set(removeTags);
-	return {
-		tags: dedupeEvalTags([...configTags.filter((tag) => !removeTagSet.has(tag)), ...params.evalDef.tags ?? []]),
-		issues: messages.map((message) => ({
-			type: "invalid-tags",
-			severity: "error",
-			filePath: params.filePath,
-			evalId: params.evalId,
-			message: `Invalid tags for eval "${params.evalId}" in ${params.filePath}: ${message}`
-		}))
-	};
-}
-/** Return effective case tags or throw when authored case tags are invalid. */
-function resolveCaseTags(params) {
-	const messages = getInvalidTagMessages({
-		tags: params.evalCase.tags,
-		source: `case "${params.evalCase.id}"`
-	});
-	if (messages.length > 0) throw new Error(`Invalid tags for case "${params.evalCase.id}" in ${params.filePath}#${params.evalId}: ${messages.join("; ")}`);
-	return dedupeEvalTags([...params.evalTags, ...params.evalCase.tags ?? []]);
-}
-/** Validate CLI/API tags filters and return the first error message. */
-function validateTagsFilters(filters) {
-	for (const filter of filters ?? []) {
-		const error = validateTagsFilterExpression(filter);
-		if (error !== null) return `Invalid --tags-filter "${filter}": ${error}`;
-	}
-	return null;
-}
-/** Filter cases by Vitest-style tag expressions. */
-function filterEvalCasesByTags(cases, tagsFilter) {
-	if (tagsFilter === void 0 || tagsFilter.length === 0) return [...cases];
-	return cases.filter((evalCase) => matchesTagsFilter({
-		tags: evalCase.tags,
-		filters: tagsFilter
-	}));
-}
-/** Return whether eval-level tags alone satisfy the run's tag filters. */
-function evalTagsMatchFilter(params) {
-	return matchesTagsFilter({
-		tags: params.tags,
-		filters: params.tagsFilter
-	});
-}
-//#endregion
-//#region ../runner/src/targeting.ts
-function escapeRegex(value) {
-	return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
-}
-function globToRegex(pattern) {
-	const normalized = pattern.replaceAll("\\", "/");
-	let regex = "^";
-	for (let i = 0; i < normalized.length; i++) {
-		const char = normalized[i];
-		const next = normalized[i + 1];
-		if (char === "*" && next === "*") {
-			regex += ".*";
-			i++;
-		} else if (char === "*") regex += "[^/]*";
-		else if (char === "?") regex += "[^/]";
-		else regex += escapeRegex(char ?? "");
-	}
-	regex += "$";
-	return new RegExp(regex);
-}
-function fileMatches(pattern, filePath) {
-	const normalizedPattern = pattern.replaceAll("\\", "/");
-	if (normalizedPattern === filePath) return true;
-	return globToRegex(normalizedPattern).test(filePath);
-}
-function matchesFiles(evalMeta, files) {
-	if (files === void 0 || files.length === 0) return true;
-	return files.some((file) => fileMatches(file, evalMeta.filePath));
-}
-function matchesEvalIds(evalMeta, evalIds) {
-	if (evalIds === void 0 || evalIds.length === 0) return true;
-	return evalIds.includes(evalMeta.id);
-}
-function matchesEvalKeys(evalMeta, evalKeys) {
-	if (evalKeys === void 0 || evalKeys.length === 0) return true;
-	return evalKeys.includes(evalMeta.key);
-}
-/** Return the discovered evals selected by a run target. */
-function getTargetEvals(params) {
-	const { target } = params.request;
-	return [...params.evals].filter((evalMeta) => matchesEvalKeys(evalMeta, target.evalKeys)).filter((evalMeta) => matchesEvalIds(evalMeta, target.evalIds)).filter((evalMeta) => matchesFiles(evalMeta, target.files)).toSorted((a, b) => a.filePath.localeCompare(b.filePath));
-}
-/** Resolve which exact eval keys a run request can affect. */
-function getTargetEvalKeys(params) {
-	return getTargetEvals({
-		evals: params.sortedEvals,
-		request: params.request
-	}).map((evalMeta) => evalMeta.key);
-}
-//#endregion
-//#region ../runner/src/runOrchestration.ts
-function toOptionalSourceFingerprint(sourceFingerprint) {
-	return sourceFingerprint.length > 0 ? sourceFingerprint : void 0;
-}
-function buildCaseModuleIsolation(params) {
-	return {
-		key: [
-			params.runId,
-			params.evalKey,
-			params.caseId,
-			`trial-${String(params.trial)}`
-		].join(":"),
-		workspaceRoot: params.workspaceRoot
-	};
-}
-function buildEvalPreparationModuleIsolation(params) {
-	return {
-		key: [
-			params.runId,
-			params.evalKey,
-			"prepare"
-		].join(":"),
-		workspaceRoot: params.workspaceRoot
-	};
-}
-/**
-* Ranks case statuses from worst to best. Used to order trial attempts so the
-* pessimistic (`lowestScore`) strategy can pick the worst attempt. Any
-* non-terminal status outside `pass`/`fail`/`error` is treated as indistinct
-* from `fail` for comparison purposes.
-*/
-function statusRank(status) {
-	if (status === "pass") return 2;
-	if (status === "error") return 0;
-	return 1;
-}
-/**
-* Returns the minimum numeric value across the declared score columns for a
-* trial, or `-Infinity` when no score has a numeric value. Used as a
-* tiebreaker between trials that share the same status.
-*/
-function minScoreValue(caseRow, scoreKeys) {
-	let min = Number.POSITIVE_INFINITY;
-	for (const key of scoreKeys) {
-		const v = caseRow.columns[key];
-		if (typeof v === "number" && Number.isFinite(v)) {
-			if (v < min) min = v;
-		}
-	}
-	return Number.isFinite(min) ? min : Number.NEGATIVE_INFINITY;
-}
-function compareTrialResults(left, right, scoreKeys) {
-	const statusDiff = statusRank(left.caseRow.status) - statusRank(right.caseRow.status);
-	if (statusDiff !== 0) return statusDiff;
-	const scoreDiff = minScoreValue(left.caseRow, scoreKeys) - minScoreValue(right.caseRow, scoreKeys);
-	if (scoreDiff !== 0) return scoreDiff;
-	return left.caseRow.trial - right.caseRow.trial;
-}
-function pickWinningTrial(params) {
-	const orderedAttempts = [...params.attempts].toSorted((left, right) => compareTrialResults(left, right, params.scoreKeys));
-	if (params.strategy === "lowestScore") {
-		const [lowestAttempt] = orderedAttempts;
-		if (lowestAttempt === void 0) throw new Error("Expected at least one trial attempt");
-		return lowestAttempt;
-	}
-	const medianAttempt = orderedAttempts[Math.floor((orderedAttempts.length - 1) / 2)];
-	if (medianAttempt === void 0) throw new Error("Expected at least one trial attempt");
-	return medianAttempt;
-}
-function formatUnknownErrorDetails(error) {
-	if (error instanceof Error) return error.stack ?? error.message;
-	if (typeof error === "string") return error;
-	return String(error);
-}
-function findDuplicateCaseIds(cases) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const evalCase of cases) counts.set(evalCase.id, (counts.get(evalCase.id) ?? 0) + 1);
-	return [...counts].filter(([, count]) => count > 1).map(([caseId]) => caseId).toSorted();
-}
-function throwIfDiscoveryIssues(issues) {
-	if (issues.length === 0) return;
-	throw new Error(issues.map((issue) => issue.message).join("\n"));
-}
-function findAmbiguousTargetCaseIds(preparedEvals) {
-	const ownersByCaseId = /* @__PURE__ */ new Map();
-	for (const preparedEval of preparedEvals) for (const preparedCase of preparedEval.preparedCases) {
-		const owners = ownersByCaseId.get(preparedCase.caseId) ?? /* @__PURE__ */ new Set();
-		owners.add(`${preparedEval.evalMeta.filePath}#${preparedEval.evalMeta.id}`);
-		ownersByCaseId.set(preparedCase.caseId, owners);
-	}
-	return [...ownersByCaseId].filter(([, owners]) => owners.size > 1).map(([caseId, owners]) => `${caseId} (${[...owners].join(", ")})`);
-}
-function buildRunErrorMessage(errors) {
-	return errors.map((entry) => {
-		const [firstLine, ...detailLines] = entry.details.split("\n");
-		const messageLine = firstLine?.trim() ?? "Unknown error";
-		const details = detailLines.join("\n").trim();
-		if (details.length === 0) return `[${entry.evalId}] ${messageLine}`;
-		return `[${entry.evalId}] ${messageLine}\n${details}`;
-	}).join("\n");
-}
-async function finalizePreparedCase(params) {
-	const { runState, runDir, preparedEval, preparedCase, onCaseFinished, emitEvent } = params;
-	if (preparedCase.finalized || preparedCase.trialResults.length === 0) return;
-	preparedCase.finalized = true;
-	const winningTrial = pickWinningTrial({
-		strategy: runState.manifest.trialSelection,
-		attempts: preparedCase.trialResults,
-		scoreKeys: preparedEval.scoreKeys
-	});
-	if (winningTrial.bufferedCacheStore !== null) await winningTrial.bufferedCacheStore.commit();
-	const artifactFileId = getCaseArtifactFileId(runState, winningTrial.caseRow);
-	runState.cases.push(winningTrial.caseRow);
-	runState.caseDetails.set(getCaseRowCaseKey(winningTrial.caseRow), winningTrial.caseDetail);
-	if (winningTrial.caseRow.status === "pass") runState.summary.passedCases++;
-	else if (winningTrial.caseRow.status === "error") runState.summary.errorCases++;
-	else runState.summary.failedCases++;
-	await writeFile(join(runDir, "traces", `${encodeURIComponent(artifactFileId)}.json`), JSON.stringify(winningTrial.caseDetail.trace, null, 2));
-	await persistCaseDetail(runDir, winningTrial.caseDetail, artifactFileId);
-	onCaseFinished?.(winningTrial.caseDetail, winningTrial.caseRow);
-	emitEvent(runState, {
-		type: "case.finished",
-		runId: runState.manifest.id,
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		payload: winningTrial.caseRow
-	});
-	preparedEval.evalCaseRows.push(winningTrial.caseRow);
-}
-function getPreparedCaseOrderKey(caseRow) {
-	return `${caseRow.evalKey ?? caseRow.evalId}\u0000${caseRow.caseId}`;
-}
-function getCaseArtifactFileId(runState, caseRow) {
-	const caseKey = getCaseRowCaseKey(caseRow);
-	return runState.cases.some((existing) => existing.caseId === caseRow.caseId && getCaseRowCaseKey(existing) !== caseKey) ? caseKey : caseRow.caseId;
-}
-function sortCaseRowsByPreparedOrder(caseRows, preparedEvals) {
-	const orderByCase = /* @__PURE__ */ new Map();
-	let order = 0;
-	for (const preparedEval of preparedEvals) for (const preparedCase of preparedEval.preparedCases) {
-		orderByCase.set(`${preparedEval.evalMeta.key}\u0000${preparedCase.caseId}`, order);
-		order++;
-	}
-	caseRows.sort((left, right) => {
-		return (orderByCase.get(getPreparedCaseOrderKey(left)) ?? Number.MAX_SAFE_INTEGER) - (orderByCase.get(getPreparedCaseOrderKey(right)) ?? Number.MAX_SAFE_INTEGER);
-	});
-}
-async function executeRun({ runState, request, runDir, config, cacheStore, lastRunStatusMap, latestRunInfoMap, emitEvent, emitDiscoveryEvent, workspaceRoot, getSourceFingerprint, getConfiguredConcurrency, getSortedEvalMetas, getTargetEvals, onCaseFinished }) {
-	try {
-		const tagsFilterError = validateTagsFilters(request.target.tagsFilter);
-		if (tagsFilterError !== null) throw new Error(tagsFilterError);
-		const targetEvals = getTargetEvals(request);
-		emitEvent(runState, {
-			type: "run.started",
-			runId: runState.manifest.id,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			payload: runState.manifest
-		});
-		const evalErrors = [];
-		const queuedCases = [];
-		const preparedEvals = [];
-		const cacheMode = runState.manifest.cacheMode ?? "use";
-		const cacheEnabled = config.cache?.enabled !== false;
-		const llmCallsConfig = resolveLlmCallsConfig(config.llmCalls);
-		const apiCallsConfig = resolveApiCallsConfig(config.apiCalls);
-		for (const evalMeta of targetEvals) {
-			const evalFilePath = evalMeta.sourceFilePath;
-			const evalModuleIsolation = buildEvalPreparationModuleIsolation({
-				runId: runState.manifest.id,
-				evalKey: evalMeta.key,
-				workspaceRoot
-			});
-			let sourceFingerprint = "";
-			try {
-				sourceFingerprint = getSourceFingerprint(await readFile(evalFilePath, "utf-8"));
-			} catch {
-				sourceFingerprint = "";
-			}
-			if (sourceFingerprint.length > 0) {
-				runState.manifest.evalSourceFingerprints[evalMeta.key] = sourceFingerprint;
-				evalMeta.sourceFingerprint = sourceFingerprint;
-			} else {
-				delete runState.manifest.evalSourceFingerprints[evalMeta.key];
-				evalMeta.sourceFingerprint = null;
-			}
-			try {
-				const entry = (await loadIsolatedEvalRegistry({
-					evalFilePath,
-					sourceFingerprint: toOptionalSourceFingerprint(sourceFingerprint),
-					moduleIsolation: evalModuleIsolation,
-					runtimeScope: "env"
-				})).get(evalMeta.id);
-				if (!entry) {
-					evalErrors.push({
-						evalId: evalMeta.id,
-						details: `Eval "${evalMeta.id}" was not registered after importing ${evalFilePath}`
-					});
-					continue;
-				}
-				await runWithModuleIsolation(evalModuleIsolation, async () => {
-					await runInEvalRuntimeScope("cases", async () => {
-						await entry.use(async (evalDef) => {
-							const evalTagsResult = resolveEvalTags({
-								configTags: config.tags,
-								evalDef,
-								evalId: evalMeta.id,
-								filePath: evalMeta.filePath
-							});
-							throwIfDiscoveryIssues(evalTagsResult.issues);
-							evalMeta.tags = evalTagsResult.tags;
-							if (evalDef.manualInput && evalDef.cases !== void 0) throw new Error(`Eval "${evalMeta.id}" cannot declare both "cases" and "manualInput". Remove one of them.`);
-							let manualInputCase = null;
-							if (evalDef.manualInput) {
-								const manualTags = evalTagsResult.tags;
-								if (!filterEvalCasesByTags([{
-									id: `${evalMeta.id}-manual`,
-									input: {},
-									tags: manualTags
-								}], request.target.tagsFilter).length) {
-									evalMeta.caseCount = 1;
-									evalMeta.caseIds = [`${evalMeta.id}-manual`];
-									return;
-								}
-								const rawValue = request.manualInputs?.[evalMeta.key];
-								if (rawValue === void 0) throw new Error(`Eval "${evalMeta.id}" requires manual input. Provide it via the run modal in the web UI or "--input" / "--input-file" on the CLI.`);
-								const parsed = parseManualInputValues(evalDef.manualInput, rawValue);
-								if (parsed.error) {
-									const formatted = parsed.error.issues.map((issue) => issue.path ? `${issue.path}: ${issue.message}` : issue.message).join("; ");
-									throw new Error(`Invalid manual input for eval "${evalMeta.id}": ${formatted}`);
-								}
-								manualInputCase = {
-									id: `${evalMeta.id}-manual`,
-									input: parsed.value,
-									tags: manualTags
-								};
-							}
-							const evalCases = manualInputCase ? [manualInputCase] : typeof evalDef.cases === "function" && !evalTagsMatchFilter({
-								tags: evalTagsResult.tags,
-								tagsFilter: request.target.tagsFilter
-							}) ? [] : await runWithEvalClock(evalDef.startTime, async () => typeof evalDef.cases === "function" ? await evalDef.cases() : evalDef.cases ?? [], { freezeTime: evalDef.freezeTime });
-							const runnableCases = (manualInputCase ? evalCases : resolveRunnableEvalCases({
-								cases: evalCases,
-								evalId: evalMeta.id
-							})).map((evalCase) => ({
-								...evalCase,
-								tags: resolveCaseTags({
-									evalTags: evalTagsResult.tags,
-									evalCase,
-									evalId: evalMeta.id,
-									filePath: evalMeta.filePath
-								})
-							}));
-							const duplicateCaseIds = findDuplicateCaseIds(runnableCases);
-							if (duplicateCaseIds.length > 0) throw new Error(`Duplicate case id${duplicateCaseIds.length === 1 ? "" : "s"} in ${evalMeta.filePath}#${evalMeta.id}: ${duplicateCaseIds.join(", ")}`);
-							const cases = filterEvalCasesByTags(filterEvalCases(runnableCases, request.target.caseIds), request.target.tagsFilter);
-							evalMeta.caseCount = runnableCases.length;
-							evalMeta.caseIds = runnableCases.map((evalCase) => evalCase.id);
-							runState.summary.totalCases += cases.length;
-							const defaultConfig = resolveEvalDefaultConfig({
-								evalDef,
-								globalColumns: config.columns,
-								globalStats: config.stats,
-								globalDefaultStatAggregate: config.defaultStatAggregate,
-								globalRemove: config.removeDefaultConfig
-							});
-							const declaredColumnDefs = buildDeclaredColumnDefs(defaultConfig.columns, evalDef.scores, evalDef.manualScores);
-							const validatedCharts = validateCharts({
-								charts: defaultConfig.charts,
-								columnDefs: declaredColumnDefs,
-								evalId: evalMeta.id
-							});
-							for (const warning of validatedCharts.warnings) console.warn(warning);
-							evalMeta.columnDefs = declaredColumnDefs;
-							evalMeta.stats = defaultConfig.stats;
-							evalMeta.defaultStatAggregate = defaultConfig.defaultStatAggregate;
-							evalMeta.charts = validatedCharts.charts;
-							const evalCaseRows = [];
-							const preparedCases = [];
-							const scoreKeys = Object.freeze(Object.keys(evalDef.scores ?? {}));
-							const manualScoreKeys = Object.freeze(Object.keys(evalDef.manualScores ?? {}));
-							const preparedEval = {
-								evalMeta,
-								evalCaseRows,
-								preparedCases,
-								scoreKeys: Object.freeze([...scoreKeys, ...manualScoreKeys])
-							};
-							preparedEvals.push(preparedEval);
-							for (const evalCase of cases) {
-								const trialResults = [];
-								const preparedCase = {
-									caseId: evalCase.id,
-									trialResults,
-									finalized: false
-								};
-								preparedCases.push(preparedCase);
-								for (let trial = 0; trial < request.trials; trial++) {
-									const bufferedCacheStore = cacheEnabled && cacheMode !== "bypass" ? createBufferedCacheStore(cacheStore) : null;
-									const caseModuleIsolation = buildCaseModuleIsolation({
-										runId: runState.manifest.id,
-										evalKey: evalMeta.key,
-										caseId: evalCase.id,
-										trial,
-										workspaceRoot
-									});
-									queuedCases.push({
-										execute: async ({ startTime, globalTraceDisplay }) => {
-											const { caseDetail, caseRowUpdate } = await useIsolatedEvalDefinition({
-												evalId: evalMeta.id,
-												evalFilePath,
-												sourceFingerprint: toOptionalSourceFingerprint(sourceFingerprint),
-												moduleIsolation: caseModuleIsolation,
-												runtimeScope: "env",
-												use: async (isolatedEvalDef) => await runCase({
-													evalDef: isolatedEvalDef,
-													evalId: evalMeta.id,
-													evalKey: evalMeta.key,
-													evalCase,
-													globalTraceDisplay,
-													globalColumns: config.columns,
-													globalDeriveFromTracing: config.deriveFromTracing,
-													llmCallsConfig,
-													apiCallsConfig,
-													globalRemoveDefaultConfig: config.removeDefaultConfig,
-													trial,
-													startTime,
-													cacheAdapter: bufferedCacheStore ?? (cacheEnabled ? cacheStore : null),
-													cacheMode,
-													moduleIsolation: caseModuleIsolation,
-													evalFilePath,
-													evalFileRelativePath: evalMeta.filePath,
-													workspaceRoot,
-													artifactDir: join(runDir, "artifacts"),
-													runId: runState.manifest.id
-												})
-											});
-											return {
-												caseDetail,
-												caseRow: {
-													caseId: evalCase.id,
-													evalId: evalMeta.id,
-													evalKey: evalMeta.key,
-													caseKey: caseDetail.caseKey,
-													tags: caseDetail.tags,
-													status: caseRowUpdate.status ?? "pending",
-													durationMs: caseRowUpdate.durationMs ?? null,
-													cacheHits: caseRowUpdate.cacheHits ?? 0,
-													cacheOperations: caseRowUpdate.cacheOperations ?? 0,
-													columns: caseRowUpdate.columns ?? {},
-													trial
-												}
-											};
-										},
-										onComplete: async ({ caseDetail, caseRow }) => {
-											trialResults.push({
-												caseDetail,
-												caseRow,
-												bufferedCacheStore
-											});
-											if (trialResults.length !== request.trials) return;
-											await finalizePreparedCase({
-												runState,
-												runDir,
-												preparedEval,
-												preparedCase,
-												onCaseFinished,
-												emitEvent
-											});
-										}
-									});
-								}
-							}
-						});
-					});
-				});
-			} catch (error) {
-				console.error(`Error running eval ${evalMeta.id}:`, error);
-				evalErrors.push({
-					evalId: evalMeta.id,
-					details: formatUnknownErrorDetails(error)
-				});
-				lastRunStatusMap.set(evalMeta.key, "error");
-				latestRunInfoMap.set(evalMeta.key, {
-					status: "error",
-					startedAt: runState.manifest.endedAt ?? runState.manifest.startedAt,
-					commitSha: runState.manifest.commitSha ?? null,
-					evalSourceFingerprint: runState.manifest.evalSourceFingerprints[evalMeta.key] ?? null
-				});
-			}
-		}
-		const ambiguousCaseTargets = request.target.caseIds && request.target.caseIds.length > 0 ? findAmbiguousTargetCaseIds(preparedEvals) : [];
-		if (ambiguousCaseTargets.length > 0) {
-			queuedCases.length = 0;
-			evalErrors.push({
-				evalId: "target",
-				details: `Ambiguous --case target. Narrow it with --file and/or --eval: ${ambiguousCaseTargets.join("; ")}`
-			});
-		} else await executeQueuedCases({
-			queuedCases,
-			concurrency: getConfiguredConcurrency(),
-			globalTraceDisplay: config.traceDisplay
-		});
-		for (const preparedEval of preparedEvals) {
-			for (const preparedCase of preparedEval.preparedCases) await finalizePreparedCase({
-				runState,
-				runDir,
-				preparedEval,
-				preparedCase,
-				onCaseFinished,
-				emitEvent
-			});
-			lastRunStatusMap.set(preparedEval.evalMeta.key, toLastRunStatus(deriveStatusFromCaseRows({ caseRows: preparedEval.evalCaseRows })));
-			const latestStatus = lastRunStatusMap.get(preparedEval.evalMeta.key) ?? null;
-			latestRunInfoMap.set(preparedEval.evalMeta.key, {
-				status: latestStatus,
-				startedAt: runState.manifest.endedAt ?? runState.manifest.startedAt,
-				commitSha: runState.manifest.commitSha ?? null,
-				evalSourceFingerprint: runState.manifest.evalSourceFingerprints[preparedEval.evalMeta.key] ?? null
-			});
-		}
-		sortCaseRowsByPreparedOrder(runState.cases, preparedEvals);
-		for (const preparedEval of preparedEvals) sortCaseRowsByPreparedOrder(preparedEval.evalCaseRows, preparedEvals);
-		const endTime = /* @__PURE__ */ new Date();
-		runState.summary.totalDurationMs = endTime.getTime() - new Date(runState.manifest.startedAt).getTime();
-		const finalStatus = evalErrors.length > 0 ? "error" : "completed";
-		runState.summary.status = finalStatus;
-		runState.manifest.status = finalStatus;
-		const completedRunAt = endTime.toISOString();
-		runState.manifest.endedAt = completedRunAt;
-		runState.summary.errorMessage = evalErrors.length > 0 ? buildRunErrorMessage(evalErrors) : null;
-		for (const evalKey of getTargetEvalKeys({
-			request,
-			sortedEvals: getSortedEvalMetas()
-		})) {
-			const latestStatus = lastRunStatusMap.get(evalKey) ?? toLastRunStatus(deriveStatusFromCaseRows({
-				caseRows: [],
-				lifecycleStatus: runState.manifest.status
-			}));
-			latestRunInfoMap.set(evalKey, {
-				status: latestStatus,
-				startedAt: completedRunAt,
-				commitSha: runState.manifest.commitSha ?? null,
-				evalSourceFingerprint: runState.manifest.evalSourceFingerprints[evalKey] ?? null
-			});
-		}
-		await persistRunState(runState);
-		emitEvent(runState, {
-			type: "run.summary",
-			runId: runState.manifest.id,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			payload: runState.summary
-		});
-		if (finalStatus === "error") emitEvent(runState, {
-			type: "run.error",
-			runId: runState.manifest.id,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			payload: { message: buildRunErrorMessage(evalErrors) }
-		});
-		else emitEvent(runState, {
-			type: "run.finished",
-			runId: runState.manifest.id,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			payload: runState.summary
-		});
-		emitDiscoveryEvent();
-	} catch (error) {
-		const message = formatUnknownErrorDetails(error);
-		runState.manifest.status = "error";
-		runState.manifest.endedAt = (/* @__PURE__ */ new Date()).toISOString();
-		runState.summary.status = "error";
-		runState.summary.errorMessage = message;
-		await persistRunState(runState);
-		emitEvent(runState, {
-			type: "run.error",
-			runId: runState.manifest.id,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			payload: { message }
-		});
-		emitDiscoveryEvent();
-	}
-}
-function toLastRunStatus(status) {
-	return status === "pending" ? null : status;
-}
-//#endregion
-export { getCurrentScope as $, validateCharts as A, buildEvalKey as At, deserializeCacheValue as B, deriveEvalFreshness as C, getEvalDisplayStatus as Ct, loadConfig as D, runSummarySchema as Dt, resolveEvalDefaultConfig as E, runManifestSchema as Et, evalSpan as F, evalChartsConfigSchema as Ft, readManualInputFile as G, serializeCacheValue as H, evalTracer as I, columnDefSchema as It, appendToEvalOutput as J, evalExpect as K, hashCacheKey as L, defineEval as Lt, z$1 as M, evalStatAggregateSchema as Mt, buildTraceTree as N, evalStatsConfigSchema as Nt, buildDeclaredColumnDefs as O, resolveApiCallsConfig as Ot, captureEvalSpanError as P, manualInputDescriptorSchema as Pt, evalTime as Q, hashCacheKeySync as R, getEvalRegistry as Rt, parseManualInputValues as S, getEvalTitle as St, parseEvalDiscovery as T, matchesTagsFilter as Tt, repoFile as U, serializeCacheRecording as V, manualInputFileValueSchema as W, evalAssert as X, configureEvalRunLogs as Y, evalLog as Z, recomputePersistedCaseStatus as _, extractLlmCalls as _t, validateTagsFilters as a, nextEvalId as at, resolveArtifactPath as b, applyDerivedCallAttributes as bt, getLastRunStatuses as c, runInExistingEvalScope as ct, loadPersistedRunSnapshots as d, startEvalBackgroundJob as dt, getEvalCaseInput as et, nextShortIdFromSnapshots as f, createRunRequestSchema as ft, recomputeEvalStatusesInRuns as g, extractApiCalls as gt, persistRunState as h, extractCacheHits as ht, resolveEvalTags as i, mergeEvalOutput as it, createFsCacheStore as j, getCaseRowCaseKey as jt, normalizeScoreDef as k, resolveLlmCallsConfig as kt, getLatestRunInfos as l, setEvalOutput as lt, deleteTemporaryRuns as m, extractCacheEntries as mt, getTargetEvalKeys as n, isInEvalScope as nt, stripTerminalControlCodes as o, runInEvalRuntimeScope as ot, persistCaseDetail as p, updateManualScoreRequestSchema as pt, EvalAssertionError as q, getTargetEvals as r, matchesEvalTags as rt, generateRunId as s, runInEvalScope as st, executeRun as t, incrementEvalOutput as tt, loadPersistedRunSnapshot as u, setScopeCacheContext as ut, runTouchesEval as v, simulateLlmCallCost as vt, loadIsolatedEvalRegistry as w, deriveScopedSummaryFromCases as wt, buildManualInputDescriptor as x, getNestedAttribute as xt, resolveTracePresentation as y, simulateTokenAllocation as yt, deserializeCacheRecording as z };
+export { startEvalBackgroundJob as $, repoFile as A, evalChartsConfigSchema as At, getCurrentScope as B, evalTracer as C, buildEvalKey as Ct, deserializeCacheValue as D, evalStatAggregateSchema as Dt, deserializeCacheRecording as E, caseRowSchema as Et, appendToEvalOutput as F, mergeEvalOutput as G, incrementEvalOutput as H, configureEvalRunLogs as I, runInEvalScope as J, nextEvalId as K, evalAssert as L, readManualInputFile as M, defineEval as Mt, evalExpect as N, getEvalRegistry as Nt, serializeCacheRecording as O, evalStatsConfigSchema as Ot, EvalAssertionError as P, runWithEvalRegistry as Pt, setScopeCacheContext as Q, evalLog as R, evalSpan as S, resolveLlmCallsConfig as St, hashCacheKeySync as T, caseDetailSchema as Tt, isInEvalScope as U, getEvalCaseInput as V, matchesEvalTags as W, runWithEvalClock as X, runInExistingEvalScope as Y, setEvalOutput as Z, createBufferedCacheStore as _, validateEvalTagName as _t, isCaseChildParentMessage as a, extractLlmCalls as at, buildTraceTree as b, runSummarySchema as bt, resolveArtifactPath as c, applyDerivedCallAttributes as ct, loadEvalModule as d, getEvalDisplayStatus as dt, createRunRequestSchema as et, resolveEvalDefaultConfig as f, deriveScopedSummaryFromCases as ft, commitPendingCacheWrites as g, matchesTagsFilter as gt, normalizeScoreDef as h, dedupeEvalTags as ht, isCaseChildMessage as i, extractApiCalls as it, manualInputFileValueSchema as j, columnDefSchema as jt, serializeCacheValue as k, manualInputDescriptorSchema as kt, registerAgentEvalsPackageResolutionHooks as l, getNestedAttribute as lt, buildDeclaredColumnDefs as m, deriveStatusFromChildStatuses as mt, resolveRunnableEvalCases as n, extractCacheEntries as nt, stripTerminalControlCodes as o, simulateLlmCallCost as ot, loadConfig as p, deriveStatusFromCaseRows as pt, runInEvalRuntimeScope as q, runCase as r, extractCacheHits as rt, resolveTracePresentation as s, simulateTokenAllocation as st, filterEvalCases as t, updateManualScoreRequestSchema as tt, runWithModuleIsolation as u, getEvalTitle as ut, createFsCacheStore as v, validateTagsFilterExpression as vt, hashCacheKey as w, getCaseRowCaseKey as wt, captureEvalSpanError as x, resolveApiCallsConfig as xt, z$1 as y, runManifestSchema as yt, evalTime as z };