@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/traces.js

@@ -1,13 +1,1014 @@
-import { a as providerFromBaseUrl, i as defaultProviderRedactor, n as InMemoryRawProviderSink, r as NoopRawProviderSink, t as FileSystemRawProviderSink } from "./raw-provider-sink-BQd7mzyT.js";
-import { INPUT_VALUE, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, OPENINFERENCE_SPAN_KIND, OUTPUT_VALUE, RUN_COST_ATTR_KEYS, SPAN_KIND_ATTR_KEYS, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, applyLlmSpanOtlpAttributes, asNumber, contextInputTokens, firstNumberAttr } from "./trace-attributes.js";
-import { $ as stringField, C as TraceNotFoundError, G as asString, J as firstStringAttr, S as TraceFileTooLargeError, X as projectOtlpFlatLine, Y as inferOtlpKind, Z as readOtlpStatus, _ as TraceAnalysisLimitError, b as TraceFileMalformedError, c as traceAnalystFunctionGroup, et as applyToolSpanOtlpAttributes, g as SpanNotFoundError, h as TRACE_ANALYSIS_LIMITS, l as createBoundedTraceAnalysisStore, m as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, nt as isOtlpModelCall, o as TRACE_ANALYST_TOOL_NAMESPACE, p as DEFAULT_TRACE_ANALYST_BUDGETS, q as extractOtlpAttributes, rt as traceSpanKindToOpenInferenceKind, s as buildTraceAnalysisToolDescriptors, tt as classifyOtlpSpanRole, v as TraceAnalysisStoreContractError, x as TraceFileMissingError, y as TraceAnalysisValidationError } from "./kind-factory-B8-r8-y8.js";
-import { n as llmSpanFromProvider, t as TraceEmitter } from "./emitter-CPBAhxum.js";
 import { a as isRetrievalSpan, i as isLlmSpan, n as TRACE_SCHEMA_VERSION, o as isSandboxSpan, r as isJudgeSpan, s as isToolSpan, t as FAILURE_CLASSES } from "./schema-CRhEY1SO.js";
-import { A as TRACE_ANALYST_ACTOR_DESCRIPTION, C as domainEvidencePattern, D as tokenizeDomainWords, E as scoreTraceInsightReadiness, O as traceAnalystOnRunComplete, S as describeTraceInsightScope, T as planTraceInsightQuestions, _ as otlpToTraceRunRecords, a as convertTraceStoresToOtlp, b as buildTraceInsightPrompt, c as otelRunCompleteHook, d as captureFetchToRawSink, f as ToolTraceMissingError, g as otlpToRunRecords, h as otlpRowsToTraceRunRecords, i as iterateRawCalls, j as TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, k as analyzeTraces, l as OTEL_AGENT_EVAL_SCOPE, m as otlpRowsToRunRecords, n as ReplayCacheMissError, o as createOtelExporter, p as toolSpansToTraceAnalysisStore, r as createReplayFetch, s as createOtelTracingStore, t as ReplayCache, u as exportRunAsOtlp, v as flattenOtlpExportToNdjson, w as inferDomainKeywords, x as defaultTraceInsightPanel, y as buildTraceInsightContext } from "./replay-CohS93nE.js";
-import { i as otlpTextToTraceAnalysisStore, n as OtlpFileTraceStore } from "./store-otlp-Dw8PPIlL.js";
-import { n as extractUsageFromResponse, r as extractUsageFromSse, t as extractUsage } from "./extract-usage-CdZdoj1s.js";
 import { a as judgeSpans, c as runsForScenario, i as hasCapturedToolArgs, l as toolSpans, n as argHash, o as llmSpans, r as groupBy, s as runFailureClass, t as aggregateLlm } from "./query-Di7eEQ79.js";
-import { n as InMemoryTraceStore, t as FileSystemTraceStore } from "./store-DNe_Uv1Q.js";
-import { n as assertRunCaptured, r as throwIfRunIncomplete, t as RunIntegrityError } from "./integrity-MLzHOfV9.js";
+import { r as modelHasSnapshot, s as validateRunRecord } from "./run-record-BvHPVS-i.js";
 import { i as redactValue, n as REDACTION_VERSION, r as redactString, t as DEFAULT_REDACTION_RULES } from "./redact-7Aq1ukl-.js";
-export { DEFAULT_REDACTION_RULES, DEFAULT_TRACE_ANALYST_BUDGETS, FAILURE_CLASSES, FileSystemRawProviderSink, FileSystemTraceStore, INPUT_VALUE, InMemoryRawProviderSink, InMemoryTraceStore, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, NoopRawProviderSink, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, OtlpFileTraceStore, REDACTION_VERSION, RUN_COST_ATTR_KEYS, ReplayCache, ReplayCacheMissError, RunIntegrityError, SPAN_KIND_ATTR_KEYS, SpanNotFoundError, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYSIS_LIMITS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TOOL_NAMESPACE, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, ToolTraceMissingError, TraceAnalysisLimitError, TraceAnalysisStoreContractError, TraceAnalysisValidationError, TraceEmitter, TraceFileMalformedError, TraceFileMissingError, TraceFileTooLargeError, TraceNotFoundError, aggregateLlm, analyzeTraces, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertRunCaptured, buildTraceAnalysisToolDescriptors, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, classifyOtlpSpanRole, contextInputTokens, convertTraceStoresToOtlp, createBoundedTraceAnalysisStore, createOtelExporter, createOtelTracingStore, createReplayFetch, defaultProviderRedactor, defaultTraceInsightPanel, describeTraceInsightScope, domainEvidencePattern, exportRunAsOtlp, extractOtlpAttributes, extractUsage, extractUsageFromResponse, extractUsageFromSse, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, groupBy, hasCapturedToolArgs, inferDomainKeywords, inferOtlpKind, isJudgeSpan, isLlmSpan, isOtlpModelCall, isRetrievalSpan, isSandboxSpan, isToolSpan, iterateRawCalls, judgeSpans, llmSpanFromProvider, llmSpans, otelRunCompleteHook, otlpRowsToRunRecords, otlpRowsToTraceRunRecords, otlpTextToTraceAnalysisStore, otlpToRunRecords, otlpToTraceRunRecords, planTraceInsightQuestions, projectOtlpFlatLine, providerFromBaseUrl, readOtlpStatus, redactString, redactValue, runFailureClass, runsForScenario, scoreTraceInsightReadiness, stringField, throwIfRunIncomplete, tokenizeDomainWords, toolSpans, toolSpansToTraceAnalysisStore, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceSpanKindToOpenInferenceKind };
+import { n as llmSpanFromProvider, t as TraceEmitter } from "./emitter-CPBAhxum.js";
+import { $ as classifyOtlpSpanRole, C as TraceNotFoundError, G as extractOtlpAttributes, J as projectOtlpFlatLine, K as firstStringAttr, Q as applyToolSpanOtlpAttributes, S as TraceFileTooLargeError, U as asString, W as compareSpanTime, X as spanEpochMillis, Y as readOtlpStatus, Z as stringField, _ as TraceAnalysisLimitError, b as TraceFileMalformedError, c as traceAnalystFunctionGroup, et as isOtlpModelCall, g as SpanNotFoundError, h as TRACE_ANALYSIS_LIMITS, l as createBoundedTraceAnalysisStore, m as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, o as TRACE_ANALYST_TOOL_NAMESPACE, p as DEFAULT_TRACE_ANALYST_BUDGETS, q as inferOtlpKind, s as buildTraceAnalysisToolDescriptors, tt as traceSpanKindToOpenInferenceKind, v as TraceAnalysisStoreContractError, x as TraceFileMissingError, y as TraceAnalysisValidationError } from "./kind-factory-CPmSd58s.js";
+import { INPUT_VALUE, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, OPENINFERENCE_SPAN_KIND, OUTPUT_VALUE, RUN_COST_ATTR_KEYS, SPAN_KIND_ATTR_KEYS, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, applyLlmSpanOtlpAttributes, asNumber, contextInputTokens, firstNumberAttr } from "./trace-attributes.js";
+import { n as extractUsageFromResponse, r as extractUsageFromSse, t as extractUsage } from "./extract-usage-BrQ8mCLX.js";
+import { a as providerFromBaseUrl, i as defaultProviderRedactor, n as InMemoryRawProviderSink, r as NoopRawProviderSink, t as FileSystemRawProviderSink } from "./raw-provider-sink-BQd7mzyT.js";
+import { S as captureFetchToRawSink, _ as TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, a as spanStatusToOtlp, b as spanIdForWire, c as defaultTraceInsightPanel, d as inferDomainKeywords, f as planTraceInsightQuestions, g as TRACE_ANALYST_ACTOR_DESCRIPTION, h as analyzeTraces, i as epochMillisToIso, l as describeTraceInsightScope, m as tokenizeDomainWords, n as toolSpansToTraceAnalysisStore, o as buildTraceInsightContext, p as scoreTraceInsightReadiness, r as createOtlpFlatLine, s as buildTraceInsightPrompt, t as ToolTraceMissingError, u as domainEvidencePattern, v as OTEL_AGENT_EVAL_SCOPE, x as traceIdForWire, y as exportRunAsOtlp } from "./store-tool-spans-Cq9mFd-q.js";
+import { n as assertRunCaptured, r as throwIfRunIncomplete, t as RunIntegrityError } from "./integrity-Cy9WHAtb.js";
+import { n as InMemoryTraceStore, t as FileSystemTraceStore } from "./store-DNe_Uv1Q.js";
+import { i as otlpTextToTraceAnalysisStore, n as OtlpFileTraceStore } from "./store-otlp-CsptLYpN.js";
+import { i as summarizeTraceErrors, n as recordAggregateMeasurements, r as summarizeExecutionMeasurements, t as readTaskFailureLabels } from "./task-failure-attributes-CpQ4y5RD.js";
+import { readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+//#region src/trace/otel-bridge.ts
+/**
+* Create a RunCompleteHook that exports all spans from the completed run
+* to the OTEL exporter, then flushes.
+*/
+function otelRunCompleteHook(exporter) {
+	return async (ctx) => {
+		const spans = await ctx.store.spans({ runId: ctx.runId });
+		for (const span of spans) if (span.endedAt) exporter.exportSpan(storeSpanToExportable(span, ctx.runId));
+		await exporter.flush();
+	};
+}
+/**
+* Create an auto-exporting TraceStore wrapper that intercepts updateSpan
+* calls. When a span gets an endedAt, it's exported immediately. This
+* gives real-time streaming instead of batch-at-end.
+*
+* This is the preferred integration path: wrap the store before
+* constructing the TraceEmitter.
+*/
+function createOtelTracingStore(inner, exporter, traceId) {
+	return {
+		async appendRun(run) {
+			return inner.appendRun(run);
+		},
+		async updateRun(runId, patch) {
+			return inner.updateRun(runId, patch);
+		},
+		async appendSpan(span) {
+			if (span.endedAt) exporter.exportSpan(storeSpanToExportable(span, traceId));
+			return inner.appendSpan(span);
+		},
+		async updateSpan(spanId, patch) {
+			await inner.updateSpan(spanId, patch);
+			if (patch.endedAt) {
+				const found = (await inner.spans({ runId: traceId })).find((s) => s.spanId === spanId);
+				if (found) exporter.exportSpan(storeSpanToExportable(found, traceId));
+			}
+		},
+		async appendEvent(event) {
+			return inner.appendEvent(event);
+		},
+		async appendBudgetEntry(entry) {
+			return inner.appendBudgetEntry(entry);
+		},
+		async appendArtifact(artifact) {
+			return inner.appendArtifact(artifact);
+		},
+		getRun: inner.getRun.bind(inner),
+		listRuns: inner.listRuns.bind(inner),
+		spans: inner.spans.bind(inner),
+		events: inner.events.bind(inner),
+		budget: inner.budget.bind(inner),
+		artifacts: inner.artifacts.bind(inner)
+	};
+}
+function storeSpanToExportable(span, traceId) {
+	const llm = span.kind === "llm" ? span : void 0;
+	const tool = span.kind === "tool" ? span : void 0;
+	return {
+		traceId,
+		spanId: span.spanId,
+		parentSpanId: span.parentSpanId,
+		name: span.name,
+		kind: span.kind,
+		startedAt: span.startedAt,
+		endedAt: span.endedAt,
+		status: span.status,
+		error: span.error,
+		model: llm?.model,
+		inputTokens: llm?.inputTokens,
+		outputTokens: llm?.outputTokens,
+		reasoningTokens: llm?.reasoningTokens,
+		cachedTokens: llm?.cachedTokens,
+		cacheWriteTokens: llm?.cacheWriteTokens,
+		costUsd: llm?.costUsd,
+		tool: tool ? {
+			toolName: tool.toolName,
+			args: tool.args,
+			argsCaptured: tool.argsCaptured,
+			result: tool.result,
+			latencyMs: tool.latencyMs
+		} : void 0,
+		attributes: span.attributes
+	};
+}
+//#endregion
+//#region src/trace/otel-export.ts
+/**
+* OTEL span exporter — streams spans to an OTLP/HTTP collector.
+*
+* Reads OTEL_EXPORTER_OTLP_ENDPOINT + OTEL_EXPORTER_OTLP_HEADERS from env
+* when no explicit config is given. Batches spans and flushes periodically
+* or when the batch fills. No @opentelemetry SDK dependency — minimal
+* OTLP/JSON serializer (~120 LOC) using the existing otel.ts helpers.
+*/
+/**
+* Create an OTEL exporter. Returns undefined when no endpoint is configured
+* (neither via config nor env) — callers should check before attaching.
+*/
+function createOtelExporter(config) {
+	const resolvedEndpoint = config?.endpoint ?? (typeof process !== "undefined" ? process.env.OTEL_EXPORTER_OTLP_ENDPOINT : void 0);
+	if (!resolvedEndpoint) return void 0;
+	const endpoint = resolvedEndpoint;
+	const headers = config?.headers ?? parseHeadersFromEnv();
+	const batchSize = config?.batchSize ?? 64;
+	const flushIntervalMs = config?.flushIntervalMs ?? 5e3;
+	const serviceName = config?.serviceName ?? "agent-eval";
+	const resourceAttrs = config?.resourceAttributes ?? {};
+	const pending = [];
+	let timer;
+	let stopped = false;
+	const exporter = {
+		exportSpan(span) {
+			if (stopped) return;
+			pending.push(toOtlpSpan(span));
+			if (pending.length >= batchSize) doFlush();
+		},
+		async flush() {
+			await doFlush();
+		},
+		async shutdown() {
+			stopped = true;
+			if (timer !== void 0) {
+				clearInterval(timer);
+				timer = void 0;
+			}
+			await doFlush();
+		}
+	};
+	timer = setInterval(() => {
+		if (pending.length > 0) doFlush();
+	}, flushIntervalMs);
+	if (typeof timer === "object" && "unref" in timer) timer.unref();
+	async function doFlush() {
+		if (pending.length === 0) return;
+		const batch = pending.splice(0);
+		const body = { resourceSpans: [{
+			resource: { attributes: toAttributes({
+				"service.name": serviceName,
+				...resourceAttrs
+			}) },
+			scopeSpans: [{
+				scope: OTEL_AGENT_EVAL_SCOPE,
+				spans: batch
+			}]
+		}] };
+		const url = `${endpoint.replace(/\/+$/, "")}/v1/traces`;
+		try {
+			await fetch(url, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					...headers
+				},
+				body: JSON.stringify(body)
+			});
+		} catch {}
+	}
+	return exporter;
+}
+function parseHeadersFromEnv() {
+	if (typeof process === "undefined") return {};
+	const raw = process.env.OTEL_EXPORTER_OTLP_HEADERS;
+	if (!raw) return {};
+	const out = {};
+	for (const pair of raw.split(",")) {
+		const eq = pair.indexOf("=");
+		if (eq < 0) continue;
+		const key = pair.slice(0, eq).trim();
+		const value = pair.slice(eq + 1).trim();
+		if (key) out[key] = value;
+	}
+	return out;
+}
+function toOtlpSpan(span) {
+	const endedAt = span.endedAt ?? span.startedAt;
+	const attrs = {};
+	if (span.attributes) {
+		for (const [k, v] of Object.entries(span.attributes)) if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") attrs[k] = v;
+	}
+	attrs[OPENINFERENCE_SPAN_KIND] = traceSpanKindToOpenInferenceKind(span.kind);
+	applyLlmSpanOtlpAttributes(attrs, span);
+	if (span.tool) applyToolSpanOtlpAttributes(attrs, span.tool);
+	return {
+		traceId: traceIdForWire(span.traceId),
+		spanId: spanIdForWire(span.spanId),
+		parentSpanId: span.parentSpanId ? spanIdForWire(span.parentSpanId) : void 0,
+		name: span.name,
+		kind: 1,
+		startTimeUnixNano: msToNs(span.startedAt),
+		endTimeUnixNano: msToNs(endedAt),
+		attributes: toAttributes(attrs),
+		status: span.status === "error" ? {
+			code: 2,
+			message: span.error
+		} : { code: 1 }
+	};
+}
+function toAttributes(record) {
+	return Object.entries(record).map(([key, value]) => ({
+		key,
+		value: typeof value === "number" ? Number.isInteger(value) ? { intValue: value.toString() } : { doubleValue: value } : typeof value === "boolean" ? { boolValue: value } : { stringValue: value }
+	}));
+}
+function msToNs(ms) {
+	return (BigInt(Math.floor(ms)) * 1000000n).toString();
+}
+//#endregion
+//#region src/trace/store-to-otlp.ts
+/**
+* Convert agent-eval's internal trace shape (`FileSystemTraceStore` → `Run`,
+* `Span`, `TraceEvent`) into the OTLP-flat JSONL the trace analyst
+* (`analyzeTraces` + `OtlpFileTraceStore`) reads.
+*
+* Eval harnesses shard a `FileSystemTraceStore` per cell (persona / variant)
+* under a run directory. The analyst consumes a single OTLP-NDJSON file keyed
+* on `trace_id` + `span_id` with `start_time`/`end_time` in ISO-8601 and
+* resource + `attributes` rolled up per-span. This module walks every shard,
+* projects each `Span` (plus events pinned to it) into the flat OTLP shape,
+* and emits one NDJSON file.
+*
+* Generic OTLP/OpenInference fields are always emitted (`service.name`,
+* `agent.name`, `run.id`/`run.status`, `openinference.span.kind`,
+* `llm.model_name`, …). Domain attributes (`legal.*`, `tax.*`, …) are injected
+* per-run via {@link TraceStoreToOtlpOptions.resourceAttributes} /
+* {@link TraceStoreToOtlpOptions.runAttributes} so consumers don't re-roll the
+* walker.
+*/
+/**
+* Read every per-cell shard under each source root and write a flat OTLP-JSONL
+* view of the corpus to `outPath`. Each cell directory is a
+* `FileSystemTraceStore` — NDJSON append-only with size-based rotation;
+* `updateRun`/`updateSpan` append `{ id, ...patch, _update: true }` rows
+* rather than rewriting, so readers must merge those patches in (done here).
+*
+* A `string` source is treated as a celled root.
+*/
+function convertTraceStoresToOtlp(source, outPath, opts = {}) {
+	const sources = Array.isArray(source) ? [...source] : typeof source === "string" ? [{
+		root: source,
+		layout: "celled"
+	}] : [source];
+	const defaultServiceName = opts.serviceName ?? "agent-eval";
+	const resourceAttributes = opts.resourceAttributes ?? (() => ({}));
+	const runAttributes = opts.runAttributes ?? (() => ({}));
+	const lines = [];
+	let spanCount = 0;
+	let runCount = 0;
+	let cellCount = 0;
+	let cellErrorCount = 0;
+	for (const src of sources) {
+		const serviceName = src.serviceName ?? defaultServiceName;
+		const cellDirs = src.layout === "flat" ? [{
+			label: "<root>",
+			dir: src.root
+		}] : listCells(src.root).map((name) => ({
+			label: name,
+			dir: join(src.root, name)
+		}));
+		for (const cell of cellDirs) try {
+			const result = projectCell({
+				cellDir: cell.dir,
+				serviceName,
+				resourceAttributes,
+				runAttributes
+			});
+			for (const line of result.lines) lines.push(line);
+			spanCount += result.spanCount;
+			runCount += result.runCount;
+			cellCount += 1;
+		} catch (err) {
+			console.warn(`[traces-to-otlp] cell ${cell.label} (${cell.dir}) skipped: ${err instanceof Error ? err.message : String(err)}`);
+			cellErrorCount += 1;
+		}
+	}
+	writeFileSync(outPath, lines.join("\n") + (lines.length > 0 ? "\n" : ""));
+	return {
+		spanCount,
+		runCount,
+		cellCount,
+		cellErrorCount
+	};
+}
+function projectCell(args) {
+	const { cellDir, serviceName, resourceAttributes, runAttributes } = args;
+	const lines = [];
+	let runCount = 0;
+	let spanCount = 0;
+	const runs = readMergedShards(cellDir, "runs", "runId");
+	const spans = readMergedShards(cellDir, "spans", "spanId");
+	const events = readShards(cellDir, "events");
+	const runByRunId = /* @__PURE__ */ new Map();
+	for (const r of runs) runByRunId.set(r.runId, r);
+	const spanBySpanId = /* @__PURE__ */ new Map();
+	for (const s of spans) spanBySpanId.set(s.spanId, s);
+	const eventsBySpanId = /* @__PURE__ */ new Map();
+	for (const e of events) {
+		if (e.kind === "state_mutation" && e.payload && typeof e.payload === "object") {
+			const entity = e.payload.entity;
+			if (entity === "run") {
+				const run = e.payload.run;
+				if (run?.runId) runByRunId.set(run.runId, run);
+				continue;
+			}
+			if (entity === "run.update") {
+				const patch = e.payload.patch;
+				if (patch && e.runId) {
+					const prior = runByRunId.get(e.runId);
+					if (prior) runByRunId.set(e.runId, {
+						...prior,
+						...patch
+					});
+				}
+				continue;
+			}
+			if (entity === "span") {
+				const span = e.payload.span;
+				if (span?.spanId) spanBySpanId.set(span.spanId, span);
+				continue;
+			}
+			if (entity === "span.update") {
+				const spanId = e.payload.spanId;
+				const patch = e.payload.patch;
+				if (spanId && patch) {
+					const prior = spanBySpanId.get(spanId);
+					if (prior) spanBySpanId.set(spanId, {
+						...prior,
+						...patch
+					});
+				}
+				continue;
+			}
+		}
+		if (!e.spanId) continue;
+		const arr = eventsBySpanId.get(e.spanId) ?? [];
+		arr.push(e);
+		eventsBySpanId.set(e.spanId, arr);
+	}
+	for (const run of runByRunId.values()) {
+		const traceId = traceIdForWire(run.runId);
+		const agentName = run.variantId ?? run.scenarioId;
+		const sharedResource = { attributes: {
+			"service.name": serviceName,
+			"agent.name": agentName,
+			"run.id": run.runId,
+			"run.status": run.status,
+			...resourceAttributes(run)
+		} };
+		const runSpanId = spanIdForWire(`run-${run.runId}`);
+		const runStart = msToIso(run.startedAt);
+		const runEnd = msToIso(run.endedAt ?? run.startedAt);
+		const runStatus = run.outcome?.failureClass && run.outcome.failureClass !== "success" ? "STATUS_CODE_ERROR" : "STATUS_CODE_OK";
+		const runAttrs = {
+			[OPENINFERENCE_SPAN_KIND]: "AGENT",
+			"agent.name": agentName,
+			"agent.workflow.name": serviceName,
+			...runAttributes(run)
+		};
+		lines.push(JSON.stringify(toLine({
+			traceId,
+			spanId: runSpanId,
+			parentSpanId: "",
+			name: `run.${agentName}`,
+			kind: "SPAN_KIND_INTERNAL",
+			startTime: runStart,
+			endTime: runEnd,
+			statusCode: runStatus,
+			statusMessage: run.outcome?.notes ?? "",
+			resource: sharedResource,
+			attributes: runAttrs
+		})));
+		runCount += 1;
+		for (const span of spanBySpanId.values()) {
+			if (span.runId !== run.runId) continue;
+			const spanAttrs = spanToAttributes(span, eventsBySpanId.get(span.spanId) ?? []);
+			const statusCode = spanStatusToOtlp(span.status, span.error, "STATUS_CODE_OK");
+			lines.push(JSON.stringify(toLine({
+				traceId,
+				spanId: spanIdForWire(span.spanId),
+				parentSpanId: span.parentSpanId ? spanIdForWire(span.parentSpanId) : runSpanId,
+				name: span.name,
+				kind: spanKindToOtlpKind(span.kind),
+				startTime: msToIso(span.startedAt),
+				endTime: msToIso(span.endedAt ?? span.startedAt),
+				statusCode,
+				statusMessage: span.error ?? "",
+				resource: sharedResource,
+				attributes: spanAttrs
+			})));
+			spanCount += 1;
+		}
+	}
+	return {
+		lines,
+		runCount,
+		spanCount
+	};
+}
+function listCells(root) {
+	try {
+		return readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+	} catch {
+		return [];
+	}
+}
+/**
+* Read every NDJSON shard for `name` under `cellDir`, ordered by mtime so
+* rotated files apply before the active one. Yields raw rows including any
+* `_update: true` patches.
+*/
+function readShards(cellDir, name) {
+	let entries;
+	try {
+		entries = readdirSync(cellDir);
+	} catch {
+		return [];
+	}
+	const shards = entries.filter((f) => (f === `${name}.ndjson` || f.startsWith(`${name}.`)) && f.endsWith(".ndjson")).map((f) => ({
+		file: f,
+		path: join(cellDir, f)
+	})).map((s) => {
+		let mtime = 0;
+		try {
+			mtime = statSync(s.path).mtimeMs;
+		} catch {}
+		return {
+			...s,
+			mtime
+		};
+	}).sort((a, b) => a.mtime - b.mtime || a.file.localeCompare(b.file));
+	const rows = [];
+	for (const shard of shards) {
+		let text;
+		try {
+			text = readFileSync(shard.path, "utf-8");
+		} catch {
+			continue;
+		}
+		for (const line of text.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			try {
+				rows.push(JSON.parse(trimmed));
+			} catch {}
+		}
+	}
+	return rows;
+}
+/**
+* Read NDJSON shards and merge `{ ...patch, _update: true }` rows into the
+* prior record keyed on `idKey` — mirrors the in-memory merge
+* `FileSystemTraceStore` keeps but doesn't replay on cross-process load.
+*/
+function readMergedShards(cellDir, name, idKey) {
+	const rows = readShards(cellDir, name);
+	const byId = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const id = row[idKey];
+		if (!id) continue;
+		const prior = byId.get(id);
+		if (prior && row._update) byId.set(id, {
+			...prior,
+			...row,
+			_update: void 0
+		});
+		else byId.set(id, row);
+	}
+	return [...byId.values()];
+}
+function spanToAttributes(span, events) {
+	const attrs = { [OPENINFERENCE_SPAN_KIND]: traceSpanKindToOpenInferenceKind(span.kind) };
+	if (span.kind === "llm") {
+		applyLlmSpanOtlpAttributes(attrs, span);
+		if (Array.isArray(span.messages)) attrs["llm.input_messages"] = JSON.stringify(span.messages.slice(-6));
+		if (typeof span.output === "string") attrs["llm.output_messages"] = JSON.stringify([{
+			role: "assistant",
+			content: span.output
+		}]);
+	} else if (span.kind === "tool") applyToolSpanOtlpAttributes(attrs, span);
+	else if (span.kind === "judge") {
+		attrs["judge.id"] = span.judgeId;
+		attrs["judge.dimension"] = span.dimension;
+		attrs["judge.score"] = span.score;
+		attrs["judge.target_span_id"] = span.targetSpanId;
+	}
+	if (span.attributes) for (const [k, v] of Object.entries(span.attributes)) attrs[`agent_eval.${k}`] = v;
+	if (events.length > 0) {
+		attrs["agent_eval.event_count"] = events.length;
+		attrs["agent_eval.event_kinds"] = JSON.stringify(events.map((e) => e.kind));
+	}
+	return attrs;
+}
+function spanKindToOtlpKind(kind) {
+	switch (kind) {
+		case "llm": return "SPAN_KIND_CLIENT";
+		case "retrieval": return "SPAN_KIND_CLIENT";
+		default: return "SPAN_KIND_INTERNAL";
+	}
+}
+const toLine = createOtlpFlatLine;
+function msToIso(ms) {
+	if (ms <= 0) return (/* @__PURE__ */ new Date(0)).toISOString();
+	return epochMillisToIso(ms) ?? (/* @__PURE__ */ new Date(0)).toISOString();
+}
+//#endregion
+//#region src/trace-analyst/hook.ts
+const DEFAULT_QUESTION = "Summarise what happened in this run. Surface any failure modes, surprising findings, or evidence that the run's verdict is wrong.";
+function traceAnalystOnRunComplete(opts) {
+	return async (ctx) => {
+		if (opts.shouldRun && !opts.shouldRun(ctx)) return;
+		const source = opts.analyze.source;
+		if (source === void 0) {
+			await ctx.store.appendEvent({
+				eventId: `analyst-skip-${ctx.runId}`,
+				runId: ctx.runId,
+				kind: "log",
+				timestamp: Date.now(),
+				payload: {
+					source: "trace_analyst_hook",
+					reason: "no source configured"
+				}
+			});
+			return;
+		}
+		const result = await analyzeTraces({ question: opts.question ?? DEFAULT_QUESTION }, {
+			...opts.analyze,
+			source
+		});
+		if (opts.save) await opts.save(result, ctx);
+		if (opts.gateOn && !opts.gateOn(result, ctx)) await ctx.store.appendEvent({
+			eventId: `analyst-gate-${ctx.runId}`,
+			runId: ctx.runId,
+			kind: "log",
+			timestamp: Date.now(),
+			payload: {
+				source: "trace_analyst_hook",
+				reason: "analyst_gate_failed",
+				findings: result.findings
+			}
+		});
+	};
+}
+//#endregion
+//#region src/trace-analyst/otlp-flatten.ts
+const DEFAULT_KIND_MAP = {
+	0: "SPAN_KIND_UNSPECIFIED",
+	1: "SPAN_KIND_INTERNAL",
+	2: "SPAN_KIND_SERVER",
+	3: "SPAN_KIND_CLIENT",
+	4: "SPAN_KIND_PRODUCER",
+	5: "SPAN_KIND_CONSUMER"
+};
+const STATUS_MAP = {
+	0: "STATUS_CODE_UNSET",
+	1: "STATUS_CODE_OK",
+	2: "STATUS_CODE_ERROR"
+};
+/** Unwrap an OTLP attribute-value union to a scalar. */
+function attrValue(v) {
+	if (v.stringValue !== void 0) return v.stringValue;
+	if (v.intValue !== void 0) return Number(v.intValue);
+	if (v.doubleValue !== void 0) return v.doubleValue;
+	if (v.boolValue !== void 0) return v.boolValue;
+	return "";
+}
+function attrsToRecord(attrs) {
+	const out = {};
+	for (const a of attrs) out[a.key] = attrValue(a.value);
+	return out;
+}
+function nanoToIso(nano) {
+	const ms = Number(nano) / 1e6;
+	return Number.isFinite(ms) ? new Date(ms).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
+}
+/** Mirror selected attributes into the OpenInference vocabulary in place. */
+function applyOpenInference(attrs) {
+	if ("llm.model" in attrs && !("llm.model_name" in attrs)) attrs[LLM_MODEL_NAME] = attrs["llm.model"];
+	if ("llm.input_tokens" in attrs && !("llm.token_count.prompt" in attrs)) attrs[LLM_INPUT_TOKENS] = attrs["llm.input_tokens"];
+	if ("inference.llm.input_tokens" in attrs && !("llm.token_count.prompt" in attrs)) attrs[LLM_INPUT_TOKENS] = attrs["inference.llm.input_tokens"];
+	if ("llm.output_tokens" in attrs && !("llm.token_count.completion" in attrs)) attrs[LLM_OUTPUT_TOKENS] = attrs["llm.output_tokens"];
+	if ("inference.llm.output_tokens" in attrs && !("llm.token_count.completion" in attrs)) attrs[LLM_OUTPUT_TOKENS] = attrs["inference.llm.output_tokens"];
+	if ("tool.name" in attrs && !("inference.tool.name" in attrs)) attrs["inference.tool.name"] = attrs[TOOL_NAME];
+	if ("span.kind" in attrs && !("openinference.span.kind" in attrs)) attrs[OPENINFERENCE_SPAN_KIND] = String(attrs["span.kind"]).toUpperCase();
+}
+function flattenOtlpExportToNdjson(otlpExport, opts = {}) {
+	const vocab = opts.attributeVocabulary ?? "openinference";
+	const kindMap = {
+		...DEFAULT_KIND_MAP,
+		...opts.kindMap
+	};
+	const lines = [];
+	for (const rs of otlpExport.resourceSpans ?? []) {
+		const resource = { attributes: attrsToRecord(rs.resource?.attributes ?? []) };
+		for (const scope of rs.scopeSpans ?? []) for (const span of scope.spans ?? []) {
+			const attributes = attrsToRecord(span.attributes ?? []);
+			if (vocab === "openinference") applyOpenInference(attributes);
+			const line = createOtlpFlatLine({
+				traceId: span.traceId,
+				spanId: span.spanId,
+				parentSpanId: span.parentSpanId ?? null,
+				name: span.name,
+				kind: kindMap[span.kind] ?? "SPAN_KIND_UNSPECIFIED",
+				startTime: nanoToIso(span.startTimeUnixNano),
+				endTime: nanoToIso(span.endTimeUnixNano),
+				statusCode: STATUS_MAP[span.status?.code ?? 0] ?? "STATUS_CODE_UNSET",
+				statusMessage: span.status?.message,
+				resource,
+				attributes,
+				events: span.events?.map((e) => ({
+					name: e.name,
+					timeUnixNano: e.timeUnixNano,
+					...e.attributes ? { attributes: attrsToRecord(e.attributes) } : {}
+				}))
+			});
+			lines.push(line);
+		}
+	}
+	return lines;
+}
+//#endregion
+//#region src/trace-analyst/otlp-to-run-records.ts
+/**
+* `otlpToRunRecords` — fold an OTLP traces.jsonl (one OTLP span per line;
+* the form AppWorld / HALO emit via their OpenInference OTLP exporter, the
+* same shape `flattenOtlpExportToNdjson` produces) into validated
+* `RunRecord[]` — one record per `trace_id` by default, or per caller-defined
+* logical run when one task is fragmented across multiple OTLP traces.
+*
+* This is the offline ingestion primitive the AppWorld proposer bench and the
+* hosted Intelligence product both stand on: traces in, paper-grade rows
+* out, ready for `compareOptimizationMethods` / `analyzeRuns` / the promotion gate.
+*
+* Aggregation per trace:
+*   - tokenUsage: reconcile input, output, cache-read, and cache-write across
+*     nested model-call wrappers without double-counting parent aggregates.
+*   - costUsd: reconcile complete observed model-call cost when present; else priced via
+*     `opts.priceUsdPerToken` from the aggregated tokens; else `null` with a
+*     loud `raw.cost_unpriced = 1` marker.
+*   - task failure class and detail: read from process-root
+*     `tangle.task.failure_*` attributes; malformed or conflicting values throw.
+*   - terminalFailureReason: the failed root's normalized status message,
+*     when one unambiguous root supplies terminal failure evidence.
+*   - terminalOutcome: reduced from root-span status only. Child tool errors
+*     remain visible in `error_span_count` and `execution_error_count` without
+*     changing the run outcome. Root, guardrail, evaluator, propagated, and
+*     unknown errors retain separate counters.
+*   - model: the dominant LLM model in the trace (snapshot-padded to satisfy
+*     `validateRunRecord` when the trace's model is a bare alias).
+*   - outcome score: `opts.scoreForTrace` (AppWorld `world.evaluate()` →
+*     TGC/SGC) when supplied. Traces without an external task-quality signal
+*     remain unlabeled; execution errors never become a task score.
+*   - prompt / completion: carried into `raw` as token-count signals and,
+*     when the first/last LLM span exposes `input.value` / `output.value`,
+*     the verbatim text is preserved on the optional `promptText` /
+*     `completionText` of the returned `OtlpTraceRunRecord`.
+*
+* Fail-loud: an OTLP file with zero valid spans throws. A trace with no
+* spans is impossible (a trace exists only because a span referenced it).
+* `validateRunRecord` runs on every row — a malformed projection throws
+* rather than silently producing a half-record.
+*/
+/**
+* Parse + aggregate an OTLP traces.jsonl string into validated
+* `RunRecord[]` (one per trace). Use {@link otlpToTraceRunRecords} when you
+* also want the verbatim prompt/completion text alongside each record.
+*/
+function otlpToRunRecords(otlpJsonl, opts) {
+	return otlpToTraceRunRecords(otlpJsonl, opts).map((r) => r.record);
+}
+/**
+* Aggregate already-parsed OTLP flat rows without serializing them back to
+* JSONL. This is the in-memory counterpart to {@link otlpToRunRecords}; both
+* paths share projection, reconciliation, validation, and ordering.
+*/
+function otlpRowsToRunRecords(rows, opts) {
+	return otlpRowsToTraceRunRecords(rows, opts).map((row) => row.record);
+}
+/** As {@link otlpToRunRecords} but returns the prompt/completion text too. */
+function otlpToTraceRunRecords(otlpJsonl, opts) {
+	return traceRunRecordsFromSpans(groupSpansByLogicalRun(groupJsonlSpansByTrace(otlpJsonl), opts.logicalRunIdForTrace), opts);
+}
+/** Parsed-row counterpart to {@link otlpToTraceRunRecords}. */
+function otlpRowsToTraceRunRecords(rows, opts) {
+	return traceRunRecordsFromSpans(groupSpansByLogicalRun(groupRowsByTrace(rows), opts.logicalRunIdForTrace), opts);
+}
+function traceRunRecordsFromSpans(byTrace, opts) {
+	const splitTag = opts.splitTag ?? "holdout";
+	const commitSha = opts.commitSha ?? "unknown";
+	const promptHash = opts.promptHash ?? "unknown";
+	const configHash = opts.configHash ?? "unknown";
+	const seed = opts.seed ?? 0;
+	const fallbackModel = opts.fallbackModel ?? "unknown@otlp";
+	if (byTrace.size === 0) throw new Error("otlpToRunRecords: OTLP input produced zero valid spans — every row was empty, malformed, or missing trace_id/span_id");
+	const traceIds = [...byTrace.keys()].sort();
+	const out = [];
+	for (const traceId of traceIds) {
+		const spans = byTrace.get(traceId);
+		const agg = aggregateTrace(traceId, spans, fallbackModel);
+		const score = resolveScore(opts, traceId, agg);
+		const { costUsd, costProvenance } = resolveCost(opts, agg);
+		const raw = {
+			source_trace_count: agg.sourceTraceCount,
+			span_count: agg.spanCount,
+			llm_span_count: agg.llmSpanCount,
+			tool_span_count: agg.toolSpanCount,
+			agent_span_count: agg.agentSpanCount,
+			error_span_count: agg.errorSpanCount,
+			execution_error_count: agg.executionErrorCount,
+			process_error_count: agg.processErrorCount,
+			guardrail_error_count: agg.guardrailErrorCount,
+			judge_error_count: agg.judgeErrorCount,
+			propagated_error_count: agg.propagatedErrorCount,
+			unclassified_error_count: agg.unclassifiedErrorCount,
+			prompt_tokens: agg.tokenUsage.input,
+			completion_tokens: agg.tokenUsage.output
+		};
+		if (agg.tokenUsage.reasoning !== void 0) raw.reasoning_tokens = agg.tokenUsage.reasoning;
+		if (agg.tokenUsage.cached !== void 0) raw.cached_tokens = agg.tokenUsage.cached;
+		if (agg.tokenUsage.cacheWrite !== void 0) raw.cache_write_tokens = agg.tokenUsage.cacheWrite;
+		if (agg.costMeasurement.value !== void 0 && !agg.costMeasurement.complete) raw.partial_observed_cost_usd = agg.costMeasurement.value;
+		recordAggregateMeasurements(raw, agg.aggregateMeasurement);
+		if (costProvenance.kind === "uncaptured") raw.cost_unpriced = 1;
+		const outcome = { raw };
+		if (score !== void 0) if (splitTag === "holdout") outcome.holdoutScore = score;
+		else outcome.searchScore = score;
+		const { promptText, completionText } = extractPromptCompletion(spans, agg.callSpanIds);
+		const judgeMetadata = opts.judgeMetadataForTrace?.(traceId);
+		const taskFailure = readTaskFailureLabels(spans.filter((span) => span.parent_span_id === null && isTerminalRootCandidate(span)), `otlpToRunRecords: run '${traceId}'`);
+		const record = validateRunRecord({
+			runId: `otlp:${opts.experimentId}:${opts.candidateId}:${traceId}`,
+			experimentId: opts.experimentId,
+			candidateId: opts.candidateId,
+			seed,
+			model: ensureSnapshot(agg.model, fallbackModel),
+			promptHash,
+			configHash,
+			commitSha,
+			wallMs: agg.wallMs,
+			costUsd,
+			costProvenance,
+			tokenUsage: agg.tokenUsage,
+			terminalOutcome: agg.terminalOutcome,
+			...agg.terminalFailureMessage ? { terminalFailureReason: agg.terminalFailureMessage } : {},
+			...judgeMetadata ? { judgeMetadata } : {},
+			outcome,
+			...taskFailure,
+			splitTag,
+			scenarioId: traceId
+		});
+		out.push({
+			record,
+			...promptText !== void 0 ? { promptText } : {},
+			...completionText !== void 0 ? { completionText } : {}
+		});
+	}
+	return out;
+}
+function* yieldJsonlRows(otlpJsonl) {
+	for (const line of otlpJsonl.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			continue;
+		}
+		if (parsed && typeof parsed === "object") yield parsed;
+	}
+}
+function groupJsonlSpansByTrace(otlpJsonl) {
+	return groupRowsByTrace(yieldJsonlRows(otlpJsonl));
+}
+function groupRowsByTrace(rows) {
+	const byTrace = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (!row || typeof row !== "object") continue;
+		const span = projectOtlpFlatLine(row);
+		if (!span) continue;
+		const arr = byTrace.get(span.trace_id);
+		if (arr) arr.push(span);
+		else byTrace.set(span.trace_id, [span]);
+	}
+	return byTrace;
+}
+function groupSpansByLogicalRun(byTrace, logicalRunIdForTrace) {
+	if (!logicalRunIdForTrace) return byTrace;
+	const byRun = /* @__PURE__ */ new Map();
+	for (const [traceId, spans] of byTrace) {
+		const suppliedRunId = logicalRunIdForTrace(traceId);
+		if (typeof suppliedRunId !== "string" || suppliedRunId.trim().length === 0) throw new Error(`otlpToRunRecords: logicalRunIdForTrace('${traceId}') returned an empty run id`);
+		const runId = suppliedRunId.trim();
+		const target = byRun.get(runId) ?? [];
+		for (const span of spans) target.push({
+			...span,
+			span_id: qualifySpanId(traceId, span.span_id),
+			parent_span_id: span.parent_span_id ? qualifySpanId(traceId, span.parent_span_id) : null
+		});
+		byRun.set(runId, target);
+	}
+	return byRun;
+}
+function qualifySpanId(traceId, spanId) {
+	const prefix = `${traceId}:`;
+	return spanId.startsWith(prefix) ? spanId : `${prefix}${spanId}`;
+}
+function aggregateTrace(traceId, spans, fallbackModel) {
+	const ordered = [...spans].sort((a, b) => compareSpanTime(a.start_time, b.start_time) || a.span_id.localeCompare(b.span_id));
+	const measurements = summarizeExecutionMeasurements(ordered.map((span) => ({
+		id: span.span_id,
+		...span.parent_span_id ? { parentId: span.parent_span_id } : {},
+		attributes: span.attributes,
+		modelCall: isOtlpModelCall({
+			kind: span.kind,
+			name: span.name,
+			attributes: span.attributes
+		}),
+		aggregate: span.kind !== "LLM" && span.kind !== "UNKNOWN"
+	})));
+	let toolSpanCount = 0;
+	let agentSpanCount = 0;
+	let firstErrorMessage;
+	const modelVotes = /* @__PURE__ */ new Map();
+	let earliest = ordered[0]?.start_time ?? "";
+	let latest = ordered[0]?.end_time ?? "";
+	for (const s of ordered) {
+		if (s.start_time && (!earliest || compareSpanTime(s.start_time, earliest) < 0)) earliest = s.start_time;
+		if (s.end_time && (!latest || compareSpanTime(s.end_time, latest) > 0)) latest = s.end_time;
+		if (s.kind === "TOOL") toolSpanCount += 1;
+		else if (s.kind === "AGENT") agentSpanCount += 1;
+		if (s.status === "ERROR") {
+			if (firstErrorMessage === void 0) firstErrorMessage = (s.status_message ?? `${s.name} — STATUS_CODE_ERROR`).slice(0, 500);
+		}
+	}
+	const callSpanIds = new Set(measurements.callSpanIds);
+	for (const span of ordered) {
+		if (!callSpanIds.has(span.span_id)) continue;
+		const model = firstStringAttr(span.attributes, LLM_MODEL_ATTR_KEYS) ?? span.model_name;
+		if (model) modelVotes.set(model, (modelVotes.get(model) ?? 0) + 1);
+	}
+	const model = topVote(modelVotes) ?? firstModelAttr(ordered) ?? fallbackModel;
+	let wallMs = 0;
+	const a = spanEpochMillis(earliest);
+	const b = spanEpochMillis(latest);
+	if (a !== null && b !== null) wallMs = Math.max(0, b - a);
+	const sourceTraceIds = [...new Set(spans.map((span) => span.trace_id))].sort();
+	const terminal = terminalEvidenceFromRoots(ordered);
+	const errorSummary = summarizeTraceErrors(ordered.map((span) => ({
+		id: span.span_id,
+		...span.parent_span_id ? { parentId: span.parent_span_id } : {},
+		role: errorRoleForProjectedSpan(span),
+		error: span.status === "ERROR",
+		processRoot: span.parent_span_id === null && isTerminalRootCandidate(span)
+	})));
+	return {
+		traceId,
+		sourceTraceCount: sourceTraceIds.length,
+		sourceTraceIds,
+		spanCount: spans.length,
+		llmSpanCount: measurements.modelCallCount,
+		toolSpanCount,
+		agentSpanCount,
+		errorSpanCount: errorSummary.total,
+		executionErrorCount: errorSummary.execution,
+		processErrorCount: errorSummary.process,
+		guardrailErrorCount: errorSummary.guardrail,
+		judgeErrorCount: errorSummary.evaluation,
+		propagatedErrorCount: errorSummary.propagated,
+		unclassifiedErrorCount: errorSummary.unclassified,
+		tokenUsage: measurements.tokenUsage,
+		firstErrorMessage,
+		model,
+		startTime: earliest,
+		endTime: latest,
+		wallMs,
+		terminalOutcome: terminal.outcome,
+		...terminal.failureMessage ? { terminalFailureMessage: terminal.failureMessage } : {},
+		callSpanIds: measurements.callSpanIds,
+		costMeasurement: measurements.cost,
+		...measurements.aggregate ? { aggregateMeasurement: measurements.aggregate } : {}
+	};
+}
+function terminalEvidenceFromRoots(spans) {
+	const roots = spans.filter((span) => span.parent_span_id === null && isTerminalRootCandidate(span));
+	if (roots.length !== 1) return { outcome: "unknown" };
+	const root = roots[0];
+	if (root.status === "ERROR") return {
+		outcome: "failed",
+		failureMessage: (root.status_message ?? `${root.name} — STATUS_CODE_ERROR`).slice(0, 500)
+	};
+	if (root.status === "OK") return { outcome: "succeeded" };
+	return { outcome: "unknown" };
+}
+function isTerminalRootCandidate(span) {
+	const role = errorRoleForProjectedSpan(span);
+	return role !== "LLM" && role !== "TOOL" && role !== "EVALUATOR" && role !== "GUARDRAIL";
+}
+function errorRoleForProjectedSpan(span) {
+	return classifyOtlpSpanRole({
+		kind: span.kind,
+		name: span.name,
+		attributes: span.attributes
+	});
+}
+function resolveScore(opts, traceId, agg) {
+	const supplied = opts.scoreForTrace?.(traceId, agg);
+	if (supplied !== void 0) {
+		if (!Number.isFinite(supplied)) throw new Error(`otlpToRunRecords: scoreForTrace('${traceId}') returned non-finite ${supplied}`);
+		return supplied;
+	}
+}
+function resolveCost(opts, agg) {
+	const observedCost = agg.costMeasurement;
+	if (observedCost.complete && observedCost.value !== void 0) return {
+		costUsd: observedCost.value,
+		costProvenance: {
+			kind: "observed",
+			usd: observedCost.value
+		}
+	};
+	if (agg.aggregateMeasurement?.costUsd !== void 0) return {
+		costUsd: agg.aggregateMeasurement.costUsd,
+		costProvenance: {
+			kind: "observed",
+			usd: agg.aggregateMeasurement.costUsd
+		}
+	};
+	if (opts.priceUsdPerToken !== void 0) {
+		const costUsd = (agg.tokenUsage.input + agg.tokenUsage.output) * opts.priceUsdPerToken;
+		return {
+			costUsd,
+			costProvenance: {
+				kind: "estimated",
+				usd: costUsd
+			}
+		};
+	}
+	return {
+		costUsd: null,
+		costProvenance: {
+			kind: "uncaptured",
+			usd: null
+		}
+	};
+}
+function extractPromptCompletion(spans, callSpanIds) {
+	const callIds = new Set(callSpanIds);
+	const measuredCalls = spans.filter((span) => callIds.has(span.span_id));
+	const llm = (measuredCalls.length > 0 ? measuredCalls : spans.filter((s) => s.kind === "LLM")).sort((a, b) => compareSpanTime(a.start_time, b.start_time) || a.span_id.localeCompare(b.span_id));
+	if (llm.length === 0) return {};
+	const promptText = firstStringAttr(llm[0].attributes, [
+		"input.value",
+		"llm.input_messages",
+		"gen_ai.prompt"
+	]) ?? void 0;
+	const last = llm[llm.length - 1];
+	const completionText = firstStringAttr(last.attributes, [
+		"output.value",
+		"llm.output_messages",
+		"gen_ai.completion"
+	]) ?? void 0;
+	return {
+		...promptText !== void 0 ? { promptText } : {},
+		...completionText !== void 0 ? { completionText } : {}
+	};
+}
+function topVote(votes) {
+	let best = null;
+	let bestN = 0;
+	for (const [k, n] of votes) if (n > bestN || n === bestN && best !== null && k < best) {
+		best = k;
+		bestN = n;
+	}
+	return best;
+}
+function firstModelAttr(spans) {
+	for (const s of spans) {
+		const m = firstStringAttr(s.attributes, LLM_MODEL_ATTR_KEYS) ?? s.model_name;
+		if (m) return m;
+	}
+	return null;
+}
+/**
+* `validateRunRecord` rejects bare model aliases (`gpt-4o`) that remap
+* silently. AppWorld/HALO traces frequently carry such bare ids (or a null
+* model). When the model already encodes a snapshot we keep it; otherwise we
+* append the fallback snapshot token so the row is admissible without lying
+* about the model — the bare base name is preserved verbatim before `@`.
+*/
+function ensureSnapshot(model, fallbackModel) {
+	if (modelHasSnapshot(model)) return model;
+	return `${model}${fallbackModel.includes("@") ? fallbackModel.slice(fallbackModel.indexOf("@")) : "@otlp"}`;
+}
+//#endregion
+export { DEFAULT_REDACTION_RULES, DEFAULT_TRACE_ANALYST_BUDGETS, FAILURE_CLASSES, FileSystemRawProviderSink, FileSystemTraceStore, INPUT_VALUE, InMemoryRawProviderSink, InMemoryTraceStore, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, NoopRawProviderSink, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, OtlpFileTraceStore, REDACTION_VERSION, RUN_COST_ATTR_KEYS, RunIntegrityError, SPAN_KIND_ATTR_KEYS, SpanNotFoundError, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYSIS_LIMITS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TOOL_NAMESPACE, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, ToolTraceMissingError, TraceAnalysisLimitError, TraceAnalysisStoreContractError, TraceAnalysisValidationError, TraceEmitter, TraceFileMalformedError, TraceFileMissingError, TraceFileTooLargeError, TraceNotFoundError, aggregateLlm, analyzeTraces, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertRunCaptured, buildTraceAnalysisToolDescriptors, buildTraceInsightContext, buildTraceInsightPrompt, captureFetchToRawSink, classifyOtlpSpanRole, contextInputTokens, convertTraceStoresToOtlp, createBoundedTraceAnalysisStore, createOtelExporter, createOtelTracingStore, defaultProviderRedactor, defaultTraceInsightPanel, describeTraceInsightScope, domainEvidencePattern, exportRunAsOtlp, extractOtlpAttributes, extractUsage, extractUsageFromResponse, extractUsageFromSse, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, groupBy, hasCapturedToolArgs, inferDomainKeywords, inferOtlpKind, isJudgeSpan, isLlmSpan, isOtlpModelCall, isRetrievalSpan, isSandboxSpan, isToolSpan, judgeSpans, llmSpanFromProvider, llmSpans, otelRunCompleteHook, otlpRowsToRunRecords, otlpRowsToTraceRunRecords, otlpTextToTraceAnalysisStore, otlpToRunRecords, otlpToTraceRunRecords, planTraceInsightQuestions, projectOtlpFlatLine, providerFromBaseUrl, readOtlpStatus, redactString, redactValue, runFailureClass, runsForScenario, scoreTraceInsightReadiness, stringField, throwIfRunIncomplete, tokenizeDomainWords, toolSpans, toolSpansToTraceAnalysisStore, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceSpanKindToOpenInferenceKind };
+
+//# sourceMappingURL=traces.js.map