@ls-stack/agent-eval 0.5.0 → 0.6.0

package/dist/{cli-C5FL7C4G.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,18 +263,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 +544,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),
@@ -277,6 +573,34 @@ function normalizeTraceError(error, capturedAt = void 0) {
 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);
@@ -285,8 +609,194 @@ function appendSpanErrors(span, errors) {
 	span.error = latestError;
 	span.status = "error";
 }
-function hasSpanError(span) {
-	return span.error !== void 0 || (span.errors?.length ?? 0) > 0;
+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 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";
@@ -302,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,
@@ -326,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,
@@ -382,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) {
@@ -410,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({
@@ -422,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;
 }
@@ -446,16 +993,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 +1076,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 +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);
@@ -532,12 +1105,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 +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
@@ -649,194 +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,
-		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 +1372,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 +1391,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 +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()
@@ -1276,7 +1680,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 +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(),
@@ -1317,6 +1733,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 +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
@@ -1635,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;
@@ -2534,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));
@@ -2555,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,
@@ -2659,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,
@@ -3614,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,
@@ -3627,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;
@@ -3640,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(","));
@@ -3681,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}".`);
@@ -3711,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";
@@ -3759,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-C5CJ1sX6.mjs");
-	const runnerModule = await import("./runner-Cdlvk56X.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();
@@ -3861,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("");
@@ -3916,6 +4388,7 @@ Usage:
 
 Flags:
   --port <n>                 Server port (default: 4100)
+  --no-env                   Disable automatic .env loading
   --help, -h                 Show this help
   `);
 		return;
@@ -3928,6 +4401,7 @@ Usage:
   agent-evals list [flags]
 
 Flags:
+  --no-env                   Disable automatic .env loading
   --help, -h                 Show this help
   `);
 		return;
@@ -3948,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;
@@ -3965,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;
@@ -3991,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 { 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 { 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 };