@ls-stack/agent-eval 0.5.0 → 0.7.0

package/dist/{cli-C5FL7C4G.mjs → runOrchestration-HaMahl6b.mjs}

@@ -1,16 +1,14 @@
+import { createRequire, registerHooks } from "node:module";
 import { createHash } from "node:crypto";
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { dirname, extname, join, relative, resolve } from "node:path";
+import { extname, isAbsolute, join, relative, resolve } from "node:path";
+import { z, z as z$1 } from "zod/v4";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { getCompositeKey } from "@ls-stack/utils/getCompositeKey";
-import { z } from "zod/v4";
-import { watch } from "chokidar";
-import { glob } from "glob";
 import { existsSync } from "node:fs";
 import { resultify } from "t-result";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { spawn, spawnSync } from "node:child_process";
 //#region ../sdk/src/defineEval.ts
 const evalRegistry = /* @__PURE__ */ new Map();
 /** Return the in-memory registry of evals defined in the current process. */
@@ -70,6 +68,27 @@ function getCurrentScope() {
 function isInEvalScope() {
 	return getCurrentScope() !== void 0;
 }
+function isObjectLike(value) {
+	return typeof value === "object" && value !== null;
+}
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function copyArray$1(value) {
+	return value.map((item) => item);
+}
+function getEvalCaseInput(path = void 0) {
+	const scope = getCurrentScope();
+	if (!scope) return void 0;
+	if (path === void 0) return scope.input;
+	if (path.length === 0) return void 0;
+	let current = scope.input;
+	for (const segment of path.split(".")) {
+		if (segment.length === 0 || !isObjectLike(current)) return;
+		current = current[segment];
+	}
+	return current;
+}
 /**
 * Attach cache context (adapter, mode, eval id, fingerprint) to a scope.
 *
@@ -86,6 +105,7 @@ function setScopeCacheContext(scope, context) {
 async function runInEvalScope(caseId, fn, options = {}) {
 	const scope = {
 		caseId,
+		input: options.input,
 		outputs: {},
 		assertionFailures: [],
 		spans: [],
@@ -145,6 +165,58 @@ function setEvalOutput(key, value) {
 	});
 }
 /**
+* Append an item to an output array in the current case scope.
+*
+* Missing values become `[value]`, existing arrays receive the item, and
+* existing scalar/object values are preserved as `[existing, value]`.
+*/
+function appendToEvalOutput(key, value) {
+	const scope = getCurrentScope();
+	if (!scope) return;
+	const existing = scope.outputs[key];
+	if (existing === void 0) scope.outputs[key] = [value];
+	else if (Array.isArray(existing)) scope.outputs[key] = [...copyArray$1(existing), value];
+	else scope.outputs[key] = [existing, value];
+	recordOpIfActive(scope, {
+		kind: "appendOutput",
+		key,
+		value
+	});
+}
+/**
+* Shallow-merge object fields into an output value in the current case scope.
+*
+* Missing values become a copy of `patch`. Non-object existing values are
+* recorded as assertion failures instead of being replaced.
+*/
+function mergeEvalOutput(key, patch) {
+	const scope = getCurrentScope();
+	if (!scope) return;
+	const existing = scope.outputs[key];
+	if (existing === void 0) {
+		scope.outputs[key] = { ...patch };
+		recordOpIfActive(scope, {
+			kind: "mergeOutput",
+			key,
+			patch
+		});
+		return;
+	}
+	if (!isObjectRecord(existing)) {
+		scope.assertionFailures.push(toAssertionFailure$1(`mergeEvalOutput("${key}"): existing value is ${Array.isArray(existing) ? "array" : typeof existing}, expected object`));
+		return;
+	}
+	scope.outputs[key] = {
+		...existing,
+		...patch
+	};
+	recordOpIfActive(scope, {
+		kind: "mergeOutput",
+		key,
+		patch
+	});
+}
+/**
 * Add a numeric delta to an output value in the current case scope.
 *
 * If the existing value is non-numeric, the operation is recorded as an
@@ -189,18 +261,267 @@ function evalAssert(condition, message) {
 	throw error;
 }
 //#endregion
-//#region ../sdk/src/tracer.ts
-let spanIdCounter = 0;
+//#region ../sdk/src/cacheKey.ts
+var SerializedCacheKeyValue = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+};
+/**
+* Hash the components of a cache key into a deterministic hex digest.
+*
+* Native `Blob` and `File` values are read asynchronously and hashed by
+* content. Use `hashCacheKeySync` only when the key contains no async values.
+*/
+async function hashCacheKey(input) {
+	return hashCacheKeySyncMaterialized(await materializeAsyncCacheKeyValue(input));
+}
+/**
+* Synchronously hash cache key components. This supports JSON-like data and
+* in-memory binary values such as `Buffer`, `ArrayBuffer`, and typed arrays,
+* but cannot content-hash native `Blob` or `File` values.
+*/
+function hashCacheKeySync(input) {
+	return hashCacheKeySyncMaterialized(input);
+}
+function hashCacheKeySyncMaterialized(input) {
+	return createHash("sha256").update(getCompositeKey(input, { stringify: stringifyCacheKeyValue })).digest("hex");
+}
+function stringifyCacheKeyValue(value) {
+	if (value instanceof SerializedCacheKeyValue) return value.value;
+	if (Buffer$1.isBuffer(value)) return `$buffer:${hashBytes(value)}`;
+	if (isArrayBuffer(value)) return `$arrayBuffer:${hashBytes(new Uint8Array(value))}`;
+	if (isSharedArrayBuffer(value)) return `$sharedArrayBuffer:${hashBytes(new Uint8Array(value))}`;
+	if (isArrayBufferView(value)) {
+		const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+		return `$${value.constructor.name}:${hashBytes(bytes)}`;
+	}
+	if (isFile$1(value)) return `$file:${getCompositeKey({
+		lastModified: value.lastModified,
+		name: value.name,
+		size: value.size,
+		type: value.type
+	})}`;
+	if (isBlob$1(value)) return `$blob:${getCompositeKey({
+		size: value.size,
+		type: value.type
+	})}`;
+}
+async function materializeAsyncCacheKeyValue(value, refs = /* @__PURE__ */ new WeakSet()) {
+	const serialized = await stringifyAsyncCacheKeyValue(value);
+	if (serialized !== void 0) return new SerializedCacheKeyValue(serialized);
+	if (stringifyCacheKeyValue(value) !== void 0) return value;
+	if (!value || typeof value !== "object") return value;
+	if (Array.isArray(value)) {
+		const items = [];
+		for (const item of value) items.push(await materializeAsyncCacheKeyValue(item, refs));
+		return items;
+	}
+	if (refs.has(value)) throw new Error("Circular reference detected");
+	refs.add(value);
+	const entries = [];
+	for (const [key, entryValue] of Object.entries(value)) entries.push([key, await materializeAsyncCacheKeyValue(entryValue, refs)]);
+	refs.delete(value);
+	return Object.fromEntries(entries);
+}
+async function stringifyAsyncCacheKeyValue(value) {
+	if (isFile$1(value)) return `$file:${getCompositeKey({
+		bytes: await hashBlobBytes(value),
+		lastModified: value.lastModified,
+		name: value.name,
+		size: value.size,
+		type: value.type
+	})}`;
+	if (isBlob$1(value)) return `$blob:${getCompositeKey({
+		bytes: await hashBlobBytes(value),
+		size: value.size,
+		type: value.type
+	})}`;
+}
+async function hashBlobBytes(value) {
+	return hashBytes(new Uint8Array(await value.arrayBuffer()));
+}
+function hashBytes(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function isArrayBuffer(value) {
+	return value instanceof ArrayBuffer;
+}
+function isSharedArrayBuffer(value) {
+	return value instanceof SharedArrayBuffer;
+}
+function isArrayBufferView(value) {
+	return ArrayBuffer.isView(value);
+}
+function isBlob$1(value) {
+	return value instanceof Blob;
+}
+function isFile$1(value) {
+	return value instanceof File;
+}
+function toJsonSafe(value) {
+	if (value === void 0) return void 0;
+	const text = JSON.stringify(value);
+	return JSON.parse(text);
+}
+//#endregion
+//#region ../sdk/src/cacheRecording.ts
+function mergeSpanAttributes$1(span, attributes) {
+	span.attributes = {
+		...span.attributes,
+		...attributes
+	};
+}
+function isRecordLike$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function valueKind$1(value) {
+	return Array.isArray(value) ? "array" : typeof value;
+}
+function copyArray(value) {
+	return value.map((item) => item);
+}
+function stripCacheAttributes(attributes) {
+	if (!attributes) return {};
+	const result = {};
+	for (const [key, value] of Object.entries(attributes)) if (!key.startsWith("cache.")) result[key] = value;
+	return result;
+}
+function snapshotNonCacheAttributes(span) {
+	const snapshot = toJsonSafe(stripCacheAttributes(span?.attributes));
+	return isRecordLike$1(snapshot) ? snapshot : {};
+}
+function diffNonCacheAttributes(before, after) {
+	const result = {};
+	for (const [key, value] of Object.entries(after)) if (!cacheAttributeValuesEqual(before[key], value)) result[key] = value;
+	return result;
+}
+function cacheAttributeValuesEqual(left, right) {
+	if (Object.is(left, right)) return true;
+	try {
+		return JSON.stringify(left) === JSON.stringify(right);
+	} catch {
+		return false;
+	}
+}
+function appendCacheRef(span, ref) {
+	if (span === void 0) return;
+	const existing = span.attributes?.["cache.refs"];
+	mergeSpanAttributes$1(span, { "cache.refs": [...Array.isArray(existing) ? copyArray(existing) : [], ref] });
+}
+function serializeSubSpanTree(scope, spanId) {
+	const original = scope.spans.find((s) => s.id === spanId);
+	if (!original) return {
+		kind: "custom",
+		name: "unknown",
+		attributes: void 0,
+		status: "ok",
+		error: void 0,
+		errors: void 0,
+		warning: void 0,
+		warnings: void 0,
+		children: []
+	};
+	const children = scope.spans.filter((s) => s.parentId === spanId).map((child) => serializeSubSpanTree(scope, child.id));
+	return {
+		kind: original.kind,
+		name: original.name,
+		attributes: original.attributes,
+		status: original.status,
+		error: original.error,
+		errors: original.errors,
+		warning: original.warning,
+		warnings: original.warnings,
+		children
+	};
+}
+function appendSubSpanOps(scope, frame) {
+	for (let i = frame.baseSpanIndex; i < scope.spans.length; i++) {
+		const candidate = scope.spans[i];
+		if (candidate?.parentId === frame.replayParentSpanId) frame.ops.push({
+			kind: "subSpan",
+			span: serializeSubSpanTree(scope, candidate.id)
+		});
+	}
+}
+function replayRecording(scope, parentSpan, recording, options) {
+	scope.replayingDepth++;
+	try {
+		for (const op of recording.ops) applyRecordingOp(scope, parentSpan, op, options);
+		if (parentSpan !== void 0 && Object.keys(recording.finalAttributes).length > 0) mergeSpanAttributes$1(parentSpan, recording.finalAttributes);
+		if (parentSpan !== void 0 && recording.finalError !== void 0) parentSpan.error = recording.finalError;
+		if (parentSpan !== void 0 && recording.finalErrors !== void 0) parentSpan.errors = recording.finalErrors;
+		if (parentSpan !== void 0 && recording.finalWarning !== void 0) parentSpan.warning = recording.finalWarning;
+		if (parentSpan !== void 0 && recording.finalWarnings !== void 0) parentSpan.warnings = recording.finalWarnings;
+	} finally {
+		scope.replayingDepth--;
+	}
+}
+function applyRecordingOp(scope, parentSpan, op, options) {
+	if (op.kind === "setOutput") {
+		scope.outputs[op.key] = op.value;
+		return;
+	}
+	if (op.kind === "appendOutput") {
+		const existing = scope.outputs[op.key];
+		if (existing === void 0) scope.outputs[op.key] = [op.value];
+		else if (Array.isArray(existing)) scope.outputs[op.key] = [...copyArray(existing), op.value];
+		else scope.outputs[op.key] = [existing, op.value];
+		return;
+	}
+	if (op.kind === "mergeOutput") {
+		const existing = scope.outputs[op.key];
+		if (existing === void 0) scope.outputs[op.key] = { ...op.patch };
+		else if (isRecordLike$1(existing)) scope.outputs[op.key] = {
+			...existing,
+			...op.patch
+		};
+		else scope.assertionFailures.push({ message: `replay mergeEvalOutput("${op.key}"): existing value is ${valueKind$1(existing)}, expected object` });
+		return;
+	}
+	if (op.kind === "incrementOutput") {
+		const existing = scope.outputs[op.key];
+		if (existing === void 0) scope.outputs[op.key] = op.delta;
+		else if (typeof existing === "number") scope.outputs[op.key] = existing + op.delta;
+		else scope.assertionFailures.push({ message: `replay incrementEvalOutput("${op.key}"): existing value is ${valueKind$1(existing)}, expected number` });
+		return;
+	}
+	if (op.kind === "checkpoint") {
+		scope.checkpoints.set(op.name, op.data);
+		return;
+	}
+	replaySerializedSpan(scope, parentSpan?.id ?? null, op.span, options);
+}
+function replaySerializedSpan(scope, parentId, serialized, options) {
+	const id = options.generateSpanId();
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const replayed = {
+		id,
+		parentId,
+		caseId: scope.caseId,
+		kind: serialized.kind,
+		name: serialized.name,
+		startedAt: now,
+		endedAt: now,
+		status: serialized.status,
+		attributes: serialized.attributes,
+		error: serialized.error,
+		errors: serialized.errors,
+		warning: serialized.warning,
+		warnings: serialized.warnings
+	};
+	scope.spans.push(replayed);
+	for (const child of serialized.children) replaySerializedSpan(scope, id, child, options);
+}
+//#endregion
+//#region ../sdk/src/traceDiagnostics.ts
 const errorCoreFields = new Set([
 	"name",
 	"message",
 	"stack",
 	"capturedAt"
 ]);
-function generateSpanId() {
-	spanIdCounter++;
-	return `span_${String(Date.now())}_${String(spanIdCounter)}`;
-}
 function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -221,33 +542,6 @@ function formatUnknownErrorMessage(error) {
 function getErrorExtraFields(error) {
 	return Object.fromEntries(Object.entries(error).filter(([key]) => !errorCoreFields.has(key)));
 }
-function updateCurrentSpan(update) {
-	const currentSpan = getCurrentScope()?.activeSpanStack.at(-1);
-	if (!currentSpan) return;
-	update(currentSpan);
-}
-function noopActiveSpan() {
-	return {
-		setName() {},
-		setAttribute() {},
-		setAttributes() {}
-	};
-}
-function noopExternalSpan(id) {
-	return {
-		id,
-		setName() {},
-		setAttribute() {},
-		setAttributes() {},
-		end() {}
-	};
-}
-function mergeSpanAttributes(span, attributes) {
-	span.attributes = {
-		...span.attributes,
-		...attributes
-	};
-}
 function normalizeTraceError(error, capturedAt = void 0) {
 	if (error instanceof Error) return {
 		...getErrorExtraFields(error),
@@ -274,19 +568,233 @@ function normalizeTraceError(error, capturedAt = void 0) {
 		capturedAt
 	};
 }
-function normalizeTraceErrors(errorOrErrors, additionalErrors, capturedAt) {
-	return (additionalErrors.length > 0 ? [errorOrErrors, ...additionalErrors] : Array.isArray(errorOrErrors) ? errorOrErrors : [errorOrErrors]).map((error) => normalizeTraceError(error, capturedAt));
+function normalizeTraceErrors(errorOrErrors, additionalErrors, capturedAt) {
+	return (additionalErrors.length > 0 ? [errorOrErrors, ...additionalErrors] : Array.isArray(errorOrErrors) ? errorOrErrors : [errorOrErrors]).map((error) => normalizeTraceError(error, capturedAt));
+}
+function normalizeTraceWarnings(warningOrWarnings, additionalWarnings, capturedAt) {
+	return (additionalWarnings.length > 0 ? [warningOrWarnings, ...additionalWarnings] : Array.isArray(warningOrWarnings) ? warningOrWarnings : [warningOrWarnings]).map((warning) => normalizeTraceError(warning, capturedAt));
+}
+function isCaptureEvalSpanErrorOptions(value) {
+	if (!isRecord$2(value)) return false;
+	const keys = Object.keys(value);
+	if (keys.length === 0) return false;
+	if (!keys.every((key) => key === "level")) return false;
+	return value.level === void 0 || isCaptureEvalSpanErrorLevel(value.level);
+}
+function isCaptureEvalSpanErrorLevel(value) {
+	return value === "error" || value === "warning";
+}
+function splitCaptureEvalSpanErrorArgs(additionalErrorsOrOptions) {
+	const lastArg = additionalErrorsOrOptions.at(-1);
+	if (isCaptureEvalSpanErrorLevel(lastArg)) return {
+		additionalErrors: additionalErrorsOrOptions.slice(0, -1),
+		options: { level: lastArg }
+	};
+	if (isCaptureEvalSpanErrorOptions(lastArg)) return {
+		additionalErrors: additionalErrorsOrOptions.slice(0, -1),
+		options: lastArg
+	};
+	return {
+		additionalErrors: additionalErrorsOrOptions,
+		options: {}
+	};
+}
+function appendSpanErrors(span, errors) {
+	if (errors.length === 0) return;
+	const latestError = errors.at(-1);
+	if (latestError === void 0) return;
+	span.errors = [...span.errors ?? [], ...errors];
+	span.error = latestError;
+	span.status = "error";
+}
+function appendSpanWarnings(span, warnings) {
+	if (warnings.length === 0) return;
+	const latestWarning = warnings.at(-1);
+	if (latestWarning === void 0) return;
+	span.warnings = [...span.warnings ?? [], ...warnings];
+	span.warning = latestWarning;
+}
+function hasSpanError(span) {
+	return span.error !== void 0 || (span.errors?.length ?? 0) > 0;
+}
+//#endregion
+//#region ../sdk/src/valueCache.ts
+function createTraceCache(generateSpanId) {
+	return async function traceCache(info, fn) {
+		const scope = getCurrentScope();
+		if (!scope) return await fn();
+		const cacheCtx = scope.cacheContext;
+		if (cacheCtx === void 0 || scope.replayingDepth > 0) return await fn();
+		const namespace = info.namespace ?? `${cacheCtx.evalId}__${info.name}`;
+		const keyHash = await hashCacheKey({
+			namespace,
+			codeFingerprint: cacheCtx.codeFingerprint,
+			key: info.key
+		});
+		const activeSpan = scope.activeSpanStack.at(-1);
+		if (cacheCtx.mode === "use") {
+			const hit = await cacheCtx.adapter.lookup(namespace, keyHash);
+			if (hit) {
+				const storedAt = hit.storedAt;
+				const age = Date.now() - new Date(storedAt).getTime();
+				appendCacheRef(activeSpan, {
+					type: "value",
+					name: info.name,
+					namespace,
+					key: keyHash,
+					status: "hit",
+					storedAt,
+					age
+				});
+				replayRecording(scope, activeSpan, hit.recording, { generateSpanId });
+				return hit.recording.returnValue;
+			}
+			appendCacheRef(activeSpan, {
+				type: "value",
+				name: info.name,
+				namespace,
+				key: keyHash,
+				status: "miss"
+			});
+		} else if (cacheCtx.mode === "refresh") appendCacheRef(activeSpan, {
+			type: "value",
+			name: info.name,
+			namespace,
+			key: keyHash,
+			status: "refresh"
+		});
+		else appendCacheRef(activeSpan, {
+			type: "value",
+			name: info.name,
+			namespace,
+			key: keyHash,
+			status: "bypass"
+		});
+		const beforeAttributes = snapshotNonCacheAttributes(activeSpan);
+		const frame = {
+			baseSpanIndex: scope.spans.length,
+			replayParentSpanId: activeSpan?.id ?? null,
+			ops: []
+		};
+		scope.recordingStack.push(frame);
+		let bodyResult;
+		try {
+			bodyResult = await fn();
+		} finally {
+			scope.recordingStack.pop();
+		}
+		appendSubSpanOps(scope, frame);
+		if (cacheCtx.mode !== "bypass") {
+			const finalAttributes = diffNonCacheAttributes(beforeAttributes, snapshotNonCacheAttributes(activeSpan));
+			const recording = {
+				returnValue: toJsonSafe(bodyResult),
+				finalAttributes,
+				ops: frame.ops
+			};
+			await cacheCtx.adapter.write({
+				version: 1,
+				key: keyHash,
+				namespace,
+				operationType: "value",
+				operationName: info.name,
+				storedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				codeFingerprint: cacheCtx.codeFingerprint,
+				recording
+			});
+		}
+		return bodyResult;
+	};
+}
+//#endregion
+//#region ../sdk/src/tracer.ts
+let spanIdCounter = 0;
+function generateSpanId() {
+	spanIdCounter++;
+	return `span_${String(Date.now())}_${String(spanIdCounter)}`;
+}
+function updateCurrentSpan(update) {
+	const currentSpan = getCurrentScope()?.activeSpanStack.at(-1);
+	if (!currentSpan) return;
+	update(currentSpan);
+}
+function noopActiveSpan() {
+	return {
+		setName() {},
+		setAttribute() {},
+		setAttributes() {},
+		incrementAttribute() {},
+		appendToAttribute() {},
+		mergeAttribute() {}
+	};
+}
+function noopExternalSpan(id) {
+	return {
+		id,
+		setName() {},
+		setAttribute() {},
+		setAttributes() {},
+		incrementAttribute() {},
+		appendToAttribute() {},
+		mergeAttribute() {},
+		end() {}
+	};
+}
+function mergeSpanAttributes(span, attributes) {
+	span.attributes = {
+		...span.attributes,
+		...attributes
+	};
 }
-function appendSpanErrors(span, errors) {
-	if (errors.length === 0) return;
-	const latestError = errors.at(-1);
-	if (latestError === void 0) return;
-	span.errors = [...span.errors ?? [], ...errors];
-	span.error = latestError;
-	span.status = "error";
+function isRecordLike(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function hasSpanError(span) {
-	return span.error !== void 0 || (span.errors?.length ?? 0) > 0;
+function valueKind(value) {
+	return Array.isArray(value) ? "array" : typeof value;
+}
+function recordSpanAttributeAssertion(message) {
+	const scope = getCurrentScope();
+	if (!scope) return;
+	scope.assertionFailures.push({ message });
+}
+function incrementSpanAttribute(span, key, delta) {
+	const existing = span.attributes?.[key];
+	if (existing === void 0) {
+		mergeSpanAttributes(span, { [key]: delta });
+		return;
+	}
+	if (typeof existing !== "number") {
+		recordSpanAttributeAssertion(`evalSpan.incrementAttribute("${key}"): existing value is ${valueKind(existing)}, expected number`);
+		return;
+	}
+	mergeSpanAttributes(span, { [key]: existing + delta });
+}
+function appendToSpanAttribute(span, key, value) {
+	const existing = span.attributes?.[key];
+	if (existing === void 0) {
+		mergeSpanAttributes(span, { [key]: [value] });
+		return;
+	}
+	if (Array.isArray(existing)) {
+		const items = existing.map((item) => item);
+		mergeSpanAttributes(span, { [key]: [...items, value] });
+		return;
+	}
+	mergeSpanAttributes(span, { [key]: [existing, value] });
+}
+function mergeSpanAttribute(span, key, patch) {
+	const existing = span.attributes?.[key];
+	if (existing === void 0) {
+		mergeSpanAttributes(span, { [key]: { ...patch } });
+		return;
+	}
+	if (!isRecordLike(existing)) {
+		recordSpanAttributeAssertion(`evalSpan.mergeAttribute("${key}"): existing value is ${valueKind(existing)}, expected object`);
+		return;
+	}
+	mergeSpanAttributes(span, { [key]: {
+		...existing,
+		...patch
+	} });
 }
 function finishSpanWithoutThrownError(span) {
 	span.status = hasSpanError(span) ? "error" : "ok";
@@ -302,9 +810,25 @@ function createSpanHandle(span) {
 		},
 		setAttributes(value) {
 			mergeSpanAttributes(span, value);
+		},
+		incrementAttribute(key, delta) {
+			incrementSpanAttribute(span, key, delta);
+		},
+		appendToAttribute(key, value) {
+			appendToSpanAttribute(span, key, value);
+		},
+		mergeAttribute(key, patch) {
+			mergeSpanAttribute(span, key, patch);
 		}
 	};
 }
+function updateExternalSpanRecord(id, update) {
+	const scope = getCurrentScope();
+	if (!scope) return;
+	const span = findSpan(scope, id);
+	if (!span) return;
+	update(span);
+}
 function createExternalSpanHandle(id) {
 	return {
 		id,
@@ -326,6 +850,21 @@ function createExternalSpanHandle(id) {
 				attributes: value
 			});
 		},
+		incrementAttribute(key, delta) {
+			updateExternalSpanRecord(id, (span) => {
+				incrementSpanAttribute(span, key, delta);
+			});
+		},
+		appendToAttribute(key, value) {
+			updateExternalSpanRecord(id, (span) => {
+				appendToSpanAttribute(span, key, value);
+			});
+		},
+		mergeAttribute(key, patch) {
+			updateExternalSpanRecord(id, (span) => {
+				mergeSpanAttribute(span, key, patch);
+			});
+		},
 		end(info = {}) {
 			endExternalSpan({
 				...info,
@@ -382,6 +921,8 @@ function updateExternalSpan(info) {
 	if (info.name !== void 0) span.name = info.name;
 	if (info.status !== void 0) span.status = info.status;
 	if (info.error !== void 0) span.error = info.error;
+	if (info.warning !== void 0) span.warning = info.warning;
+	if (info.warnings !== void 0) span.warnings = info.warnings;
 	if (info.attributes !== void 0) mergeSpanAttributes(span, info.attributes);
 }
 function endExternalSpan(info) {
@@ -410,6 +951,8 @@ function recordExternalSpan(info) {
 		existing.status = status;
 		existing.attributes = info.attributes;
 		existing.error = info.error;
+		existing.warning = info.warning;
+		existing.warnings = info.warnings;
 		return id;
 	}
 	scope.spans.push({
@@ -422,7 +965,9 @@ function recordExternalSpan(info) {
 		endedAt,
 		status,
 		attributes: info.attributes,
-		error: info.error
+		error: info.error,
+		warning: info.warning,
+		warnings: info.warnings
 	});
 	return id;
 }
@@ -446,16 +991,42 @@ const evalSpan = {
 		updateCurrentSpan((currentSpan) => {
 			mergeSpanAttributes(currentSpan, value);
 		});
+	},
+	incrementAttribute(key, delta) {
+		updateCurrentSpan((currentSpan) => {
+			incrementSpanAttribute(currentSpan, key, delta);
+		});
+	},
+	appendToAttribute(key, value) {
+		updateCurrentSpan((currentSpan) => {
+			appendToSpanAttribute(currentSpan, key, value);
+		});
+	},
+	mergeAttribute(key, patch) {
+		updateCurrentSpan((currentSpan) => {
+			mergeSpanAttribute(currentSpan, key, patch);
+		});
 	}
 };
 /**
 * Attach one or more recoverable errors to the active eval span.
 *
-* The active span is marked as `error` even if its callback later completes
-* without throwing. Calls outside `evalTracer.span(...)` are ignored.
+* By default the active span is marked as `error` even if its callback later
+* completes without throwing. Pass `'warning'` or `{ level: 'warning' }` as the
+* final argument to record the diagnostic without changing span status. Calls
+* outside `evalTracer.span(...)` are ignored.
 */
-function captureEvalSpanError(errorOrErrors, ...additionalErrors) {
-	const errors = normalizeTraceErrors(errorOrErrors, additionalErrors, (/* @__PURE__ */ new Date()).toISOString());
+function captureEvalSpanError(errorOrErrors, ...additionalErrorsOrOptions) {
+	const { additionalErrors, options } = splitCaptureEvalSpanErrorArgs(additionalErrorsOrOptions);
+	const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+	if ((options.level ?? "error") === "warning") {
+		const warnings = normalizeTraceWarnings(errorOrErrors, additionalErrors, capturedAt);
+		updateCurrentSpan((currentSpan) => {
+			appendSpanWarnings(currentSpan, warnings);
+		});
+		return;
+	}
+	const errors = normalizeTraceErrors(errorOrErrors, additionalErrors, capturedAt);
 	updateCurrentSpan((currentSpan) => {
 		appendSpanErrors(currentSpan, errors);
 	});
@@ -503,7 +1074,7 @@ async function traceSpan(info, fn) {
 						"cache.storedAt": storedAt,
 						"cache.age": Date.now() - new Date(storedAt).getTime()
 					});
-					replayRecording(scope, spanRecord, hit.recording);
+					replayRecording(scope, spanRecord, hit.recording, { generateSpanId });
 					spanRecord.status = hit.recording.finalStatus ?? (hasSpanError(spanRecord) ? "error" : "ok");
 					spanRecord.endedAt = (/* @__PURE__ */ new Date()).toISOString();
 					return hit.recording.returnValue;
@@ -513,7 +1084,7 @@ async function traceSpan(info, fn) {
 			else mergeSpanAttributes(spanRecord, { "cache.status": "bypass" });
 			const frame = {
 				baseSpanIndex: scope.spans.length,
-				cachedSpanId: id,
+				replayParentSpanId: id,
 				ops: []
 			};
 			scope.recordingStack.push(frame);
@@ -532,12 +1103,16 @@ async function traceSpan(info, fn) {
 					finalStatus: spanRecord.status,
 					finalError: spanRecord.error,
 					finalErrors: spanRecord.errors,
+					finalWarning: spanRecord.warning,
+					finalWarnings: spanRecord.warnings,
 					ops: frame.ops
 				};
 				const entry = {
 					version: 1,
 					key: keyHash,
 					namespace,
+					operationType: "span",
+					operationName: info.name,
 					spanName: info.name,
 					spanKind: info.kind,
 					storedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -569,6 +1144,13 @@ const evalTracer = {
 	/** Run a callback inside a new trace span and record its lifecycle. */
 	span: traceSpan,
 	/**
+	* Cache a pure value without creating a trace span.
+	*
+	* When called inside an active span, the span receives a `cache.refs` entry
+	* describing the value cache status for this run.
+	*/
+	cache: createTraceCache(generateSpanId),
+	/**
 	* Start a span whose lifecycle is controlled by an external tracer/exporter.
 	*
 	* Calls are no-ops outside an eval case scope, except that a generated or
@@ -649,194 +1231,6 @@ function buildTraceTree(spans, checkpoints) {
 		checkpoints
 	};
 }
-var SerializedCacheKeyValue = class {
-	value;
-	constructor(value) {
-		this.value = value;
-	}
-};
-/**
-* Hash the components of a cache key into a deterministic hex digest.
-*
-* Native `Blob` and `File` values are read asynchronously and hashed by
-* content. Use `hashCacheKeySync` only when the key contains no async values.
-*/
-async function hashCacheKey(input) {
-	return hashCacheKeySyncMaterialized(await materializeAsyncCacheKeyValue(input));
-}
-/**
-* Synchronously hash cache key components. This supports JSON-like data and
-* in-memory binary values such as `Buffer`, `ArrayBuffer`, and typed arrays,
-* but cannot content-hash native `Blob` or `File` values.
-*/
-function hashCacheKeySync(input) {
-	return hashCacheKeySyncMaterialized(input);
-}
-function hashCacheKeySyncMaterialized(input) {
-	return createHash("sha256").update(getCompositeKey(input, { stringify: stringifyCacheKeyValue })).digest("hex");
-}
-function stringifyCacheKeyValue(value) {
-	if (value instanceof SerializedCacheKeyValue) return value.value;
-	if (Buffer$1.isBuffer(value)) return `$buffer:${hashBytes(value)}`;
-	if (isArrayBuffer(value)) return `$arrayBuffer:${hashBytes(new Uint8Array(value))}`;
-	if (isSharedArrayBuffer(value)) return `$sharedArrayBuffer:${hashBytes(new Uint8Array(value))}`;
-	if (isArrayBufferView(value)) {
-		const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-		return `$${value.constructor.name}:${hashBytes(bytes)}`;
-	}
-	if (isFile$1(value)) return `$file:${getCompositeKey({
-		lastModified: value.lastModified,
-		name: value.name,
-		size: value.size,
-		type: value.type
-	})}`;
-	if (isBlob$1(value)) return `$blob:${getCompositeKey({
-		size: value.size,
-		type: value.type
-	})}`;
-}
-async function materializeAsyncCacheKeyValue(value, refs = /* @__PURE__ */ new WeakSet()) {
-	const serialized = await stringifyAsyncCacheKeyValue(value);
-	if (serialized !== void 0) return new SerializedCacheKeyValue(serialized);
-	if (stringifyCacheKeyValue(value) !== void 0) return value;
-	if (!value || typeof value !== "object") return value;
-	if (Array.isArray(value)) {
-		const items = [];
-		for (const item of value) items.push(await materializeAsyncCacheKeyValue(item, refs));
-		return items;
-	}
-	if (refs.has(value)) throw new Error("Circular reference detected");
-	refs.add(value);
-	const entries = [];
-	for (const [key, entryValue] of Object.entries(value)) entries.push([key, await materializeAsyncCacheKeyValue(entryValue, refs)]);
-	refs.delete(value);
-	return Object.fromEntries(entries);
-}
-async function stringifyAsyncCacheKeyValue(value) {
-	if (isFile$1(value)) return `$file:${getCompositeKey({
-		bytes: await hashBlobBytes(value),
-		lastModified: value.lastModified,
-		name: value.name,
-		size: value.size,
-		type: value.type
-	})}`;
-	if (isBlob$1(value)) return `$blob:${getCompositeKey({
-		bytes: await hashBlobBytes(value),
-		size: value.size,
-		type: value.type
-	})}`;
-}
-async function hashBlobBytes(value) {
-	return hashBytes(new Uint8Array(await value.arrayBuffer()));
-}
-function hashBytes(value) {
-	return createHash("sha256").update(value).digest("hex");
-}
-function isArrayBuffer(value) {
-	return value instanceof ArrayBuffer;
-}
-function isSharedArrayBuffer(value) {
-	return value instanceof SharedArrayBuffer;
-}
-function isArrayBufferView(value) {
-	return ArrayBuffer.isView(value);
-}
-function isBlob$1(value) {
-	return value instanceof Blob;
-}
-function isFile$1(value) {
-	return value instanceof File;
-}
-function toJsonSafe(value) {
-	if (value === void 0) return void 0;
-	const text = JSON.stringify(value);
-	return JSON.parse(text);
-}
-function stripCacheAttributes(attributes) {
-	if (!attributes) return {};
-	const result = {};
-	for (const [key, value] of Object.entries(attributes)) if (!key.startsWith("cache.")) result[key] = value;
-	return result;
-}
-function serializeSubSpanTree(scope, spanId) {
-	const original = scope.spans.find((s) => s.id === spanId);
-	if (!original) return {
-		kind: "custom",
-		name: "unknown",
-		attributes: void 0,
-		status: "ok",
-		error: void 0,
-		errors: void 0,
-		children: []
-	};
-	const children = scope.spans.filter((s) => s.parentId === spanId).map((child) => serializeSubSpanTree(scope, child.id));
-	return {
-		kind: original.kind,
-		name: original.name,
-		attributes: original.attributes,
-		status: original.status,
-		error: original.error,
-		errors: original.errors,
-		children
-	};
-}
-function appendSubSpanOps(scope, frame) {
-	for (let i = frame.baseSpanIndex; i < scope.spans.length; i++) {
-		const candidate = scope.spans[i];
-		if (candidate?.parentId === frame.cachedSpanId) frame.ops.push({
-			kind: "subSpan",
-			span: serializeSubSpanTree(scope, candidate.id)
-		});
-	}
-}
-function replayRecording(scope, parentSpan, recording) {
-	scope.replayingDepth++;
-	try {
-		for (const op of recording.ops) applyRecordingOp(scope, parentSpan, op);
-		if (Object.keys(recording.finalAttributes).length > 0) mergeSpanAttributes(parentSpan, recording.finalAttributes);
-		if (recording.finalError !== void 0) parentSpan.error = recording.finalError;
-		if (recording.finalErrors !== void 0) parentSpan.errors = recording.finalErrors;
-	} finally {
-		scope.replayingDepth--;
-	}
-}
-function applyRecordingOp(scope, parentSpan, op) {
-	if (op.kind === "setOutput") {
-		scope.outputs[op.key] = op.value;
-		return;
-	}
-	if (op.kind === "incrementOutput") {
-		const existing = scope.outputs[op.key];
-		if (existing === void 0) scope.outputs[op.key] = op.delta;
-		else if (typeof existing === "number") scope.outputs[op.key] = existing + op.delta;
-		else scope.assertionFailures.push({ message: `replay incrementEvalOutput("${op.key}"): existing value is ${typeof existing}, expected number` });
-		return;
-	}
-	if (op.kind === "checkpoint") {
-		scope.checkpoints.set(op.name, op.data);
-		return;
-	}
-	replaySerializedSpan(scope, parentSpan.id, op.span);
-}
-function replaySerializedSpan(scope, parentId, serialized) {
-	const id = generateSpanId();
-	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const replayed = {
-		id,
-		parentId,
-		caseId: scope.caseId,
-		kind: serialized.kind,
-		name: serialized.name,
-		startedAt: now,
-		endedAt: now,
-		status: serialized.status,
-		attributes: serialized.attributes,
-		error: serialized.error,
-		errors: serialized.errors
-	};
-	scope.spans.push(replayed);
-	for (const child of serialized.children) replaySerializedSpan(scope, id, child);
-}
 //#endregion
 //#region ../shared/src/schemas/display.ts
 const scalarCellSchema = z.union([
@@ -976,6 +1370,8 @@ const traceSpanErrorSchema = z.object({
 	stack: z.string().optional(),
 	capturedAt: z.string().optional()
 }).catchall(z.unknown());
+/** Schema for a warning attached to a trace span. */
+const traceSpanWarningSchema = traceSpanErrorSchema;
 /** Schema for a persisted trace span captured during case execution. */
 const traceSpanSchema = z.object({
 	id: z.string(),
@@ -993,7 +1389,9 @@ const traceSpanSchema = z.object({
 	]),
 	attributes: z.record(z.string(), z.unknown()).optional(),
 	error: traceSpanErrorSchema.optional(),
-	errors: z.array(traceSpanErrorSchema).optional()
+	errors: z.array(traceSpanErrorSchema).optional(),
+	warning: traceSpanWarningSchema.optional(),
+	warnings: z.array(traceSpanWarningSchema).optional()
 });
 //#endregion
 //#region ../shared/src/schemas/chart.ts
@@ -1254,12 +1652,16 @@ const spanCacheOptionsSchema = z.object({
 	/** Override the default namespace (`${evalId}__${spanName}`). */
 	namespace: z.string().optional()
 });
+/** Category of operation stored in the eval cache. */
+const cacheOperationTypeSchema = z.enum(["span", "value"]);
 /** Summary of a single persisted cache entry, used by list/delete endpoints. */
 const cacheListItemSchema = z.object({
 	key: z.string(),
 	namespace: z.string(),
-	spanName: z.string(),
-	spanKind: traceSpanKindSchema,
+	operationType: cacheOperationTypeSchema,
+	operationName: z.string(),
+	spanName: z.string().optional(),
+	spanKind: traceSpanKindSchema.optional(),
 	storedAt: z.string(),
 	codeFingerprint: z.string(),
 	sizeBytes: z.number()
@@ -1276,7 +1678,9 @@ const serializedCacheSpanSchema = z.object({
 		"cancelled"
 	]),
 	error: traceSpanErrorSchema.optional(),
-	errors: z.array(traceSpanErrorSchema).optional()
+	errors: z.array(traceSpanErrorSchema).optional(),
+	warning: traceSpanWarningSchema.optional(),
+	warnings: z.array(traceSpanWarningSchema).optional()
 }).extend({ children: z.lazy(() => z.array(serializedCacheSpanSchema)) });
 /**
 * One captured operation performed while a cached span's body executed.
@@ -1290,6 +1694,16 @@ const cacheRecordingOpSchema = z.discriminatedUnion("kind", [
 		key: z.string(),
 		value: z.unknown()
 	}),
+	z.object({
+		kind: z.literal("appendOutput"),
+		key: z.string(),
+		value: z.unknown()
+	}),
+	z.object({
+		kind: z.literal("mergeOutput"),
+		key: z.string(),
+		patch: z.record(z.string(), z.unknown())
+	}),
 	z.object({
 		kind: z.literal("incrementOutput"),
 		key: z.string(),
@@ -1317,6 +1731,8 @@ const cacheRecordingSchema = z.object({
 	]).optional(),
 	finalError: traceSpanErrorSchema.optional(),
 	finalErrors: z.array(traceSpanErrorSchema).optional(),
+	finalWarning: traceSpanWarningSchema.optional(),
+	finalWarnings: z.array(traceSpanWarningSchema).optional(),
 	ops: z.array(cacheRecordingOpSchema)
 });
 /** Persisted cache file containing metadata and a recording. */
@@ -1324,8 +1740,10 @@ const cacheEntrySchema = z.object({
 	version: z.literal(1),
 	key: z.string(),
 	namespace: z.string(),
-	spanName: z.string(),
-	spanKind: traceSpanKindSchema,
+	operationType: cacheOperationTypeSchema.optional(),
+	operationName: z.string().optional(),
+	spanName: z.string().optional(),
+	spanKind: traceSpanKindSchema.optional(),
 	storedAt: z.string(),
 	codeFingerprint: z.string(),
 	recording: cacheRecordingSchema
@@ -1635,15 +2053,21 @@ function createFsCacheStore(options) {
 				if (fileStatResult.error || !fileStatResult.value.isFile()) continue;
 				const cacheFile = await readCacheFilePath(filePath);
 				if (cacheFile === null) continue;
-				for (const entry of Object.values(cacheFile.entries)) items.push({
-					key: entry.key,
-					namespace: entry.namespace,
-					spanName: entry.spanName,
-					spanKind: entry.spanKind,
-					storedAt: entry.storedAt,
-					codeFingerprint: entry.codeFingerprint,
-					sizeBytes: Buffer.byteLength(JSON.stringify(entry), "utf8")
-				});
+				for (const entry of Object.values(cacheFile.entries)) {
+					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,
+						codeFingerprint: entry.codeFingerprint,
+						sizeBytes: Buffer.byteLength(JSON.stringify(entry), "utf8")
+					});
+				}
 			}
 			items.sort((a, b) => a.storedAt < b.storedAt ? 1 : -1);
 			return items;
@@ -1804,80 +2228,6 @@ function safeJsonParse(text) {
 	return parsed.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
@@ -2087,98 +2437,6 @@ async function loadConfig() {
 	}
 }
 //#endregion
-//#region ../runner/src/discovery.ts
-const evalIdMatchRegex = /\bid\s*:\s*['"]([^'"]+)['"]/;
-const evalTitleMatchRegex = /\btitle\s*:\s*['"]([^'"]+)['"]/;
-function parseEvalMetas(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;
-	}
-	return metas;
-}
-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
@@ -2266,30 +2524,6 @@ function setLatestRunInfoMap(params) {
 	for (const evalId of evalIds) latestRunInfoMap.set(evalId, info);
 }
 //#endregion
-//#region ../runner/src/gitState.ts
-function runGitCommand(workspaceRoot, args) {
-	const result = spawnSync("git", args, {
-		cwd: workspaceRoot,
-		encoding: "utf8",
-		stdio: [
-			"ignore",
-			"pipe",
-			"ignore"
-		]
-	});
-	return {
-		status: result.status,
-		stdout: result.stdout.trim()
-	};
-}
-/** Read the current git commit for the workspace, if available. */
-function readGitWorktreeState(workspaceRoot) {
-	const insideWorktree = runGitCommand(workspaceRoot, ["rev-parse", "--is-inside-work-tree"]);
-	if (insideWorktree.status !== 0 || insideWorktree.stdout !== "true") return { commitSha: null };
-	const commitResult = runGitCommand(workspaceRoot, ["rev-parse", "HEAD"]);
-	return { commitSha: commitResult.status === 0 ? commitResult.stdout : null };
-}
-//#endregion
 //#region ../runner/src/outputArtifacts.ts
 const mimeTypeExtensionMap = {
 	"application/json": ".json",
@@ -2345,100 +2579,329 @@ function normalizeMimeType(value) {
 	const normalized = value.trim();
 	return normalized.length > 0 ? normalized : "application/octet-stream";
 }
-function getArtifactFileName(params) {
-	const { outputKey, mimeType, value } = params;
-	if (isFile(value) && value.name.trim().length > 0) return value.name.trim();
-	const extension = getExtensionForMimeType(mimeType);
-	return extension.length > 0 ? `${sanitizeSegment(outputKey)}${extension}` : sanitizeSegment(outputKey);
+function getArtifactFileName(params) {
+	const { outputKey, mimeType, value } = params;
+	if (isFile(value) && value.name.trim().length > 0) return value.name.trim();
+	const extension = getExtensionForMimeType(mimeType);
+	return extension.length > 0 ? `${sanitizeSegment(outputKey)}${extension}` : sanitizeSegment(outputKey);
+}
+function getExtensionForMimeType(mimeType) {
+	const exactMatch = mimeTypeExtensionMap[mimeType];
+	if (exactMatch) return exactMatch;
+	const subtype = mimeType.split("/")[1];
+	if (subtype === void 0 || subtype.length === 0) return "";
+	const withoutSuffix = subtype.split("+")[0] ?? subtype;
+	return withoutSuffix.length > 0 ? `.${withoutSuffix}` : "";
+}
+function sanitizeSegment(value) {
+	const normalized = value.trim().replaceAll(/[^A-Za-z0-9._-]+/g, "-");
+	return normalized.length > 0 ? normalized : "artifact";
+}
+function sanitizeFileName(value) {
+	const normalized = sanitizeSegment(value);
+	const extension = extname(normalized);
+	if (extension.length === 0) return normalized;
+	return `${normalized.slice(0, -extension.length).replaceAll(".", "-")}${extension}`;
+}
+function isFile(value) {
+	return value instanceof File;
+}
+//#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.evalId === params.evalId)) return true;
+	if (params.target.mode === "all") return params.evalExists;
+	if (params.target.mode === "evalIds") return params.target.evalIds?.includes(params.evalId) ?? false;
+	return false;
+}
+async function recomputeEvalStatusesInRuns(params) {
+	let updatedRuns = 0;
+	for (const run of params.runs) {
+		if (!runTouchesEval({
+			target: run.manifest.target,
+			caseRows: run.cases,
+			evalId: params.evalId,
+			evalExists: params.evalExists
+		})) continue;
+		if (run.manifest.status === "running") continue;
+		let changed = false;
+		for (const caseRow of run.cases) {
+			if (caseRow.evalId !== params.evalId) continue;
+			const caseDetail = run.caseDetails.get(caseRow.caseId);
+			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) {
+	await writeFile(join(runDir, "case-details", `${encodeCaseDetailFileName(caseDetail.caseId)}.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.id, 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 evalId of getRunEvalIds(run, knownEvalMetas.map((evalMeta) => evalMeta.id))) latestRunInfos.set(evalId, {
+		status: getEvalStatusForRun(run, evalId, manualScoreKeysByEval.get(evalId) ?? []),
+		startedAt: getRunFreshnessTimestamp(run.manifest),
+		commitSha: run.manifest.commitSha ?? null,
+		evalSourceFingerprint: run.manifest.evalSourceFingerprints[evalId] ?? 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.caseId, detail);
+	}
+	return caseDetails;
 }
-function getExtensionForMimeType(mimeType) {
-	const exactMatch = mimeTypeExtensionMap[mimeType];
-	if (exactMatch) return exactMatch;
-	const subtype = mimeType.split("/")[1];
-	if (subtype === void 0 || subtype.length === 0) return "";
-	const withoutSuffix = subtype.split("+")[0] ?? subtype;
-	return withoutSuffix.length > 0 ? `.${withoutSuffix}` : "";
+function getRunEvalIds(run, knownEvalIds) {
+	const evalIds = new Set(run.cases.map((caseRow) => caseRow.evalId));
+	if (run.manifest.target.mode === "evalIds") for (const evalId of run.manifest.target.evalIds ?? []) evalIds.add(evalId);
+	else if (run.manifest.target.mode === "all" && evalIds.size === 0) for (const evalId of knownEvalIds) evalIds.add(evalId);
+	return [...evalIds];
 }
-function sanitizeSegment(value) {
-	const normalized = value.trim().replaceAll(/[^A-Za-z0-9._-]+/g, "-");
-	return normalized.length > 0 ? normalized : "artifact";
+function getEvalStatusForRun(run, evalId, manualScoreKeys) {
+	const evalCases = run.cases.filter((caseRow) => caseRow.evalId === evalId);
+	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 sanitizeFileName(value) {
-	const normalized = sanitizeSegment(value);
-	const extension = extname(normalized);
-	if (extension.length === 0) return normalized;
-	return `${normalized.slice(0, -extension.length).replaceAll(".", "-")}${extension}`;
+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 isFile(value) {
-	return value instanceof File;
+function encodeCaseDetailFileName(caseId) {
+	return encodeURIComponent(caseId);
 }
 //#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);
+//#region ../runner/src/moduleIsolation.ts
+const isolationParam = "agent-evals-isolate";
+const pathSegmentSeparatorPattern = /[\\/]+/;
+const isolationStorage = new AsyncLocalStorage();
+const activeIsolationRoots = /* @__PURE__ */ new Map();
+let hooksRegistered = false;
+const requireFromRunner = createRequire(import.meta.url);
+const agentPackageUrlBySpecifier = new Map([
+	"@ls-stack/agent-eval",
+	"@agent-evals/sdk",
+	"@agent-evals/shared",
+	"@agent-evals/runner",
+	"@agent-evals/runner/run-child"
+].flatMap((specifier) => {
+	try {
+		return [[specifier, pathToFileURL(requireFromRunner.resolve(specifier)).href]];
+	} catch {
+		return [];
+	}
+}));
+function isAgentEvalsPackageSpecifier(specifier) {
+	return specifier === "@ls-stack/agent-eval" || specifier === "@agent-evals/sdk" || specifier === "@agent-evals/shared" || specifier === "@agent-evals/runner" || specifier.startsWith("@ls-stack/agent-eval/") || specifier.startsWith("@agent-evals/sdk/") || specifier.startsWith("@agent-evals/shared/") || specifier.startsWith("@agent-evals/runner/");
+}
+function getIsolationKeyFromParent(parentURL) {
+	if (!parentURL?.startsWith("file:")) return null;
+	const value = new URL(parentURL).searchParams.get(isolationParam);
+	return activeIsolationRoots.has(value ?? "") ? value : null;
+}
+function isWorkspaceFile(url, workspaceRoot) {
+	if (url.protocol !== "file:") return false;
+	const relativePath = relative(workspaceRoot, fileURLToPath(url));
+	if (relativePath === "" || relativePath.startsWith("..") || isAbsolute(relativePath)) return false;
+	const segments = relativePath.split(pathSegmentSeparatorPattern);
+	return !segments.includes("node_modules") && !segments.includes(".agent-evals");
+}
+function addIsolationParam(url, key) {
+	const moduleUrl = new URL(url);
+	if (moduleUrl.searchParams.get(isolationParam) === key) return url;
+	moduleUrl.searchParams.set(isolationParam, key);
+	return moduleUrl.href;
+}
+function registerModuleIsolationHooks() {
+	if (hooksRegistered) return;
+	hooksRegistered = true;
+	registerHooks({ resolve(specifier, context, nextResolve) {
+		const agentPackageUrl = agentPackageUrlBySpecifier.get(specifier);
+		if (agentPackageUrl !== void 0) return {
+			url: agentPackageUrl,
+			shortCircuit: true
+		};
+		const resolved = nextResolve(specifier, context);
+		if (isAgentEvalsPackageSpecifier(specifier)) return resolved;
+		const activeContext = isolationStorage.getStore();
+		const inferredKey = getIsolationKeyFromParent(context.parentURL);
+		const isolationKey = activeContext?.key ?? inferredKey;
+		if (isolationKey === null) return resolved;
+		const workspaceRoot = activeContext?.workspaceRoot ?? activeIsolationRoots.get(isolationKey);
+		if (workspaceRoot === void 0) return resolved;
+		if (!isWorkspaceFile(new URL(resolved.url), workspaceRoot)) return resolved;
+		return {
+			...resolved,
+			url: addIsolationParam(resolved.url, isolationKey)
+		};
+	} });
 }
 /**
-* Recompute a persisted case's status after score definitions changed.
+* Execute module loading and eval code with fresh workspace module URLs.
 *
-* 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.
+* Node does not expose an ESM cache reset API, so the runner appends a
+* run-scoped query parameter to workspace file imports. Package imports are
+* left alone so SDK singletons, such as the eval registry, remain shared.
 */
-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.evalId === params.evalId)) return true;
-	if (params.target.mode === "all") return params.evalExists;
-	if (params.target.mode === "evalIds") return params.target.evalIds?.includes(params.evalId) ?? false;
-	return false;
-}
-async function recomputeEvalStatusesInRuns(params) {
-	let updatedRuns = 0;
-	for (const run of params.runs) {
-		if (!runTouchesEval({
-			target: run.manifest.target,
-			caseRows: run.cases,
-			evalId: params.evalId,
-			evalExists: params.evalExists
-		})) continue;
-		if (run.manifest.status === "running") continue;
-		let changed = false;
-		for (const caseRow of run.cases) {
-			if (caseRow.evalId !== params.evalId) continue;
-			const caseDetail = run.caseDetails.get(caseRow.caseId);
-			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;
+async function runWithModuleIsolation(context, fn) {
+	registerModuleIsolationHooks();
+	activeIsolationRoots.set(context.key, context.workspaceRoot);
+	return await isolationStorage.run(context, fn);
 }
 //#endregion
 //#region ../runner/src/traceDisplay.ts
@@ -2528,18 +2991,25 @@ async function callWithUnknownResult(fn, args) {
 	return await Reflect.apply(fn, void 0, args);
 }
 async function runCase(params) {
-	const { evalDef, evalId, evalCase, globalTraceDisplay, trial, signal, startTime, cacheAdapter, cacheMode, codeFingerprint, artifactDir, runId } = params;
+	const { evalDef, evalId, evalCase, globalTraceDisplay, trial, startTime, cacheAdapter, cacheMode, codeFingerprint, moduleIsolation, artifactDir, runId } = params;
 	const { scope, error: executeError } = await runInEvalScope(evalCase.id, async () => {
-		await Reflect.apply(evalDef.execute, evalDef, [{
-			input: evalCase.input,
-			signal
-		}]);
-	}, { cacheContext: cacheAdapter ? {
-		adapter: cacheAdapter,
-		mode: cacheMode,
-		evalId,
-		codeFingerprint
-	} : void 0 });
+		const execute = async () => {
+			await Reflect.apply(evalDef.execute, evalDef, [{ input: evalCase.input }]);
+		};
+		if (moduleIsolation === void 0) {
+			await execute();
+			return;
+		}
+		await runWithModuleIsolation(moduleIsolation, execute);
+	}, {
+		input: evalCase.input,
+		cacheContext: cacheAdapter ? {
+			adapter: cacheAdapter,
+			mode: cacheMode,
+			evalId,
+			codeFingerprint
+		} : void 0
+	});
 	const traceTree = buildTraceTree(scope.spans, scope.checkpoints);
 	const nonAssertError = executeError && !(executeError instanceof EvalAssertionError) ? executeError : null;
 	if (executeError instanceof EvalAssertionError && scope.assertionFailures.length === 0) scope.assertionFailures.push(toAssertionFailure(executeError.message, executeError));
@@ -2555,20 +3025,35 @@ async function runCase(params) {
 		const message = `deriveFromTracing threw: ${e instanceof Error ? e.message : String(e)}`;
 		scope.assertionFailures.push(toAssertionFailure(message, e instanceof Error ? e : void 0));
 	}
+	if (!nonAssertError && evalDef.outputsSchema) {
+		const parsedOutputs = evalDef.outputsSchema.safeParse(getOutputsSchemaInput(evalDef.outputsSchema, scope.outputs));
+		if (parsedOutputs.success) scope.outputs = {
+			...scope.outputs,
+			...parsedOutputs.data
+		};
+		else scope.assertionFailures.push(toAssertionFailure(formatOutputsSchemaError(parsedOutputs.error)));
+	}
 	const scoreResults = /* @__PURE__ */ new Map();
 	const scoringTraces = {};
-	if (!nonAssertError && evalDef.scores) for (const [key, def] of Object.entries(evalDef.scores)) {
+	if (!nonAssertError && scope.assertionFailures.length === 0 && evalDef.scores) for (const [key, def] of Object.entries(evalDef.scores)) {
 		const { compute, passThreshold, label } = normalizeScoreDef(def);
-		const scoreRun = await runInEvalScope(evalCase.id, async () => await callWithUnknownResult(compute, [{
+		const scoreRun = await runInEvalScope(evalCase.id, async () => {
+			const computeScore = async () => await callWithUnknownResult(compute, [{
+				input: evalCase.input,
+				outputs: { ...scope.outputs },
+				case: evalCase
+			}]);
+			if (moduleIsolation === void 0) return await computeScore();
+			return await runWithModuleIsolation(moduleIsolation, computeScore);
+		}, {
 			input: evalCase.input,
-			outputs: { ...scope.outputs },
-			case: evalCase
-		}]), { cacheContext: cacheAdapter ? {
-			adapter: cacheAdapter,
-			mode: cacheMode,
-			evalId: `${evalId}__score__${key}`,
-			codeFingerprint
-		} : void 0 });
+			cacheContext: cacheAdapter ? {
+				adapter: cacheAdapter,
+				mode: cacheMode,
+				evalId: `${evalId}__score__${key}`,
+				codeFingerprint
+			} : void 0
+		});
 		const { trace, traceDisplay } = resolveTracePresentation(scoreRun.scope.spans, globalTraceDisplay, evalDef.traceDisplay);
 		if (trace.length > 0) scoringTraces[key] = {
 			trace,
@@ -2638,200 +3123,61 @@ async function runCase(params) {
 		input: evalCase.input,
 		trace: displayTrace,
 		traceDisplay,
-		columns,
-		assertionFailures: scope.assertionFailures,
-		error: errorInfo,
-		trial
-	};
-	if (Object.keys(scoringTraces).length > 0) caseDetail.scoringTraces = scoringTraces;
-	return {
-		caseDetail,
-		caseRowUpdate: {
-			status,
-			latencyMs: Date.now() - startTime,
-			columns
-		}
-	};
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-function isBlob(value) {
-	return value instanceof Blob;
-}
-function toAssertionFailure(message, error = void 0) {
-	return error?.stack ? {
-		message,
-		stack: error.stack
-	} : { message };
-}
-//#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) {
-	await writeFile(join(runDir, "case-details", `${encodeCaseDetailFileName(caseDetail.caseId)}.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.id, 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 evalId of getRunEvalIds(run, knownEvalMetas.map((evalMeta) => evalMeta.id))) latestRunInfos.set(evalId, {
-		status: getEvalStatusForRun(run, evalId, manualScoreKeysByEval.get(evalId) ?? []),
-		startedAt: getRunFreshnessTimestamp(run.manifest),
-		commitSha: run.manifest.commitSha ?? null,
-		evalSourceFingerprint: run.manifest.evalSourceFingerprints[evalId] ?? 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;
+		columns,
+		assertionFailures: scope.assertionFailures,
+		error: errorInfo,
+		trial
+	};
+	if (Object.keys(scoringTraces).length > 0) caseDetail.scoringTraces = scoringTraces;
 	return {
-		runDir,
-		manifest,
-		summary,
-		cases: await readCaseRows(runDir),
-		caseDetails: await readCaseDetails(runDir)
+		caseDetail,
+		caseRowUpdate: {
+			status,
+			latencyMs: Date.now() - startTime,
+			columns
+		}
 	};
 }
-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.caseId, detail);
-	}
-	return caseDetails;
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
 }
-function getRunEvalIds(run, knownEvalIds) {
-	const evalIds = new Set(run.cases.map((caseRow) => caseRow.evalId));
-	if (run.manifest.target.mode === "evalIds") for (const evalId of run.manifest.target.evalIds ?? []) evalIds.add(evalId);
-	else if (run.manifest.target.mode === "all" && evalIds.size === 0) for (const evalId of knownEvalIds) evalIds.add(evalId);
-	return [...evalIds];
+function isBlob(value) {
+	return value instanceof Blob;
 }
-function getEvalStatusForRun(run, evalId, manualScoreKeys) {
-	const evalCases = run.cases.filter((caseRow) => caseRow.evalId === evalId);
-	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 getOutputsSchemaInput(schema, outputs) {
+	if (!(schema instanceof z.ZodObject)) return outputs;
+	const configuredOutputs = {};
+	for (const key of Object.keys(schema.shape)) if (key in outputs) configuredOutputs[key] = outputs[key];
+	return configuredOutputs;
 }
-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 formatOutputsSchemaError(error) {
+	const issueLines = error.issues.map((issue) => {
+		return `${issue.path.length > 0 ? issue.path.join(".") : "<root>"}: ${issue.message}`;
+	});
+	if (issueLines.length === 0) return "outputsSchema validation failed";
+	return `outputsSchema validation failed:\n${issueLines.join("\n")}`;
 }
-function encodeCaseDetailFileName(caseId) {
-	return encodeURIComponent(caseId);
+function toAssertionFailure(message, error = void 0) {
+	return error?.stack ? {
+		message,
+		stack: error.stack
+	} : { message };
 }
 //#endregion
 //#region ../runner/src/runQueue.ts
 async function executeQueuedCases(params) {
-	const { runState, queuedCases, concurrency, globalTraceDisplay } = 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 (!runState.abortController.signal.aborted && workerError === void 0) {
+		while (workerError === void 0) {
 			const queuedCase = queuedCases[nextCaseIndex];
 			nextCaseIndex += 1;
 			if (queuedCase === void 0) return;
 			try {
 				await executeQueuedCase({
 					queuedCase,
-					runState,
 					globalTraceDisplay
 				});
 			} catch (error) {
@@ -2845,11 +3191,10 @@ async function executeQueuedCases(params) {
 	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, runState, globalTraceDisplay } = params;
+	const { queuedCase, globalTraceDisplay } = params;
 	const startTime = Date.now();
 	const result = await queuedCase.execute({
 		globalTraceDisplay,
-		signal: runState.abortController.signal,
 		startTime
 	});
 	await queuedCase.onComplete(result);
@@ -2900,7 +3245,48 @@ function pickWinningTrial(params) {
 	if (medianAttempt === void 0) throw new Error("Expected at least one trial attempt");
 	return medianAttempt;
 }
-async function executeRun({ runState, request, runDir, config, evals, cacheStore, lastRunStatusMap, latestRunInfoMap, emitEvent, emitDiscoveryEvent, getSourceFingerprint, getConfiguredConcurrency, getSortedEvalMetas, getTargetEvals }) {
+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();
+	runState.cases.push(winningTrial.caseRow);
+	runState.caseDetails.set(preparedCase.caseId, winningTrial.caseDetail);
+	preparedEval.mergeColumns(winningTrial.caseDetail.columns);
+	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", `${preparedCase.caseId}.json`), JSON.stringify(winningTrial.caseDetail.trace, null, 2));
+	await persistCaseDetail(runDir, winningTrial.caseDetail);
+	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.evalId}\u0000${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.id}\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, evals, cacheStore, lastRunStatusMap, latestRunInfoMap, emitEvent, emitDiscoveryEvent, workspaceRoot, getSourceFingerprint, getConfiguredConcurrency, getSortedEvalMetas, getTargetEvals, onCaseFinished }) {
 	try {
 		const targetEvals = getTargetEvals(request);
 		emitEvent(runState, {
@@ -2909,14 +3295,16 @@ async function executeRun({ runState, request, runDir, config, evals, cacheStore
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			payload: runState.manifest
 		});
-		const allCaseRows = [];
 		const evalErrors = [];
 		const queuedCases = [];
 		const preparedEvals = [];
 		const cacheMode = runState.manifest.cacheMode ?? "use";
 		const cacheEnabled = config.cache?.enabled !== false;
+		const moduleIsolation = {
+			key: runState.manifest.id,
+			workspaceRoot
+		};
 		for (const evalMeta of targetEvals) {
-			if (runState.abortController.signal.aborted) break;
 			const evalFilePath = evalMeta.sourceFilePath;
 			let codeFingerprint = "";
 			try {
@@ -2928,7 +3316,9 @@ async function executeRun({ runState, request, runDir, config, evals, cacheStore
 			else delete runState.manifest.evalSourceFingerprints[evalMeta.id];
 			try {
 				const registry = getEvalRegistry();
-				await loadEvalModule(evalFilePath, codeFingerprint);
+				await runWithModuleIsolation(moduleIsolation, async () => {
+					await loadEvalModule(evalFilePath, codeFingerprint);
+				});
 				const entry = registry.get(evalMeta.id);
 				if (!entry) {
 					evalErrors.push({
@@ -2937,74 +3327,87 @@ async function executeRun({ runState, request, runDir, config, evals, cacheStore
 					});
 					continue;
 				}
-				await entry.use(async (evalDef) => {
-					const cases = filterEvalCases(resolveRunnableEvalCases({
-						cases: typeof evalDef.cases === "function" ? await evalDef.cases() : evalDef.cases ?? [],
-						evalId: evalMeta.id
-					}), request.target.evalIds, request.target.caseIds, evalMeta.id);
-					runState.summary.totalCases += cases.length;
-					const accumulatedColumns = /* @__PURE__ */ new Map();
-					const evalCaseRows = [];
-					const preparedCases = [];
-					const scoreKeys = Object.freeze(Object.keys(evalDef.scores ?? {}));
-					const manualScoreKeys = Object.freeze(Object.keys(evalDef.manualScores ?? {}));
-					preparedEvals.push({
-						evalMeta,
-						accumulatedColumns,
-						evalCaseRows,
-						preparedCases,
-						scoreKeys: Object.freeze([...scoreKeys, ...manualScoreKeys]),
-						mergeColumns: (columns) => {
-							mergeColumnDefs(accumulatedColumns, columns, evalDef.columns, evalDef.scores, evalDef.manualScores);
-						}
-					});
-					for (const evalCase of cases) {
-						if (runState.abortController.signal.aborted) break;
-						const trialResults = [];
-						preparedCases.push({
-							caseId: evalCase.id,
-							trialResults
-						});
-						for (let trial = 0; trial < request.trials; trial++) {
-							const bufferedCacheStore = cacheEnabled && cacheMode !== "bypass" ? createBufferedCacheStore(cacheStore) : null;
-							queuedCases.push({
-								execute: async ({ startTime, signal, globalTraceDisplay }) => {
-									const { caseDetail, caseRowUpdate } = await runCase({
-										evalDef,
-										evalId: evalMeta.id,
-										evalCase,
-										globalTraceDisplay,
-										trial,
-										signal,
-										startTime,
-										cacheAdapter: bufferedCacheStore ?? (cacheEnabled ? cacheStore : null),
-										cacheMode,
-										codeFingerprint,
-										artifactDir: join(runDir, "artifacts"),
-										runId: runState.manifest.id
-									});
-									return {
-										caseDetail,
-										caseRow: {
-											caseId: evalCase.id,
+				await runWithModuleIsolation(moduleIsolation, async () => {
+					await entry.use(async (evalDef) => {
+						const cases = filterEvalCases(resolveRunnableEvalCases({
+							cases: typeof evalDef.cases === "function" ? await evalDef.cases() : evalDef.cases ?? [],
+							evalId: evalMeta.id
+						}), request.target.evalIds, request.target.caseIds, evalMeta.id);
+						runState.summary.totalCases += cases.length;
+						const accumulatedColumns = /* @__PURE__ */ new Map();
+						const evalCaseRows = [];
+						const preparedCases = [];
+						const scoreKeys = Object.freeze(Object.keys(evalDef.scores ?? {}));
+						const manualScoreKeys = Object.freeze(Object.keys(evalDef.manualScores ?? {}));
+						const preparedEval = {
+							evalMeta,
+							accumulatedColumns,
+							evalCaseRows,
+							preparedCases,
+							scoreKeys: Object.freeze([...scoreKeys, ...manualScoreKeys]),
+							mergeColumns: (columns) => {
+								mergeColumnDefs(accumulatedColumns, columns, evalDef.columns, evalDef.scores, evalDef.manualScores);
+							}
+						};
+						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;
+								queuedCases.push({
+									execute: async ({ startTime, globalTraceDisplay }) => {
+										const { caseDetail, caseRowUpdate } = await runCase({
+											evalDef,
 											evalId: evalMeta.id,
-											status: caseRowUpdate.status ?? "pending",
-											latencyMs: caseRowUpdate.latencyMs ?? null,
-											columns: caseRowUpdate.columns ?? {},
-											trial
-										}
-									};
-								},
-								onComplete: ({ caseDetail, caseRow }) => {
-									trialResults.push({
-										caseDetail,
-										caseRow,
-										bufferedCacheStore
-									});
-								}
-							});
+											evalCase,
+											globalTraceDisplay,
+											trial,
+											startTime,
+											cacheAdapter: bufferedCacheStore ?? (cacheEnabled ? cacheStore : null),
+											cacheMode,
+											codeFingerprint,
+											moduleIsolation,
+											artifactDir: join(runDir, "artifacts"),
+											runId: runState.manifest.id
+										});
+										return {
+											caseDetail,
+											caseRow: {
+												caseId: evalCase.id,
+												evalId: evalMeta.id,
+												status: caseRowUpdate.status ?? "pending",
+												latencyMs: caseRowUpdate.latencyMs ?? null,
+												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);
@@ -3022,37 +3425,19 @@ async function executeRun({ runState, request, runDir, config, evals, cacheStore
 			}
 		}
 		await executeQueuedCases({
-			runState,
 			queuedCases,
 			concurrency: getConfiguredConcurrency(),
 			globalTraceDisplay: config.traceDisplay
 		});
 		for (const preparedEval of preparedEvals) {
-			for (const preparedCase of preparedEval.preparedCases) {
-				if (preparedCase.trialResults.length === 0) continue;
-				const winningTrial = pickWinningTrial({
-					strategy: runState.manifest.trialSelection,
-					attempts: preparedCase.trialResults,
-					scoreKeys: preparedEval.scoreKeys
-				});
-				if (winningTrial.bufferedCacheStore !== null) await winningTrial.bufferedCacheStore.commit();
-				runState.cases.push(winningTrial.caseRow);
-				runState.caseDetails.set(preparedCase.caseId, winningTrial.caseDetail);
-				preparedEval.mergeColumns(winningTrial.caseDetail.columns);
-				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", `${preparedCase.caseId}.json`), JSON.stringify(winningTrial.caseDetail.trace, null, 2));
-				await persistCaseDetail(runDir, winningTrial.caseDetail);
-				emitEvent(runState, {
-					type: "case.finished",
-					runId: runState.manifest.id,
-					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-					payload: winningTrial.caseRow
-				});
-				preparedEval.evalCaseRows.push(winningTrial.caseRow);
-				allCaseRows.push(winningTrial.caseRow);
-			}
+			for (const preparedCase of preparedEval.preparedCases) await finalizePreparedCase({
+				runState,
+				runDir,
+				preparedEval,
+				preparedCase,
+				onCaseFinished,
+				emitEvent
+			});
 			preparedEval.evalMeta.columnDefs = [...preparedEval.accumulatedColumns.values()];
 			lastRunStatusMap.set(preparedEval.evalMeta.id, toLastRunStatus(deriveStatusFromCaseRows({ caseRows: preparedEval.evalCaseRows })));
 			const latestStatus = lastRunStatusMap.get(preparedEval.evalMeta.id) ?? null;
@@ -3063,9 +3448,11 @@ async function executeRun({ runState, request, runDir, config, evals, cacheStore
 				evalSourceFingerprint: runState.manifest.evalSourceFingerprints[preparedEval.evalMeta.id] ?? 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 = runState.abortController.signal.aborted ? "cancelled" : evalErrors.length > 0 ? "error" : "completed";
+		const finalStatus = evalErrors.length > 0 ? "error" : "completed";
 		runState.summary.status = finalStatus;
 		runState.manifest.status = finalStatus;
 		const completedRunAt = endTime.toISOString();
@@ -3087,6 +3474,7 @@ async function executeRun({ runState, request, runDir, config, evals, cacheStore
 				evalSourceFingerprint: runState.manifest.evalSourceFingerprints[evalId] ?? null
 			});
 		}
+		await persistRunState(runState);
 		emitEvent(runState, {
 			type: "run.summary",
 			runId: runState.manifest.id,
@@ -3105,7 +3493,6 @@ async function executeRun({ runState, request, runDir, config, evals, cacheStore
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			payload: runState.summary
 		});
-		await persistRunState(runState);
 		emitDiscoveryEvent();
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
@@ -3113,13 +3500,13 @@ async function executeRun({ runState, request, runDir, config, evals, cacheStore
 		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 }
 		});
-		await persistRunState(runState);
 		emitDiscoveryEvent();
 	}
 }
@@ -3127,872 +3514,4 @@ function toLastRunStatus(status) {
 	return status === "pending" ? null : status;
 }
 //#endregion
-//#region ../runner/src/runner.ts
-const globMagicCharacters = new Set([
-	"*",
-	"?",
-	"[",
-	"]",
-	"{",
-	"}",
-	"(",
-	")",
-	"!",
-	"+",
-	"@"
-]);
-function hasGlobMagic(value) {
-	for (const char of value) if (globMagicCharacters.has(char)) return true;
-	return false;
-}
-function getWatchRootForIncludePattern(params) {
-	const segments = params.pattern.replaceAll("\\", "/").split("/").filter((part) => part !== "");
-	const firstGlobSegmentIndex = segments.findIndex(hasGlobMagic);
-	if (firstGlobSegmentIndex === -1) return dirname(resolve(params.workspaceRoot, params.pattern));
-	if (firstGlobSegmentIndex === 0) return params.workspaceRoot;
-	return resolve(params.workspaceRoot, segments.slice(0, firstGlobSegmentIndex).join("/"));
-}
-function getWatchRootsForIncludePatterns(params) {
-	const roots = /* @__PURE__ */ new Set();
-	for (const pattern of params.patterns) roots.add(getWatchRootForIncludePattern({
-		pattern,
-		workspaceRoot: params.workspaceRoot
-	}));
-	if (roots.size === 0) return [params.workspaceRoot];
-	return [...roots];
-}
-/** Create an in-memory eval runner bound to the current workspace config. */
-function createRunner({ watchForChanges = true } = {}) {
-	let config;
-	let workspaceRoot;
-	let localStateDir;
-	let cacheStore;
-	const evals = /* @__PURE__ */ new Map();
-	const runs = /* @__PURE__ */ new Map();
-	const lastRunStatusMap = /* @__PURE__ */ new Map();
-	const latestRunInfoMap = /* @__PURE__ */ new Map();
-	const discoveryListeners = /* @__PURE__ */ new Set();
-	let nextShortIdNum = 0;
-	let discoveryWatcher;
-	let discoveryRefreshTimer;
-	function toWorkspaceRelativePath(filePath) {
-		return relative(workspaceRoot, filePath).replaceAll("\\", "/");
-	}
-	function getSortedEvalMetas() {
-		return [...evals.values()].toSorted((a, b) => a.filePath.localeCompare(b.filePath));
-	}
-	function getSourceFingerprint(source) {
-		return createHash("sha256").update(source).digest("hex");
-	}
-	function getConfiguredConcurrency() {
-		const configuredConcurrency = config.concurrency;
-		if (typeof configuredConcurrency !== "number" || !Number.isFinite(configuredConcurrency)) return 1;
-		return Math.max(1, Math.floor(configuredConcurrency));
-	}
-	const runner = {
-		async init() {
-			config = await loadConfig();
-			workspaceRoot = config.workspaceRoot ?? process.cwd();
-			localStateDir = resolve(workspaceRoot, ".agent-evals");
-			await mkdir(localStateDir, { recursive: true });
-			await mkdir(join(localStateDir, "runs"), { recursive: true });
-			cacheStore = createFsCacheStore({
-				workspaceRoot,
-				dir: config.cache?.dir,
-				maxEntriesPerEval: config.cache?.maxEntriesPerEval
-			});
-			await loadPersistedRuns();
-			await runner.refreshDiscovery();
-			if (watchForChanges) await setupWatcher();
-		},
-		async listCache() {
-			return cacheStore.list();
-		},
-		async clearCache(filter) {
-			await cacheStore.clear(filter);
-		},
-		async recomputeStatusesForEval(evalId) {
-			const evalMeta = evals.get(evalId);
-			if (!evalMeta) return { updatedRuns: 0 };
-			const registry = getEvalRegistry();
-			await loadEvalModule(evalMeta.sourceFilePath, evalMeta.sourceFingerprint ?? void 0);
-			const entry = registry.get(evalId);
-			if (!entry) return { updatedRuns: 0 };
-			const scoreThresholds = /* @__PURE__ */ new Map();
-			entry.use((evalDef) => {
-				for (const [key, def] of Object.entries(evalDef.scores ?? {})) {
-					const threshold = normalizeScoreDef(def).passThreshold;
-					if (threshold !== void 0) scoreThresholds.set(key, threshold);
-				}
-				for (const [key, def] of Object.entries(evalDef.manualScores ?? {})) if (def.passThreshold !== void 0) scoreThresholds.set(key, def.passThreshold);
-			});
-			const updatedRuns = await recomputeEvalStatusesInRuns({
-				runs: runs.values(),
-				evalId,
-				evalExists: evals.has(evalId),
-				scoreThresholds,
-				persistCaseDetail
-			});
-			emitDiscoveryEvent();
-			return { updatedRuns };
-		},
-		async cleanRunsForEval(evalId) {
-			let deletedRuns = 0;
-			for (const [runId, run] of [...runs]) {
-				if (!runTouchesEval({
-					target: run.manifest.target,
-					caseRows: run.cases,
-					evalId,
-					evalExists: evals.has(evalId)
-				})) continue;
-				if (run.manifest.status === "running") continue;
-				runs.delete(runId);
-				await rm(run.runDir, {
-					recursive: true,
-					force: true
-				});
-				deletedRuns += 1;
-			}
-			emitDiscoveryEvent();
-			return { deletedRuns };
-		},
-		async updateManualScore({ runId, caseId, scoreKey, value }) {
-			const run = runs.get(runId);
-			if (!run) return {
-				updated: false,
-				reason: "Run not found"
-			};
-			if (run.manifest.status === "running") return {
-				updated: false,
-				reason: "Run is still running"
-			};
-			const caseRow = run.cases.find((row) => row.caseId === caseId);
-			if (!caseRow) return {
-				updated: false,
-				reason: "Case not found"
-			};
-			const evalMeta = evals.get(caseRow.evalId);
-			if (!evalMeta) return {
-				updated: false,
-				reason: "Eval not found"
-			};
-			if (evalMeta.columnDefs.find((def) => def.key === scoreKey)?.isManualScore !== true) return {
-				updated: false,
-				reason: "Manual score not found"
-			};
-			const caseDetail = run.caseDetails.get(caseId);
-			if (!caseDetail) return {
-				updated: false,
-				reason: "Case detail not found"
-			};
-			caseRow.columns[scoreKey] = value;
-			caseDetail.columns[scoreKey] = value;
-			const scoreThresholds = /* @__PURE__ */ new Map();
-			for (const def of evalMeta.columnDefs) {
-				if (def.isScore !== true || def.passThreshold === void 0) continue;
-				scoreThresholds.set(def.key, def.passThreshold);
-			}
-			const nextStatus = recomputePersistedCaseStatus(caseRow, caseDetail, scoreThresholds);
-			caseRow.status = nextStatus;
-			caseDetail.status = nextStatus;
-			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;
-			run.summary.totalDurationMs = derivedSummary.totalDurationMs;
-			await persistCaseDetail(run.runDir, caseDetail);
-			await persistRunState(run);
-			emitDiscoveryEvent();
-			return {
-				updated: true,
-				run: {
-					manifest: run.manifest,
-					summary: run.summary,
-					cases: run.cases
-				},
-				caseDetail
-			};
-		},
-		async deleteRun(runId) {
-			const run = runs.get(runId);
-			if (!run) return { deleted: false };
-			if (run.manifest.status === "running") return { deleted: false };
-			runs.delete(runId);
-			await rm(run.runDir, {
-				recursive: true,
-				force: true
-			});
-			emitDiscoveryEvent();
-			return { deleted: true };
-		},
-		getEvals() {
-			const gitState = readGitWorktreeState(workspaceRoot);
-			const result = [];
-			for (const meta of getSortedEvalMetas()) result.push(buildEvalSummary({
-				meta,
-				config,
-				gitState,
-				latestRun: latestRunInfoMap.get(meta.id),
-				lastRunStatus: lastRunStatusMap.get(meta.id) ?? null
-			}));
-			return result;
-		},
-		getEval(id) {
-			const meta = evals.get(id);
-			if (!meta) return void 0;
-			return buildEvalSummary({
-				meta,
-				config,
-				gitState: readGitWorktreeState(workspaceRoot),
-				latestRun: latestRunInfoMap.get(meta.id),
-				lastRunStatus: lastRunStatusMap.get(meta.id) ?? null
-			});
-		},
-		async refreshDiscovery() {
-			const patterns = config.include;
-			const discovered = [];
-			for (const pattern of patterns) {
-				const files = await glob(pattern, {
-					cwd: workspaceRoot,
-					absolute: true
-				});
-				discovered.push(...files);
-			}
-			evals.clear();
-			for (const filePath of discovered) try {
-				const content = await readFile(filePath, "utf-8");
-				const discoveredMetas = parseEvalMetas(filePath, content);
-				const sourceFingerprint = getSourceFingerprint(content);
-				const registry = getEvalRegistry();
-				try {
-					await loadEvalModule(filePath, sourceFingerprint);
-				} catch {}
-				for (const meta of discoveredMetas) {
-					const discoveredEntry = registry.get(meta.id);
-					const title = meta.title;
-					let columnDefs = buildDeclaredColumnDefs(void 0, void 0, void 0);
-					let stats;
-					let charts;
-					discoveredEntry?.use((evalDef) => {
-						columnDefs = buildDeclaredColumnDefs(evalDef.columns, evalDef.scores, evalDef.manualScores);
-						stats = evalDef.stats;
-						const validated = validateCharts({
-							charts: evalDef.charts,
-							columnDefs,
-							evalId: meta.id
-						});
-						for (const warning of validated.warnings) console.warn(warning);
-						charts = validated.charts;
-					});
-					evals.set(meta.id, {
-						id: meta.id,
-						title,
-						filePath: toWorkspaceRelativePath(meta.filePath),
-						sourceFilePath: meta.filePath,
-						sourceFingerprint,
-						columnDefs,
-						caseCount: null,
-						stats,
-						charts
-					});
-				}
-			} catch {}
-			emitDiscoveryEvent();
-		},
-		async startRun(request) {
-			const runId = generateRunId();
-			const shortId = `r${String(nextShortIdNum++)}`;
-			const now = (/* @__PURE__ */ new Date()).toISOString();
-			const cacheMode = request.cache?.mode ?? "use";
-			const runDir = join(localStateDir, "runs", runId);
-			const manifest = {
-				id: runId,
-				shortId,
-				status: "running",
-				startedAt: now,
-				endedAt: null,
-				commitSha: readGitWorktreeState(workspaceRoot).commitSha,
-				evalSourceFingerprints: {},
-				target: request.target,
-				trials: request.trials,
-				trialSelection: config.trialSelection ?? "lowestScore",
-				cacheMode
-			};
-			const summary = {
-				runId,
-				status: "running",
-				totalCases: 0,
-				passedCases: 0,
-				failedCases: 0,
-				errorCases: 0,
-				cancelledCases: 0,
-				totalDurationMs: null,
-				errorMessage: null
-			};
-			const abortController = new AbortController();
-			const runState = {
-				runDir,
-				manifest,
-				summary,
-				cases: [],
-				caseDetails: /* @__PURE__ */ new Map(),
-				listeners: /* @__PURE__ */ new Set(),
-				abortController
-			};
-			runs.set(runId, runState);
-			setLatestRunInfoMap({
-				latestRunInfoMap,
-				evalIds: getTargetEvalIds({
-					request,
-					sortedEvalIds: getSortedEvalMetas().map((meta) => meta.id),
-					knownEvalIds: new Set(evals.keys())
-				}),
-				info: {
-					status: "running",
-					startedAt: now,
-					commitSha: manifest.commitSha ?? null,
-					evalSourceFingerprint: null
-				}
-			});
-			await mkdir(runDir, { recursive: true });
-			await mkdir(join(runDir, "traces"), { recursive: true });
-			await mkdir(join(runDir, "artifacts"), { recursive: true });
-			await mkdir(join(runDir, "case-details"), { recursive: true });
-			await writeFile(join(runDir, "run.json"), JSON.stringify(manifest, null, 2));
-			executeRun({
-				runState,
-				request,
-				runDir,
-				config,
-				evals,
-				cacheStore,
-				lastRunStatusMap,
-				latestRunInfoMap,
-				emitEvent,
-				emitDiscoveryEvent,
-				getSourceFingerprint,
-				getConfiguredConcurrency,
-				getSortedEvalMetas,
-				getTargetEvals
-			});
-			return {
-				manifest,
-				summary,
-				cases: []
-			};
-		},
-		getRuns() {
-			return [...runs.values()].map((r) => r.manifest);
-		},
-		getRun(id) {
-			const run = runs.get(id);
-			if (!run) return void 0;
-			return {
-				manifest: run.manifest,
-				summary: run.summary,
-				cases: run.cases
-			};
-		},
-		cancelRun(id) {
-			const run = runs.get(id);
-			if (!run) return;
-			run.abortController.abort();
-			run.manifest.status = "cancelled";
-			run.manifest.endedAt = (/* @__PURE__ */ new Date()).toISOString();
-			run.summary.status = "cancelled";
-			emitEvent(run, {
-				type: "run.cancelled",
-				runId: id,
-				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-				payload: run.summary
-			});
-		},
-		getCaseDetail(runId, caseId) {
-			const run = runs.get(runId);
-			if (!run) return void 0;
-			return run.caseDetails.get(caseId);
-		},
-		subscribe(runId, listener) {
-			const run = runs.get(runId);
-			if (!run) return () => {};
-			run.listeners.add(listener);
-			return () => {
-				run.listeners.delete(listener);
-			};
-		},
-		subscribeDiscovery(listener) {
-			discoveryListeners.add(listener);
-			return () => {
-				discoveryListeners.delete(listener);
-			};
-		},
-		async close() {
-			if (discoveryRefreshTimer !== void 0) {
-				clearTimeout(discoveryRefreshTimer);
-				discoveryRefreshTimer = void 0;
-			}
-			const watcher = discoveryWatcher;
-			if (watcher === void 0) return;
-			discoveryWatcher = void 0;
-			await watcher.close();
-		},
-		getWorkspaceRoot() {
-			return workspaceRoot;
-		},
-		getArtifactPath(artifactId_) {
-			return resolveArtifactPath(join(localStateDir, "runs"), artifactId_);
-		}
-	};
-	async function setupWatcher() {
-		const watcher = watch(getWatchRootsForIncludePatterns({
-			patterns: config.include,
-			workspaceRoot
-		}), {
-			ignoreInitial: true,
-			persistent: true
-		});
-		discoveryWatcher = watcher;
-		const scheduleRefresh = () => {
-			if (discoveryRefreshTimer !== void 0) clearTimeout(discoveryRefreshTimer);
-			discoveryRefreshTimer = setTimeout(() => {
-				discoveryRefreshTimer = void 0;
-				runner.refreshDiscovery();
-			}, 50);
-		};
-		watcher.on("change", scheduleRefresh);
-		watcher.on("add", scheduleRefresh);
-		watcher.on("unlink", scheduleRefresh);
-		watcher.on("addDir", scheduleRefresh);
-		watcher.on("unlinkDir", scheduleRefresh);
-		await new Promise((ready) => {
-			watcher.once("ready", ready);
-		});
-	}
-	function emitDiscoveryEvent() {
-		const lastRunStatuses = getLastRunStatuses({
-			runs: runs.values(),
-			knownEvals: evals.values()
-		});
-		const latestRunInfos = getLatestRunInfos({
-			runs: runs.values(),
-			knownEvals: evals.values()
-		});
-		lastRunStatusMap.clear();
-		for (const [evalId, status] of lastRunStatuses) lastRunStatusMap.set(evalId, status);
-		latestRunInfoMap.clear();
-		for (const [evalId, info] of latestRunInfos) latestRunInfoMap.set(evalId, info);
-		const event = {
-			type: "discovery.updated",
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			payload: runner.getEvals()
-		};
-		for (const listener of discoveryListeners) listener(event);
-	}
-	function getTargetEvals(request) {
-		if (request.target.evalIds && request.target.evalIds.length > 0) return request.target.evalIds.map((id) => evals.get(id)).filter((e) => e !== void 0);
-		return getSortedEvalMetas();
-	}
-	function emitEvent(runState, event) {
-		for (const listener of runState.listeners) try {
-			listener(event);
-		} catch {}
-	}
-	async function loadPersistedRuns() {
-		runs.clear();
-		const persistedRuns = await loadPersistedRunSnapshots(localStateDir);
-		nextShortIdNum = nextShortIdFromSnapshots(persistedRuns);
-		for (const persistedRun of persistedRuns) runs.set(persistedRun.manifest.id, {
-			...persistedRun,
-			listeners: /* @__PURE__ */ new Set(),
-			abortController: new AbortController()
-		});
-	}
-	return runner;
-}
-//#endregion
-//#region src/cli.ts
-function parseArgs(argv) {
-	const args = {
-		command: "help",
-		subcommand: void 0,
-		showHelp: false,
-		helpTopic: "global",
-		unknownHelpTarget: void 0,
-		evalIds: [],
-		caseIds: [],
-		trials: 1,
-		json: false,
-		port: 4100,
-		cacheMode: "use",
-		clearCache: false,
-		all: false
-	};
-	const command = argv[0];
-	if (command === "--help" || command === "-h") {
-		args.showHelp = true;
-		return args;
-	}
-	if (isCliCommand(command)) {
-		args.command = command;
-		args.helpTopic = command === "help" ? "global" : command;
-	} else if (command !== void 0 && !command.startsWith("-")) args.unknownHelpTarget = command;
-	let cursor = 1;
-	if (args.command === "cache") {
-		const sub = argv[cursor];
-		if (sub === "list" || sub === "clear") {
-			args.subcommand = sub;
-			args.helpTopic = `cache ${sub}`;
-			cursor++;
-		} else if (sub !== void 0 && !sub.startsWith("-")) args.unknownHelpTarget = `cache ${sub}`;
-	}
-	for (let i = cursor; i < argv.length; i++) {
-		const arg = argv[i];
-		const next = argv[i + 1];
-		if (arg === "--help" || arg === "-h") args.showHelp = true;
-		else if (arg === "--eval" && next) {
-			args.evalIds.push(...next.split(","));
-			i++;
-		} else if (arg === "--case" && next) {
-			args.caseIds.push(...next.split(","));
-			i++;
-		} else if (arg === "--trials" && next) {
-			args.trials = Number(next);
-			i++;
-		} else if (arg === "--json") args.json = true;
-		else if (arg === "--port" && next) {
-			args.port = Number(next);
-			i++;
-		} else if (arg === "--cache" && next) {
-			if (next === "use" || next === "bypass" || next === "refresh") args.cacheMode = next;
-			i++;
-		} else if (arg === "--no-cache") args.cacheMode = "bypass";
-		else if (arg === "--refresh-cache") args.cacheMode = "refresh";
-		else if (arg === "--clear-cache") args.clearCache = true;
-		else if (arg === "--all") args.all = true;
-	}
-	return args;
-}
-/**
-* Run the Agent Evals CLI against the current workspace.
-*
-* @param argv Raw command-line arguments excluding the executable name.
-*/
-async function runCli(argv) {
-	const args = parseArgs(argv);
-	if (args.showHelp) {
-		if (args.unknownHelpTarget !== void 0) {
-			console.error(`No help found for "${args.unknownHelpTarget}".`);
-			process.exit(1);
-			return;
-		}
-		printHelp(args.helpTopic);
-		return;
-	}
-	switch (args.command) {
-		case "app":
-			await commandApp(args);
-			break;
-		case "list":
-			await commandList(args);
-			break;
-		case "run":
-			await commandRun(args);
-			break;
-		case "cache":
-			await commandCache(args);
-			break;
-		default:
-			printHelp(args.helpTopic);
-			break;
-	}
-}
-function isCliCommand(command) {
-	return command === "app" || command === "list" || command === "run" || command === "cache" || command === "help";
-}
-const currentDir = dirname(fileURLToPath(import.meta.url));
-const repoRoot = resolve(currentDir, "../../..");
-const pnpmCommand = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
-function hasRepoWebWorkspace() {
-	return existsSync(resolve(repoRoot, "apps/web/package.json"));
-}
-async function ensureWebUiIsBuilt() {
-	if (!hasRepoWebWorkspace()) return;
-	console.info("Preparing web UI...");
-	await new Promise((resolvePromise, rejectPromise) => {
-		const child = spawn(pnpmCommand, [
-			"--filter",
-			"@agent-evals/web",
-			"build"
-		], {
-			cwd: repoRoot,
-			stdio: "inherit"
-		});
-		child.once("error", (error) => {
-			rejectPromise(error);
-		});
-		child.once("exit", (code, signal) => {
-			if (signal) {
-				rejectPromise(/* @__PURE__ */ new Error(`Web UI build stopped with signal ${signal}.`));
-				return;
-			}
-			if (code !== 0) {
-				rejectPromise(/* @__PURE__ */ new Error(`Web UI build failed with exit code ${String(code)}.`));
-				return;
-			}
-			resolvePromise();
-		});
-	});
-}
-function isHonoAppModule(mod) {
-	if (typeof mod !== "object" || mod === null || !("app" in mod)) return false;
-	const { app } = mod;
-	return typeof app === "object" && app !== null && "fetch" in app && typeof app.fetch === "function";
-}
-function isServerRunnerModule(mod) {
-	if (typeof mod !== "object" || mod === null || !("initRunner" in mod)) return false;
-	return typeof mod.initRunner === "function";
-}
-async function commandApp(args) {
-	await ensureWebUiIsBuilt();
-	const { serve } = await import("@hono/node-server");
-	const bundledWebDist = resolve(currentDir, "apps/web/dist");
-	if (existsSync(bundledWebDist)) process.env.AGENT_EVALS_WEB_DIST = bundledWebDist;
-	const appModule = await import("./app-C5CJ1sX6.mjs");
-	const runnerModule = await import("./runner-Cdlvk56X.mjs");
-	if (!isHonoAppModule(appModule)) throw new Error("Server app module is invalid");
-	if (!isServerRunnerModule(runnerModule)) throw new Error("Server runner module is invalid");
-	await runnerModule.initRunner();
-	console.info(`Agent Evals app: http://localhost:${String(args.port)}`);
-	serve({
-		fetch: appModule.app.fetch,
-		port: args.port
-	});
-}
-async function commandList(args_) {
-	const runner = createRunner({ watchForChanges: false });
-	await runner.init();
-	const evals = runner.getEvals();
-	if (evals.length === 0) {
-		console.info("No eval files found.");
-		return;
-	}
-	console.info("Discovered evals:\n");
-	for (const ev of evals) {
-		const displayStatus = getEvalDisplayStatus({
-			freshnessStatus: ev.freshnessStatus,
-			stale: ev.stale,
-			outdated: ev.outdated,
-			lastRunStatus: ev.lastRunStatus
-		});
-		const title = getEvalTitle(ev);
-		console.info(`  ${title}`);
-		console.info(`    id: ${ev.id}`);
-		console.info(`    file: ${ev.filePath}`);
-		if (displayStatus !== "pending") console.info(`    status: ${displayStatus}`);
-		if (ev.caseCount !== null) console.info(`    cases: ${String(ev.caseCount)}`);
-		console.info("");
-	}
-}
-async function commandRun(args) {
-	const runner = createRunner({ watchForChanges: false });
-	await runner.init();
-	if (args.clearCache) {
-		await runner.clearCache();
-		if (!args.json) {
-			console.info("Cleared cache before run.");
-			console.info("");
-		}
-	}
-	const target = args.caseIds.length > 0 ? {
-		mode: "caseIds",
-		caseIds: args.caseIds,
-		evalIds: args.evalIds.length > 0 ? args.evalIds : void 0
-	} : args.evalIds.length > 0 ? {
-		mode: "evalIds",
-		evalIds: args.evalIds
-	} : { mode: "all" };
-	const run = await runner.startRun({
-		target,
-		trials: args.trials,
-		cache: { mode: args.cacheMode }
-	});
-	if (!args.json) {
-		console.info(`Run started: ${run.manifest.id}`);
-		console.info(`Trials: ${String(args.trials)}`);
-		if (args.cacheMode !== "use") console.info(`Cache mode: ${args.cacheMode}`);
-		console.info("");
-	}
-	await waitForRunCompletion(runner, run.manifest.id);
-	const finalRun = runner.getRun(run.manifest.id);
-	if (!finalRun) {
-		process.exit(1);
-		return;
-	}
-	const { summary } = finalRun;
-	if (args.json) console.info(JSON.stringify(summary, null, 2));
-	else {
-		console.info("--- Run Summary ---");
-		console.info(`Status: ${summary.status}`);
-		console.info(`Total: ${String(summary.totalCases)}`);
-		console.info(`Passed: ${String(summary.passedCases)}`);
-		console.info(`Failed: ${String(summary.failedCases)}`);
-		console.info(`Errors: ${String(summary.errorCases)}`);
-		if (summary.totalCases > 0) console.info(`Pass Rate: ${String(summary.passedCases)}/${String(summary.totalCases)}`);
-		if (summary.totalDurationMs !== null) console.info(`Duration: ${(summary.totalDurationMs / 1e3).toFixed(1)}s`);
-	}
-	if (summary.failedCases > 0 || summary.errorCases > 0) process.exit(1);
-}
-async function commandCache(args) {
-	const runner = createRunner({ watchForChanges: false });
-	await runner.init();
-	if (args.subcommand === "list" || args.subcommand === void 0) {
-		const entries = await runner.listCache();
-		if (args.json) {
-			console.info(JSON.stringify(entries, null, 2));
-			return;
-		}
-		if (entries.length === 0) {
-			console.info("No cache entries.");
-			return;
-		}
-		console.info(`Cache entries (${String(entries.length)}):\n`);
-		for (const entry of entries) {
-			console.info(`  ${entry.namespace}`);
-			console.info(`    key: ${entry.key}`);
-			console.info(`    span: ${entry.spanName} (${entry.spanKind})`);
-			console.info(`    stored: ${entry.storedAt}`);
-			console.info(`    size: ${String(entry.sizeBytes)} bytes`);
-			console.info("");
-		}
-		return;
-	}
-	if (args.subcommand === "clear") {
-		if (args.evalIds.length > 0) {
-			for (const evalId of args.evalIds) {
-				const entries = await runner.listCache();
-				const prefix = `${evalId}__`;
-				const matching = entries.filter((entry) => entry.namespace.startsWith(prefix));
-				for (const entry of matching) await runner.clearCache({
-					namespace: entry.namespace,
-					key: entry.key
-				});
-			}
-			console.info(`Cleared cache entries for: ${args.evalIds.join(", ")}`);
-			return;
-		}
-		if (args.all) {
-			await runner.clearCache();
-			console.info("Cleared all cache entries.");
-			return;
-		}
-		console.info("Refusing to clear cache without --eval <id> or --all. Use one of these flags to confirm.");
-		process.exit(1);
-		return;
-	}
-	printHelp(args.helpTopic);
-}
-async function waitForRunCompletion(runner, runId) {
-	return new Promise((resolvePromise) => {
-		const check = () => {
-			const run = runner.getRun(runId);
-			if (!run || run.manifest.status === "completed" || run.manifest.status === "cancelled" || run.manifest.status === "error") {
-				resolvePromise();
-				return;
-			}
-			setTimeout(check, 200);
-		};
-		check();
-	});
-}
-function printHelp(topic = "global") {
-	if (topic === "app") {
-		console.info(`
-agent-evals app - Start server with UI
-
-Usage:
-  agent-evals app [flags]
-
-Flags:
-  --port <n>                 Server port (default: 4100)
-  --help, -h                 Show this help
-  `);
-		return;
-	}
-	if (topic === "list") {
-		console.info(`
-agent-evals list - List discovered evals
-
-Usage:
-  agent-evals list [flags]
-
-Flags:
-  --help, -h                 Show this help
-  `);
-		return;
-	}
-	if (topic === "run") {
-		console.info(`
-agent-evals run - Run evals
-
-Usage:
-  agent-evals run [flags]
-
-Flags:
-  --eval <id>                Run specific eval(s) (comma-separated)
-  --case <id>                Run specific case(s) (comma-separated)
-  --trials <n>               Number of trials per case
-  --json                     Output run summary as JSON
-  --cache <use|bypass|refresh>  Cache mode for this run (default: use)
-  --no-cache                 Shortcut for --cache bypass
-  --refresh-cache            Shortcut for --cache refresh
-  --clear-cache              Clear the cache before starting the run
-  --help, -h                 Show this help
-  `);
-		return;
-	}
-	if (topic === "cache" || topic === "cache list" || topic === "cache clear") {
-		console.info(`
-agent-evals cache - Manage cached operation entries
-
-Usage:
-  agent-evals cache list [flags]
-  agent-evals cache clear --eval <id>
-  agent-evals cache clear --all
-
-Flags:
-  --eval <id>                Clear entries for specific eval(s) (comma-separated)
-  --all                      Confirm clearing every cached entry
-  --json                     Output cache listing as JSON
-  --help, -h                 Show this help
-  `);
-		return;
-	}
-	console.info(`
-agent-evals - LLM/Agent eval runner
-
-Commands:
-  app                        Start server with UI
-  list                       List discovered evals
-  run                        Run evals
-  cache list                 List cached operation entries
-  cache clear --eval <id>    Clear cache entries for one eval
-  cache clear --all          Clear every cached entry
-  help                       Show this help
-
-Options:
-  --eval <id>                Run specific eval(s) (comma-separated)
-  --case <id>                Run specific case(s) (comma-separated)
-  --trials <n>               Number of trials per case
-  --json                     Output results as JSON
-  --port <n>                 Server port (default: 4100)
-  --cache <use|bypass|refresh>  Cache mode for this run (default: use)
-  --no-cache                 Shortcut for --cache bypass
-  --refresh-cache            Shortcut for --cache refresh
-  --clear-cache              Clear the cache before starting the run
-  --help, -h                 Show help
-  `);
-}
-//#endregion
-export { columnKindSchema as $, evalSummarySchema as A, evalChartsConfigSchema as B, assertionFailureSchema as C, evalStatAggregateSchema as D, evalFreshnessStatusSchema as E, evalChartColorSchema as F, traceDisplayConfigSchema as G, traceAttributeDisplayInputSchema as H, evalChartConfigSchema as I, traceSpanKindSchema as J, traceDisplayInputConfigSchema as K, evalChartMetricSchema as L, evalChartAggregateSchema as M, evalChartAxisSchema as N, evalStatItemSchema as O, evalChartBuiltinMetricSchema as P, columnFormatSchema as Q, evalChartTooltipExtraSchema as R, spanCacheOptionsSchema as S, caseRowSchema as T, traceAttributeDisplayPlacementSchema as U, traceAttributeDisplayFormatSchema as V, traceAttributeDisplaySchema as W, cellValueSchema as X, traceSpanSchema as Y, columnDefSchema as Z, cacheListItemSchema as _, setEvalOutput as _t, sseEnvelopeSchema as a, buildTraceTree as at, cacheRecordingSchema as b, defineEval as bt, deriveScopedSummaryFromCases as c, evalTracer as ct, runManifestSchema as d, EvalAssertionError as dt, fileRefSchema as et, runSummarySchema as f, evalAssert as ft, cacheFileSchema as g, runInEvalScope as gt, cacheEntrySchema as h, isInEvalScope as ht, updateManualScoreRequestSchema as i, runArtifactRefSchema as it, scoreTraceSchema as j, evalStatsConfigSchema as k, deriveStatusFromCaseRows as l, hashCacheKey as lt, trialSelectionModeSchema as m, incrementEvalOutput as mt, createRunner as n, numberDisplayOptionsSchema as nt, getEvalTitle as o, captureEvalSpanError as ot, agentEvalsConfigSchema as p, getCurrentScope as pt, traceSpanErrorSchema as q, createRunRequestSchema as r, repoFileRefSchema as rt, getEvalDisplayStatus as s, evalSpan as st, runCli as t, jsonCellSchema as tt, deriveStatusFromChildStatuses as u, hashCacheKeySync as ut, cacheModeSchema as v, setScopeCacheContext as vt, caseDetailSchema as w, serializedCacheSpanSchema as x, getEvalRegistry as xt, cacheRecordingOpSchema as y, repoFile as yt, evalChartTypeSchema as z };
+export { evalChartAxisSchema as $, runManifestSchema as A, evalTracer as At, cacheRecordingSchema as B, mergeEvalOutput as Bt, updateManualScoreRequestSchema as C, numberDisplayOptionsSchema as Ct, deriveScopedSummaryFromCases as D, buildTraceTree as Dt, getEvalDisplayStatus as E, z$1 as Et, cacheFileSchema as F, evalAssert as Ft, caseRowSchema as G, defineEval as Gt, spanCacheOptionsSchema as H, setEvalOutput as Ht, cacheListItemSchema as I, getCurrentScope as It, evalStatItemSchema as J, evalFreshnessStatusSchema as K, getEvalRegistry as Kt, cacheModeSchema as L, getEvalCaseInput as Lt, agentEvalsConfigSchema as M, hashCacheKeySync as Mt, trialSelectionModeSchema as N, EvalAssertionError as Nt, deriveStatusFromCaseRows as O, captureEvalSpanError as Ot, cacheEntrySchema as P, appendToEvalOutput as Pt, evalChartAggregateSchema as Q, cacheOperationTypeSchema as R, incrementEvalOutput as Rt, createRunRequestSchema as S, jsonCellSchema as St, getEvalTitle as T, runArtifactRefSchema as Tt, assertionFailureSchema as U, setScopeCacheContext as Ut, serializedCacheSpanSchema as V, runInEvalScope as Vt, caseDetailSchema as W, repoFile as Wt, evalSummarySchema as X, evalStatsConfigSchema as Y, scoreTraceSchema as Z, loadEvalModule as _, cellValueSchema as _t, loadPersistedRunSnapshot as a, evalChartTypeSchema as at, normalizeScoreDef as b, columnKindSchema as bt, persistCaseDetail as c, traceAttributeDisplayInputSchema as ct, recomputePersistedCaseStatus as d, traceDisplayConfigSchema as dt, evalChartBuiltinMetricSchema as et, runTouchesEval as f, traceDisplayInputConfigSchema as ft, setLatestRunInfoMap as g, traceSpanWarningSchema as gt, getTargetEvalIds as h, traceSpanSchema as ht, getLatestRunInfos as i, evalChartTooltipExtraSchema as it, runSummarySchema as j, hashCacheKey as jt, deriveStatusFromChildStatuses as k, evalSpan as kt, persistRunState as l, traceAttributeDisplayPlacementSchema as lt, buildEvalSummary as m, traceSpanKindSchema as mt, generateRunId as n, evalChartConfigSchema as nt, loadPersistedRunSnapshots as o, evalChartsConfigSchema as ot, resolveArtifactPath as p, traceSpanErrorSchema as pt, evalStatAggregateSchema as q, getLastRunStatuses as r, evalChartMetricSchema as rt, nextShortIdFromSnapshots as s, traceAttributeDisplayFormatSchema as st, executeRun as t, evalChartColorSchema as tt, recomputeEvalStatusesInRuns as u, traceAttributeDisplaySchema as ut, loadConfig as v, columnDefSchema as vt, sseEnvelopeSchema as w, repoFileRefSchema as wt, createFsCacheStore as x, fileRefSchema as xt, buildDeclaredColumnDefs as y, columnFormatSchema as yt, cacheRecordingOpSchema as z, isInEvalScope as zt };