@ls-stack/agent-eval 0.4.0 → 0.6.0

package/dist/{cli-B0QmsWCU.mjs → cli-C-n-Fd4o.mjs}

@@ -1,10 +1,10 @@
 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 { 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";
@@ -70,6 +70,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 +107,7 @@ function setScopeCacheContext(scope, context) {
 async function runInEvalScope(caseId, fn, options = {}) {
 	const scope = {
 		caseId,
+		input: options.input,
 		outputs: {},
 		assertionFailures: [],
 		spans: [],
@@ -145,6 +167,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,6 +263,451 @@ function evalAssert(condition, message) {
 	throw error;
 }
 //#endregion
+//#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 isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatUnknownErrorMessage(error) {
+	if (typeof error === "string") return error;
+	if (typeof error === "number" || typeof error === "boolean") return String(error);
+	if (typeof error === "bigint") return String(error);
+	if (typeof error === "symbol") return error.description ?? "Symbol";
+	if (typeof error === "function") return error.name ? `[function ${error.name}]` : "[function]";
+	if (error === void 0) return "undefined";
+	if (error === null) return "null";
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return "Unknown error";
+	}
+}
+function getErrorExtraFields(error) {
+	return Object.fromEntries(Object.entries(error).filter(([key]) => !errorCoreFields.has(key)));
+}
+function normalizeTraceError(error, capturedAt = void 0) {
+	if (error instanceof Error) return {
+		...getErrorExtraFields(error),
+		name: error.name,
+		message: error.message,
+		stack: error.stack,
+		capturedAt
+	};
+	if (isRecord$2(error)) {
+		const extraFields = getErrorExtraFields(error);
+		const name = typeof error.name === "string" ? error.name : void 0;
+		const stack = typeof error.stack === "string" ? error.stack : void 0;
+		const message = error.message === void 0 ? formatUnknownErrorMessage(error) : formatUnknownErrorMessage(error.message);
+		return {
+			...extraFields,
+			...name === void 0 ? {} : { name },
+			message,
+			...stack === void 0 ? {} : { stack },
+			capturedAt
+		};
+	}
+	return {
+		message: String(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() {
@@ -204,7 +723,10 @@ function noopActiveSpan() {
 	return {
 		setName() {},
 		setAttribute() {},
-		setAttributes() {}
+		setAttributes() {},
+		incrementAttribute() {},
+		appendToAttribute() {},
+		mergeAttribute() {}
 	};
 }
 function noopExternalSpan(id) {
@@ -213,6 +735,9 @@ function noopExternalSpan(id) {
 		setName() {},
 		setAttribute() {},
 		setAttributes() {},
+		incrementAttribute() {},
+		appendToAttribute() {},
+		mergeAttribute() {},
 		end() {}
 	};
 }
@@ -222,6 +747,61 @@ function mergeSpanAttributes(span, attributes) {
 		...attributes
 	};
 }
+function isRecordLike(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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";
+	span.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+}
 function createSpanHandle(span) {
 	return {
 		setName(value) {
@@ -232,9 +812,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,
@@ -256,6 +852,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,
@@ -312,6 +923,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) {
@@ -340,6 +953,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({
@@ -352,7 +967,9 @@ function recordExternalSpan(info) {
 		endedAt,
 		status,
 		attributes: info.attributes,
-		error: info.error
+		error: info.error,
+		warning: info.warning,
+		warnings: info.warnings
 	});
 	return id;
 }
@@ -364,20 +981,58 @@ function recordExternalSpan(info) {
 const evalSpan = {
 	setName(value) {
 		updateCurrentSpan((currentSpan) => {
-			currentSpan.name = value;
+			currentSpan.name = value;
+		});
+	},
+	setAttribute(key, value) {
+		updateCurrentSpan((currentSpan) => {
+			mergeSpanAttributes(currentSpan, { [key]: value });
+		});
+	},
+	setAttributes(value) {
+		updateCurrentSpan((currentSpan) => {
+			mergeSpanAttributes(currentSpan, value);
+		});
+	},
+	incrementAttribute(key, delta) {
+		updateCurrentSpan((currentSpan) => {
+			incrementSpanAttribute(currentSpan, key, delta);
 		});
 	},
-	setAttribute(key, value) {
+	appendToAttribute(key, value) {
 		updateCurrentSpan((currentSpan) => {
-			mergeSpanAttributes(currentSpan, { [key]: value });
+			appendToSpanAttribute(currentSpan, key, value);
 		});
 	},
-	setAttributes(value) {
+	mergeAttribute(key, patch) {
 		updateCurrentSpan((currentSpan) => {
-			mergeSpanAttributes(currentSpan, value);
+			mergeSpanAttribute(currentSpan, key, patch);
 		});
 	}
 };
+/**
+* Attach one or more recoverable errors to the active eval span.
+*
+* 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, ...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);
+	});
+}
 async function traceSpan(info, fn) {
 	const scope = getCurrentScope();
 	if (!scope) return await fn(noopActiveSpan());
@@ -421,8 +1076,8 @@ async function traceSpan(info, fn) {
 						"cache.storedAt": storedAt,
 						"cache.age": Date.now() - new Date(storedAt).getTime()
 					});
-					replayRecording(scope, spanRecord, hit.recording);
-					spanRecord.status = "ok";
+					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;
 				}
@@ -431,7 +1086,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);
@@ -442,16 +1097,24 @@ async function traceSpan(info, fn) {
 				scope.recordingStack.pop();
 			}
 			appendSubSpanOps(scope, frame);
+			finishSpanWithoutThrownError(spanRecord);
 			if (ctx.mode !== "bypass") {
 				const recording = {
 					returnValue: toJsonSafe(bodyResult),
 					finalAttributes: stripCacheAttributes(spanRecord.attributes),
+					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(),
@@ -460,23 +1123,15 @@ async function traceSpan(info, fn) {
 				};
 				await ctx.adapter.write(entry);
 			}
-			spanRecord.status = "ok";
-			spanRecord.endedAt = (/* @__PURE__ */ new Date()).toISOString();
 			return bodyResult;
 		}
 		const result = await fn(activeSpan);
-		spanRecord.status = "ok";
-		spanRecord.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+		finishSpanWithoutThrownError(spanRecord);
 		return result;
 	} catch (error) {
 		spanRecord.status = "error";
 		spanRecord.endedAt = (/* @__PURE__ */ new Date()).toISOString();
-		if (error instanceof Error) spanRecord.error = {
-			name: error.name,
-			message: error.message,
-			stack: error.stack
-		};
-		else spanRecord.error = { message: String(error) };
+		spanRecord.error = normalizeTraceError(error);
 		throw error;
 	} finally {
 		scope.spanStack.pop();
@@ -491,6 +1146,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
@@ -571,189 +1233,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,
-		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,
-		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);
-	} 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
-	};
-	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([
@@ -886,6 +1365,15 @@ const traceAttributeDisplayInputSchema = z.object({
 });
 /** Schema for authored trace display config in eval or workspace config. */
 const traceDisplayInputConfigSchema = z.object({ attributes: z.array(traceAttributeDisplayInputSchema).optional() });
+/** Schema for an error attached to a trace span. */
+const traceSpanErrorSchema = z.object({
+	name: z.string().optional(),
+	message: z.string(),
+	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(),
@@ -902,11 +1390,10 @@ const traceSpanSchema = z.object({
 		"cancelled"
 	]),
 	attributes: z.record(z.string(), z.unknown()).optional(),
-	error: z.object({
-		name: z.string().optional(),
-		message: z.string(),
-		stack: z.string().optional()
-	}).optional()
+	error: traceSpanErrorSchema.optional(),
+	errors: z.array(traceSpanErrorSchema).optional(),
+	warning: traceSpanWarningSchema.optional(),
+	warnings: z.array(traceSpanWarningSchema).optional()
 });
 //#endregion
 //#region ../shared/src/schemas/chart.ts
@@ -1167,12 +1654,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()
@@ -1188,11 +1679,10 @@ const serializedCacheSpanSchema = z.object({
 		"error",
 		"cancelled"
 	]),
-	error: z.object({
-		name: z.string().optional(),
-		message: z.string(),
-		stack: z.string().optional()
-	}).optional()
+	error: 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.
@@ -1206,6 +1696,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(),
@@ -1225,6 +1725,16 @@ const cacheRecordingOpSchema = z.discriminatedUnion("kind", [
 const cacheRecordingSchema = z.object({
 	returnValue: z.unknown(),
 	finalAttributes: z.record(z.string(), z.unknown()),
+	finalStatus: z.enum([
+		"running",
+		"ok",
+		"error",
+		"cancelled"
+	]).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. */
@@ -1232,8 +1742,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
@@ -1543,15 +2055,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;
@@ -2442,12 +2960,15 @@ async function runCase(params) {
 			input: evalCase.input,
 			signal
 		}]);
-	}, { cacheContext: cacheAdapter ? {
-		adapter: cacheAdapter,
-		mode: cacheMode,
-		evalId,
-		codeFingerprint
-	} : void 0 });
+	}, {
+		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));
@@ -2463,20 +2984,31 @@ 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, [{
 			input: evalCase.input,
 			outputs: { ...scope.outputs },
 			case: evalCase
-		}]), { cacheContext: cacheAdapter ? {
-			adapter: cacheAdapter,
-			mode: cacheMode,
-			evalId: `${evalId}__score__${key}`,
-			codeFingerprint
-		} : void 0 });
+		}]), {
+			input: evalCase.input,
+			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,
@@ -2567,6 +3099,19 @@ function isRecord(value) {
 function isBlob(value) {
 	return value instanceof Blob;
 }
+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 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 toAssertionFailure(message, error = void 0) {
 	return error?.stack ? {
 		message,
@@ -3036,6 +3581,39 @@ function toLastRunStatus(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;
@@ -3048,6 +3626,8 @@ function createRunner({ watchForChanges = true } = {}) {
 	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("\\", "/");
 	}
@@ -3076,7 +3656,7 @@ function createRunner({ watchForChanges = true } = {}) {
 			});
 			await loadPersistedRuns();
 			await runner.refreshDiscovery();
-			if (watchForChanges) setupWatcher();
+			if (watchForChanges) await setupWatcher();
 		},
 		async listCache() {
 			return cacheStore.list();
@@ -3401,6 +3981,16 @@ function createRunner({ watchForChanges = true } = {}) {
 				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;
 		},
@@ -3408,19 +3998,29 @@ function createRunner({ watchForChanges = true } = {}) {
 			return resolveArtifactPath(join(localStateDir, "runs"), artifactId_);
 		}
 	};
-	function setupWatcher() {
-		const watcher = watch(config.include.map((p) => resolve(workspaceRoot, p)), {
+	async function setupWatcher() {
+		const watcher = watch(getWatchRootsForIncludePatterns({
+			patterns: config.include,
+			workspaceRoot
+		}), {
 			ignoreInitial: true,
 			persistent: true
 		});
-		watcher.on("change", () => {
-			runner.refreshDiscovery();
-		});
-		watcher.on("add", () => {
-			runner.refreshDiscovery();
-		});
-		watcher.on("unlink", () => {
-			runner.refreshDiscovery();
+		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() {
@@ -3467,6 +4067,7 @@ function createRunner({ watchForChanges = true } = {}) {
 //#endregion
 //#region src/cli.ts
 function parseArgs(argv) {
+	const normalizedArgv = argv.filter((arg) => arg !== "--no-env");
 	const args = {
 		command: "help",
 		subcommand: void 0,
@@ -3480,9 +4081,10 @@ function parseArgs(argv) {
 		port: 4100,
 		cacheMode: "use",
 		clearCache: false,
-		all: false
+		all: false,
+		loadEnv: normalizedArgv.length === argv.length
 	};
-	const command = argv[0];
+	const command = normalizedArgv[0];
 	if (command === "--help" || command === "-h") {
 		args.showHelp = true;
 		return args;
@@ -3493,16 +4095,16 @@ function parseArgs(argv) {
 	} else if (command !== void 0 && !command.startsWith("-")) args.unknownHelpTarget = command;
 	let cursor = 1;
 	if (args.command === "cache") {
-		const sub = argv[cursor];
+		const sub = normalizedArgv[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];
+	for (let i = cursor; i < normalizedArgv.length; i++) {
+		const arg = normalizedArgv[i];
+		const next = normalizedArgv[i + 1];
 		if (arg === "--help" || arg === "-h") args.showHelp = true;
 		else if (arg === "--eval" && next) {
 			args.evalIds.push(...next.split(","));
@@ -3534,6 +4136,10 @@ function parseArgs(argv) {
 */
 async function runCli(argv) {
 	const args = parseArgs(argv);
+	if (args.loadEnv && !loadWorkspaceEnv()) {
+		process.exit(1);
+		return;
+	}
 	if (args.showHelp) {
 		if (args.unknownHelpTarget !== void 0) {
 			console.error(`No help found for "${args.unknownHelpTarget}".`);
@@ -3564,6 +4170,18 @@ async function runCli(argv) {
 function isCliCommand(command) {
 	return command === "app" || command === "list" || command === "run" || command === "cache" || command === "help";
 }
+function loadWorkspaceEnv() {
+	const envPath = resolve(process.cwd(), ".env");
+	if (!existsSync(envPath)) return true;
+	const loadResult = resultify(() => {
+		process.loadEnvFile(envPath);
+	});
+	if (loadResult.error) {
+		console.error(`Failed to load .env at ${envPath}: ${loadResult.error.message}`);
+		return false;
+	}
+	return true;
+}
 const currentDir = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(currentDir, "../../..");
 const pnpmCommand = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
@@ -3612,8 +4230,8 @@ async function commandApp(args) {
 	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-CljutWb7.mjs");
-	const runnerModule = await import("./runner-CsSJwWE4.mjs");
+	const appModule = await import("./app-7qDBq_ub.mjs");
+	const runnerModule = await import("./runner-uzzY8kk1.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();
@@ -3714,7 +4332,8 @@ async function commandCache(args) {
 		for (const entry of entries) {
 			console.info(`  ${entry.namespace}`);
 			console.info(`    key: ${entry.key}`);
-			console.info(`    span: ${entry.spanName} (${entry.spanKind})`);
+			const operationLabel = entry.operationType === "span" ? `${entry.operationName} (span ${entry.spanKind ?? "unknown"})` : `${entry.operationName} (value)`;
+			console.info(`    operation: ${operationLabel}`);
 			console.info(`    stored: ${entry.storedAt}`);
 			console.info(`    size: ${String(entry.sizeBytes)} bytes`);
 			console.info("");
@@ -3769,6 +4388,7 @@ Usage:
 
 Flags:
   --port <n>                 Server port (default: 4100)
+  --no-env                   Disable automatic .env loading
   --help, -h                 Show this help
   `);
 		return;
@@ -3781,6 +4401,7 @@ Usage:
   agent-evals list [flags]
 
 Flags:
+  --no-env                   Disable automatic .env loading
   --help, -h                 Show this help
   `);
 		return;
@@ -3801,6 +4422,7 @@ Flags:
   --no-cache                 Shortcut for --cache bypass
   --refresh-cache            Shortcut for --cache refresh
   --clear-cache              Clear the cache before starting the run
+  --no-env                   Disable automatic .env loading
   --help, -h                 Show this help
   `);
 		return;
@@ -3818,6 +4440,7 @@ Flags:
   --eval <id>                Clear entries for specific eval(s) (comma-separated)
   --all                      Confirm clearing every cached entry
   --json                     Output cache listing as JSON
+  --no-env                   Disable automatic .env loading
   --help, -h                 Show this help
   `);
 		return;
@@ -3844,8 +4467,9 @@ Options:
   --no-cache                 Shortcut for --cache bypass
   --refresh-cache            Shortcut for --cache refresh
   --clear-cache              Clear the cache before starting the run
+  --no-env                   Disable automatic .env loading
   --help, -h                 Show help
   `);
 }
 //#endregion
-export { fileRefSchema 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, traceSpanSchema as J, traceDisplayInputConfigSchema as K, evalChartMetricSchema as L, evalChartAggregateSchema as M, evalChartAxisSchema as N, evalStatItemSchema as O, evalChartBuiltinMetricSchema as P, columnKindSchema as Q, evalChartTooltipExtraSchema as R, spanCacheOptionsSchema as S, caseRowSchema as T, traceAttributeDisplayPlacementSchema as U, traceAttributeDisplayFormatSchema as V, traceAttributeDisplaySchema as W, columnDefSchema as X, cellValueSchema as Y, columnFormatSchema as Z, cacheListItemSchema as _, repoFile as _t, sseEnvelopeSchema as a, evalSpan as at, cacheRecordingSchema as b, deriveScopedSummaryFromCases as c, hashCacheKeySync as ct, runManifestSchema as d, getCurrentScope as dt, jsonCellSchema as et, runSummarySchema as f, incrementEvalOutput as ft, cacheFileSchema as g, setScopeCacheContext as gt, cacheEntrySchema as h, setEvalOutput as ht, updateManualScoreRequestSchema as i, buildTraceTree as it, scoreTraceSchema as j, evalStatsConfigSchema as k, deriveStatusFromCaseRows as l, EvalAssertionError as lt, trialSelectionModeSchema as m, runInEvalScope as mt, createRunner as n, repoFileRefSchema as nt, getEvalTitle as o, evalTracer as ot, agentEvalsConfigSchema as p, isInEvalScope as pt, traceSpanKindSchema as q, createRunRequestSchema as r, runArtifactRefSchema as rt, getEvalDisplayStatus as s, hashCacheKey as st, runCli as t, numberDisplayOptionsSchema as tt, deriveStatusFromChildStatuses as u, evalAssert as ut, cacheModeSchema as v, defineEval as vt, caseDetailSchema as w, serializedCacheSpanSchema as x, cacheRecordingOpSchema as y, getEvalRegistry as yt, evalChartTypeSchema as z };
+export { columnDefSchema as $, evalStatsConfigSchema as A, evalChartTypeSchema as B, spanCacheOptionsSchema as C, setEvalOutput as Ct, evalFreshnessStatusSchema as D, getEvalRegistry as Dt, caseRowSchema as E, defineEval as Et, evalChartBuiltinMetricSchema as F, traceAttributeDisplaySchema as G, traceAttributeDisplayFormatSchema as H, evalChartColorSchema as I, traceSpanErrorSchema as J, traceDisplayConfigSchema as K, evalChartConfigSchema as L, scoreTraceSchema as M, evalChartAggregateSchema as N, evalStatAggregateSchema as O, evalChartAxisSchema as P, cellValueSchema as Q, evalChartMetricSchema as R, serializedCacheSpanSchema as S, runInEvalScope as St, caseDetailSchema as T, repoFile as Tt, traceAttributeDisplayInputSchema as U, evalChartsConfigSchema as V, traceAttributeDisplayPlacementSchema as W, traceSpanSchema as X, traceSpanKindSchema as Y, traceSpanWarningSchema as Z, cacheListItemSchema as _, getCurrentScope as _t, sseEnvelopeSchema as a, repoFileRefSchema as at, cacheRecordingOpSchema as b, isInEvalScope as bt, deriveScopedSummaryFromCases as c, buildTraceTree as ct, runManifestSchema as d, evalTracer as dt, columnFormatSchema as et, runSummarySchema as f, hashCacheKey as ft, cacheFileSchema as g, evalAssert as gt, cacheEntrySchema as h, appendToEvalOutput as ht, updateManualScoreRequestSchema as i, numberDisplayOptionsSchema as it, evalSummarySchema as j, evalStatItemSchema as k, deriveStatusFromCaseRows as l, captureEvalSpanError as lt, trialSelectionModeSchema as m, EvalAssertionError as mt, createRunner as n, fileRefSchema as nt, getEvalTitle as o, runArtifactRefSchema as ot, agentEvalsConfigSchema as p, hashCacheKeySync as pt, traceDisplayInputConfigSchema as q, createRunRequestSchema as r, jsonCellSchema as rt, getEvalDisplayStatus as s, z$1 as st, runCli as t, columnKindSchema as tt, deriveStatusFromChildStatuses as u, evalSpan as ut, cacheModeSchema as v, getEvalCaseInput as vt, assertionFailureSchema as w, setScopeCacheContext as wt, cacheRecordingSchema as x, mergeEvalOutput as xt, cacheOperationTypeSchema as y, incrementEvalOutput as yt, evalChartTooltipExtraSchema as z };