@tangle-network/agent-eval 0.129.0 → 0.130.1

package/dist/code-agent-session-BjkMTQ7H.js

@@ -0,0 +1,1390 @@
+import { i as estimateCost, o as isModelPriced } from "./metrics-C9YY1OcL.js";
+import { t as extractUsage } from "./extract-usage-BrQ8mCLX.js";
+import { createHash } from "node:crypto";
+//#region src/contract/intake/code-agent-observation.ts
+/**
+* Project one provider session into the exact user-visible answer and a
+* provider-neutral action stream. Raw prompts, tool inputs, and tool outputs
+* stay out of this projection; callers retain the source JSONL as evidence.
+*/
+function observeCodeAgentSession(options) {
+	const entries = options.entries.filter(isRecord$1);
+	const projection = projectionFor(options.source, entries);
+	const terminal = terminalWithExecution(projection, options.execution);
+	return {
+		source: options.source,
+		sessionId: sessionIdFromEntries$1(options.source, entries) ?? fallbackSessionId$1(options.source, options.sourcePath),
+		finalText: projection.finalText,
+		terminal,
+		actions: projection.actions
+	};
+}
+function projectionFor(source, entries) {
+	switch (source) {
+		case "codex": return codexProjection(entries);
+		case "claude-code": return claudeProjection(entries);
+		case "opencode": return openCodeProjection(entries);
+		case "kimi-code": return kimiProjection(entries);
+		case "pi": return piProjection(entries);
+	}
+}
+function codexProjection(entries) {
+	const actions = [];
+	const calls = /* @__PURE__ */ new Map();
+	let finalText = null;
+	let terminal = "unknown";
+	let explicitTerminal = false;
+	for (const entry of entries) {
+		const entryType = stringField$1(entry, "type");
+		const payload = record$1(entry.payload) ?? {};
+		const payloadType = stringField$1(payload, "type");
+		const timestampMs = timestamp(entry.timestamp);
+		const item = record$1(entry.item);
+		if (entryType === "item.started" && item) {
+			const itemType = stringField$1(item, "type");
+			if (isCodexActionItem(itemType)) {
+				const id = stringField$1(item, "id") ?? `item-${actions.length}`;
+				const action = actionFor({
+					id,
+					stepIndex: actions.length,
+					kind: itemType === "file_change" ? "patch" : "tool",
+					surface: codexItemSurface(itemType, item),
+					name: codexItemName(itemType, item),
+					status: "started",
+					timestampMs,
+					metadata: compactMetadata({
+						sourceEventType: entryType,
+						itemType
+					})
+				});
+				calls.set(id, action);
+				actions.push(action);
+			}
+		}
+		if (entryType === "item.completed" && item) {
+			const itemType = stringField$1(item, "type");
+			if (itemType === "agent_message" || itemType === "message") finalText = nonEmpty(stringField$1(item, "text")) ?? finalText;
+			if (isCodexActionItem(itemType)) {
+				const id = stringField$1(item, "id") ?? `item-${actions.length}`;
+				const status = codexItemStatus(itemType, item);
+				const existing = calls.get(id);
+				if (existing) existing.status = status;
+				else {
+					const action = actionFor({
+						id,
+						stepIndex: actions.length,
+						kind: itemType === "file_change" ? "patch" : "tool",
+						surface: codexItemSurface(itemType, item),
+						name: codexItemName(itemType, item),
+						status,
+						timestampMs,
+						metadata: compactMetadata({
+							sourceEventType: entryType,
+							itemType
+						})
+					});
+					calls.set(id, action);
+					actions.push(action);
+				}
+			}
+		}
+		if (entryType === "response_item") {
+			if (payloadType === "message" || payloadType === "agent_message") finalText = textFromMessagePayload(payload) ?? finalText;
+			if (payloadType === "function_call" || payloadType === "custom_tool_call") {
+				const id = stringField$1(payload, "call_id") ?? stringField$1(payload, "id") ?? `call-${actions.length}`;
+				const name = stringField$1(payload, "name") ?? payloadType;
+				const action = actionFor({
+					id,
+					stepIndex: actions.length,
+					kind: "tool",
+					surface: surfaceForTool(name),
+					name,
+					status: "started",
+					timestampMs,
+					metadata: compactMetadata({
+						sourceEventType: entryType,
+						payloadType
+					})
+				});
+				calls.set(id, action);
+				actions.push(action);
+			}
+			if (payloadType === "function_call_output" || payloadType === "custom_tool_call_output") {
+				const id = stringField$1(payload, "call_id") ?? stringField$1(payload, "id");
+				const existing = id ? calls.get(id) : void 0;
+				if (existing) existing.status = looksLikeError(payload.output) ? "failed" : "completed";
+			}
+		}
+		if (entryType === "event_msg") {
+			if (payloadType === "agent_message") finalText = nonEmpty(stringField$1(payload, "message")) ?? nonEmpty(stringField$1(payload, "text")) ?? finalText;
+			if (payloadType === "patch_apply_end") {
+				const patchStatus = typeof payload.success === "boolean" ? payload.success ? "completed" : "failed" : "unknown";
+				actions.push(actionFor({
+					id: stringField$1(payload, "call_id") ?? `patch-${actions.length}`,
+					stepIndex: actions.length,
+					kind: "patch",
+					surface: "code",
+					name: "patch",
+					status: patchStatus,
+					timestampMs,
+					metadata: compactMetadata({
+						sourceEventType: entryType,
+						payloadType
+					})
+				}));
+			}
+			if (payloadType === "sub_agent_activity") {
+				const name = stringField$1(payload, "kind") ?? "subagent";
+				actions.push(actionFor({
+					id: stringField$1(payload, "event_id") ?? `subagent-${actions.length}`,
+					stepIndex: actions.length,
+					kind: "tool",
+					surface: "subagent",
+					name,
+					status: statusFrom(payload),
+					timestampMs,
+					metadata: compactMetadata({
+						sourceEventType: entryType,
+						payloadType
+					})
+				}));
+			}
+			if (payloadType === "task_complete" || payloadType === "turn_aborted") {
+				const completed = payloadType === "task_complete";
+				terminal = completed ? "completed" : "failed";
+				explicitTerminal = true;
+				actions.push(terminalAction(actions.length, payloadType, completed, timestampMs));
+			}
+		}
+		if (entryType === "turn.completed" || entryType === "exec_done") {
+			const completed = entry.success !== false;
+			terminal = completed ? "completed" : "failed";
+			explicitTerminal = true;
+			finalText = nonEmpty(stringField$1(entry, "message")) ?? finalText;
+			actions.push(terminalAction(actions.length, entryType, completed, timestampMs));
+		}
+		if (entryType === "turn.failed" || entryType === "error") {
+			terminal = "failed";
+			explicitTerminal = true;
+			actions.push(terminalAction(actions.length, entryType, false, timestampMs));
+		}
+	}
+	return {
+		finalText,
+		terminal,
+		explicitTerminal,
+		actions
+	};
+}
+function claudeProjection(entries) {
+	const actions = [];
+	const calls = /* @__PURE__ */ new Map();
+	let finalText = null;
+	let resultText = null;
+	let terminal = "unknown";
+	let explicitTerminal = false;
+	for (const entry of entries) {
+		const entryType = stringField$1(entry, "type");
+		const timestampMs = timestamp(entry.timestamp);
+		const message = record$1(entry.message);
+		const content = Array.isArray(message?.content) ? message.content : [];
+		if (entryType === "assistant") {
+			const text = textBlocks(content);
+			if (text !== null) finalText = text;
+			for (const value of content) {
+				const part = record$1(value);
+				if (!part) continue;
+				const partType = stringField$1(part, "type");
+				if (partType === "tool_use") {
+					const id = stringField$1(part, "id") ?? `tool-${actions.length}`;
+					const name = stringField$1(part, "name") ?? "tool";
+					const action = actionFor({
+						id,
+						stepIndex: actions.length,
+						kind: "tool",
+						surface: surfaceForTool(name),
+						name,
+						status: "started",
+						timestampMs,
+						metadata: compactMetadata({
+							sourceEventType: entryType,
+							partType
+						})
+					});
+					calls.set(id, action);
+					actions.push(action);
+				}
+			}
+			completeClaudeTools(content, calls);
+			const stopReason = stringField$1(message ?? {}, "stop_reason");
+			if (stopReason === "end_turn") {
+				terminal = "completed";
+				explicitTerminal = true;
+				actions.push(terminalAction(actions.length, stopReason, true, timestampMs));
+			}
+		}
+		if (entryType === "user") completeClaudeTools(content, calls);
+		if (entryType === "tool_use") {
+			const id = stringField$1(entry, "id") ?? `tool-${actions.length}`;
+			const name = stringField$1(entry, "name") ?? "tool";
+			const action = actionFor({
+				id,
+				stepIndex: actions.length,
+				kind: "tool",
+				surface: surfaceForTool(name),
+				name,
+				status: "started",
+				timestampMs,
+				metadata: { sourceEventType: entryType }
+			});
+			calls.set(id, action);
+			actions.push(action);
+		}
+		if (entryType === "tool_result") {
+			const id = stringField$1(entry, "tool_use_id");
+			const action = id ? calls.get(id) : void 0;
+			if (action) action.status = entry.is_error === true ? "failed" : "completed";
+		}
+		if (entryType === "system") {
+			const subtype = stringField$1(entry, "subtype");
+			const hookName = stringField$1(entry, "hook_name") ?? stringField$1(entry, "hookName");
+			if (subtype?.toLowerCase().includes("hook") || hookName) actions.push(actionFor({
+				id: stringField$1(entry, "uuid") ?? `hook-${actions.length}`,
+				stepIndex: actions.length,
+				kind: "tool",
+				surface: "hook",
+				name: hookName ?? subtype ?? "hook",
+				status: statusFrom(entry),
+				timestampMs,
+				metadata: compactMetadata({
+					sourceEventType: entryType,
+					subtype
+				})
+			}));
+		}
+		if (entryType === "pr-link") actions.push(terminalAction(actions.length, entryType, true, timestampMs));
+		if (entryType === "result") {
+			resultText = nonEmpty(stringField$1(entry, "result")) ?? resultText;
+			const subtype = stringField$1(entry, "subtype");
+			const completed = entry.is_error !== true && !subtype?.toLowerCase().includes("error");
+			terminal = completed ? "completed" : "failed";
+			explicitTerminal = true;
+			actions.push(terminalAction(actions.length, subtype ?? entryType, completed, timestampMs));
+		}
+		if (entryType === "error") {
+			terminal = "failed";
+			explicitTerminal = true;
+			actions.push(terminalAction(actions.length, entryType, false, timestampMs));
+		}
+	}
+	return {
+		finalText: resultText ?? finalText,
+		terminal,
+		explicitTerminal,
+		actions
+	};
+}
+function openCodeProjection(entries) {
+	const actions = [];
+	const assistantMessageIds = new Set(entries.filter((entry) => stringField$1(entry, "role") === "assistant").map((entry) => stringField$1(entry, "id")).filter((id) => id !== void 0));
+	let finalText = null;
+	let terminal = "unknown";
+	let explicitTerminal = false;
+	for (const entry of entries) {
+		const entryType = stringField$1(entry, "type");
+		const part = record$1(entry.part) ?? entry;
+		const partType = stringField$1(part, "type");
+		const timestampMs = timestamp(entry.timestamp) ?? timestamp(record$1(entry.time)?.created);
+		if (entryType === "text" && record$1(entry.part)) finalText = nonEmpty(stringField$1(part, "text")) ?? finalText;
+		else if (partType === "text" && (assistantMessageIds.size === 0 || assistantMessageIds.has(stringField$1(part, "messageID") ?? ""))) finalText = nonEmpty(stringField$1(part, "text")) ?? finalText;
+		if (entryType === "tool_use" || partType === "tool") {
+			const state = record$1(part.state) ?? {};
+			const name = stringField$1(part, "tool") ?? "tool";
+			actions.push(actionFor({
+				id: stringField$1(part, "callID") ?? stringField$1(part, "id") ?? `tool-${actions.length}`,
+				stepIndex: actions.length,
+				kind: "tool",
+				surface: surfaceForTool(name),
+				name,
+				status: statusFrom(state),
+				timestampMs,
+				metadata: compactMetadata({
+					sourceEventType: entryType,
+					partType
+				})
+			}));
+		}
+		if (partType === "patch") actions.push(actionFor({
+			id: stringField$1(part, "id") ?? `patch-${actions.length}`,
+			stepIndex: actions.length,
+			kind: "patch",
+			surface: "code",
+			name: "patch",
+			status: "completed",
+			timestampMs,
+			metadata: compactMetadata({
+				sourceEventType: entryType,
+				partType
+			})
+		}));
+		if (stringField$1(entry, "role") === "assistant") {
+			const finish = stringField$1(entry, "finish");
+			if (finish === "stop" || finish === "error") {
+				const completed = finish === "stop";
+				terminal = completed ? "completed" : "failed";
+				explicitTerminal = true;
+				actions.push(terminalAction(actions.length, finish, completed, timestampMs));
+			}
+		}
+		if (entryType === "error") {
+			terminal = "failed";
+			explicitTerminal = true;
+			actions.push(terminalAction(actions.length, entryType, false, timestampMs));
+		}
+	}
+	return {
+		finalText,
+		terminal,
+		explicitTerminal,
+		actions
+	};
+}
+function kimiProjection(entries) {
+	const actions = [];
+	const calls = /* @__PURE__ */ new Map();
+	let finalText = null;
+	let terminal = "unknown";
+	let explicitTerminal = false;
+	for (const entry of entries) {
+		const timestampMs = timestamp(entry.timestamp);
+		const message = record$1(entry.message);
+		const messageType = stringField$1(message ?? {}, "type");
+		const payload = record$1(message?.payload) ?? {};
+		if (messageType === "ContentPart" && stringField$1(payload, "type") === "text") finalText = nonEmpty(stringField$1(payload, "text")) ?? nonEmpty(stringField$1(payload, "content")) ?? finalText;
+		if (messageType === "ToolCall") {
+			const fn = record$1(payload.function) ?? {};
+			const id = stringField$1(payload, "id") ?? `tool-${actions.length}`;
+			const name = stringField$1(fn, "name") ?? "tool";
+			const action = actionFor({
+				id,
+				stepIndex: actions.length,
+				kind: "tool",
+				surface: surfaceForTool(name),
+				name,
+				status: "started",
+				timestampMs,
+				metadata: { sourceEventType: messageType }
+			});
+			calls.set(id, action);
+			actions.push(action);
+		}
+		if (messageType === "ToolResult") {
+			const id = stringField$1(payload, "tool_call_id");
+			const action = id ? calls.get(id) : void 0;
+			if (action) action.status = record$1(payload.return_value)?.is_error === true ? "failed" : "completed";
+		}
+		if (messageType === "TurnEnd" || messageType === "StepInterrupted") {
+			const completed = messageType === "TurnEnd";
+			terminal = completed ? "completed" : "failed";
+			explicitTerminal = true;
+			actions.push(terminalAction(actions.length, messageType, completed, timestampMs));
+		}
+	}
+	return {
+		finalText,
+		terminal,
+		explicitTerminal,
+		actions
+	};
+}
+function piProjection(entries) {
+	const actions = [];
+	let terminal = "unknown";
+	let explicitTerminal = false;
+	for (const entry of entries) {
+		const nodes = Array.isArray(entry.nodes) ? entry.nodes : [];
+		for (const value of nodes) {
+			const node = record$1(value);
+			const ir = record$1(node?.ir) ?? node;
+			const kind = stringField$1(ir ?? {}, "kind");
+			if (kind === "ToolInvocation") actions.push(actionFor({
+				id: stringField$1(ir ?? {}, "id") ?? stringField$1(node ?? {}, "id") ?? `tool-${actions.length}`,
+				stepIndex: actions.length,
+				kind: "tool",
+				surface: "tool",
+				name: stringField$1(ir ?? {}, "name") ?? "graph-tool",
+				status: "started",
+				timestampMs: timestamp(ir?.createdAt),
+				metadata: {
+					sourceEventType: "graph-node",
+					graphKind: kind
+				}
+			}));
+			if (kind === "ToolResult") {
+				const prior = [...actions].reverse().find((action) => action.kind === "tool");
+				if (prior) prior.status = "completed";
+			}
+			if (kind === "CompletionDecision") {
+				terminal = "completed";
+				explicitTerminal = true;
+				actions.push(actionFor({
+					id: stringField$1(ir ?? {}, "id") ?? stringField$1(node ?? {}, "id") ?? `completion-${actions.length}`,
+					stepIndex: actions.length,
+					kind: "graph-completion",
+					surface: "tool",
+					name: "complete",
+					status: "completed",
+					timestampMs: timestamp(ir?.createdAt),
+					metadata: {
+						sourceEventType: "graph-node",
+						graphKind: kind
+					}
+				}));
+			}
+		}
+	}
+	return {
+		finalText: null,
+		terminal,
+		explicitTerminal,
+		actions
+	};
+}
+function completeClaudeTools(content, calls) {
+	for (const value of content) {
+		const part = record$1(value);
+		if (!part || stringField$1(part, "type") !== "tool_result") continue;
+		const id = stringField$1(part, "tool_use_id");
+		const action = id ? calls.get(id) : void 0;
+		if (action) action.status = part.is_error === true ? "failed" : "completed";
+	}
+}
+function isCodexActionItem(itemType) {
+	return itemType === "command_execution" || itemType === "mcp_tool_call" || itemType === "collab_tool_call" || itemType === "web_search" || itemType === "file_change";
+}
+function codexItemSurface(itemType, item) {
+	if (itemType === "mcp_tool_call") return "mcp";
+	if (itemType === "collab_tool_call") return "subagent";
+	if (itemType === "web_search") return "web";
+	if (itemType === "file_change") return "code";
+	return surfaceForTool(stringField$1(item, "name") ?? itemType ?? "tool");
+}
+function codexItemName(itemType, item) {
+	if (itemType === "mcp_tool_call") return [stringField$1(item, "server"), stringField$1(item, "tool")].filter(Boolean).join("/") || "mcp";
+	if (itemType === "collab_tool_call") return stringField$1(item, "tool") ?? "subagent";
+	if (itemType === "web_search") return "web_search";
+	if (itemType === "file_change") return "file_change";
+	return stringField$1(item, "name") ?? itemType ?? "tool";
+}
+function codexItemStatus(itemType, item) {
+	const status = statusFrom(item);
+	if (status === "failed") return status;
+	if (itemType === "command_execution") {
+		const exitCode = numberField$1(item, "exit_code");
+		if (exitCode !== void 0) return exitCode === 0 ? "completed" : "failed";
+	}
+	if (itemType === "mcp_tool_call" && record$1(item.error)) return "failed";
+	return status === "unknown" || status === "started" ? "completed" : status;
+}
+function textFromMessagePayload(payload) {
+	const direct = nonEmpty(stringField$1(payload, "text"));
+	if (direct) return direct;
+	const content = payload.content;
+	if (typeof content === "string") return nonEmpty(content);
+	if (Array.isArray(content)) return textBlocks(content);
+	return null;
+}
+function textBlocks(values) {
+	return nonEmpty(values.map((value) => record$1(value)).filter((value) => value !== null).filter((value) => stringField$1(value, "type") === "text").map((value) => stringField$1(value, "text")).filter((value) => value !== void 0).join("\n"));
+}
+function terminalWithExecution(projection, execution) {
+	if (!execution) return {
+		status: projection.terminal,
+		explicit: projection.explicitTerminal
+	};
+	assertExecutionReceipt(execution);
+	return {
+		status: execution.exitCode !== 0 || projection.terminal === "failed" ? "failed" : "completed",
+		explicit: true
+	};
+}
+function assertExecutionReceipt(receipt) {
+	if (!Number.isSafeInteger(receipt.exitCode)) throw new Error("code-agent execution exitCode must be a safe integer");
+	for (const [name, value] of [["startedAtMs", receipt.startedAtMs], ["completedAtMs", receipt.completedAtMs]]) if (value !== void 0 && (!Number.isFinite(value) || value < 0)) throw new Error(`code-agent execution ${name} must be a non-negative finite number`);
+	if (receipt.startedAtMs !== void 0 && receipt.completedAtMs !== void 0 && receipt.completedAtMs < receipt.startedAtMs) throw new Error("code-agent execution completedAtMs precedes startedAtMs");
+}
+function terminalAction(stepIndex, name, completed, timestampMs) {
+	return actionFor({
+		id: `terminal-${stepIndex}`,
+		stepIndex,
+		kind: "terminal",
+		surface: "tool",
+		name,
+		status: completed ? "completed" : "failed",
+		timestampMs,
+		metadata: { sourceEventType: name }
+	});
+}
+function actionFor(input) {
+	return input;
+}
+function surfaceForTool(name) {
+	const normalized = name.toLowerCase();
+	if (normalized.startsWith("mcp__") || normalized.includes("mcp_tool")) return "mcp";
+	if (normalized === "task" || normalized === "agent" || normalized.includes("subagent") || normalized.includes("spawn_agent") || normalized.includes("collab") || normalized.startsWith("multi_agent")) return "subagent";
+	if (normalized === "skill" || normalized.includes("skill")) return "skill";
+	if (normalized.includes("hook")) return "hook";
+	if (normalized.includes("web_search") || normalized.includes("webfetch") || normalized === "web") return "web";
+	if (normalized === "edit" || normalized === "write" || normalized.includes("patch") || normalized.includes("file_change")) return "code";
+	return "tool";
+}
+function statusFrom(value) {
+	const status = (stringField$1(value, "status") ?? "").toLowerCase();
+	if (status === "completed" || status === "success" || status === "succeeded") return "completed";
+	if (status === "error" || status === "failed" || status === "declined") return "failed";
+	if (status === "running" || status === "started" || status === "in_progress") return "started";
+	return "unknown";
+}
+function compactMetadata(input) {
+	return Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== void 0));
+}
+function sessionIdFromEntries$1(source, entries) {
+	for (const entry of entries) {
+		if (source === "codex") {
+			const threadId = stringField$1(entry, "thread_id");
+			if (threadId) return threadId;
+			const payload = record$1(entry.payload);
+			const id = payload ? stringField$1(payload, "id") : void 0;
+			if (id) return id;
+		}
+		const payload = record$1(record$1(entry.message)?.payload);
+		const sessionId = stringField$1(entry, "sessionID") ?? stringField$1(entry, "sessionId") ?? stringField$1(entry, "session_id") ?? stringField$1(payload ?? {}, "session_id");
+		if (sessionId) return sessionId;
+	}
+}
+function fallbackSessionId$1(source, sourcePath) {
+	return `${source}:${sourcePath ?? "unknown-session"}`;
+}
+function looksLikeError(value) {
+	if (isRecord$1(value)) {
+		if (value.success === false || value.is_error === true) return true;
+		const exitCode = numberField$1(value, "exit_code");
+		if (exitCode !== void 0 && exitCode !== 0) return true;
+	}
+	const text = typeof value === "string" ? value : JSON.stringify(value ?? "");
+	return /\b(?:error|failed|failure)\b|exit(?:_| )code["\s:]+[1-9]/i.test(text);
+}
+function nonEmpty(value) {
+	return value !== void 0 && value.length > 0 ? value : null;
+}
+function isRecord$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function record$1(value) {
+	return isRecord$1(value) ? value : null;
+}
+function stringField$1(value, key) {
+	const field = value[key];
+	return typeof field === "string" && field.length > 0 ? field : void 0;
+}
+function numberField$1(value, key) {
+	const field = value[key];
+	return typeof field === "number" && Number.isFinite(field) ? field : void 0;
+}
+function timestamp(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value > 0xe8d4a51000 ? value : value * 1e3;
+	if (typeof value === "string" && value.length > 0) {
+		const parsed = Date.parse(value);
+		return Number.isFinite(parsed) ? parsed : void 0;
+	}
+}
+//#endregion
+//#region src/contract/intake/code-agent-session.ts
+function parseCodeAgentJsonl(jsonl) {
+	const entries = [];
+	let malformedLines = 0;
+	for (const line of jsonl.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			entries.push(JSON.parse(trimmed));
+		} catch {
+			malformedLines += 1;
+		}
+	}
+	return {
+		entries,
+		malformedLines
+	};
+}
+function fromCodexSession(options) {
+	return fromCodeAgentSession("codex", options);
+}
+function fromClaudeCodeSession(options) {
+	return fromCodeAgentSession("claude-code", options);
+}
+function fromOpenCodeSession(options) {
+	return fromCodeAgentSession("opencode", options);
+}
+function fromKimiCodeSession(options) {
+	return fromCodeAgentSession("kimi-code", options);
+}
+function fromPiSession(options) {
+	return fromCodeAgentSession("pi", options);
+}
+const fromPigraphSession = fromPiSession;
+function fromCodeAgentSession(source, options) {
+	const entries = options.entries.filter(isRecord);
+	if (entries.length === 0) return {
+		runs: [],
+		diagnostics: [{
+			source,
+			sessionId: fallbackSessionId(source, options.sourcePath),
+			sourcePath: options.sourcePath,
+			entries: 0,
+			malformedLines: options.malformedLines ?? 0,
+			hasExplicitTerminalSignal: false,
+			hasFinalOutput: false,
+			hasQualityLabel: false,
+			hasTokenUsage: false,
+			hasCost: false,
+			costKind: "uncaptured",
+			warnings: ["no parseable session entries"]
+		}],
+		metrics: [],
+		observations: []
+	};
+	const metrics = metricsFor(source, entries);
+	const sessionId = sessionIdFromEntries(source, entries) ?? fallbackSessionId(source, options.sourcePath);
+	const observation = observeCodeAgentSession({
+		source,
+		entries,
+		sourcePath: options.sourcePath,
+		execution: options.execution
+	});
+	applyObservedSurfaceMetrics(metrics, observation);
+	const model = withSnapshot(options.model ?? modelFromEntries(source, entries) ?? source);
+	const tokenUsage = {
+		input: metrics.inputTokens,
+		output: metrics.outputTokens,
+		...metrics.reasoningTokens > 0 ? { reasoning: metrics.reasoningTokens } : {},
+		...metrics.cachedTokens > 0 ? { cached: metrics.cachedTokens } : {},
+		...metrics.cacheWriteTokens > 0 ? { cacheWrite: metrics.cacheWriteTokens } : {}
+	};
+	const { costUsd, costProvenance } = resolveSessionCost(options.costProvenance, metrics, model);
+	const qualityScore = finiteScore(options.score);
+	const invalidQualityScore = options.score !== void 0 && qualityScore === void 0;
+	const promptHash = options.promptHash ?? hashString(`prompt:${source}:${firstUserText(entries) ?? ""}`);
+	const configHash = options.configHash ?? hashJson({
+		source,
+		model,
+		sourcePath: options.sourcePath,
+		cwd: cwdFromEntries(entries),
+		entryCount: entries.length
+	});
+	const explicitTerminal = observation.terminal.explicit;
+	const warnings = diagnosticsFor(metrics, {
+		model,
+		explicitTerminal,
+		malformedLines: options.malformedLines ?? 0,
+		hasQualityLabel: qualityScore !== void 0,
+		invalidQualityScore,
+		costKind: costProvenance.kind
+	});
+	const terminalOutcome = terminalOutcomeFromSession(observation.terminal);
+	const processExitCode = options.execution?.exitCode;
+	const splitTag = options.splitTag ?? "holdout";
+	return {
+		runs: [{
+			runId: `${source}:${sessionId}`,
+			experimentId: options.experimentId ?? `${source}-local-sessions`,
+			candidateId: options.candidateId ?? model,
+			seed: options.seed ?? stableSeed(sessionId),
+			model,
+			promptHash,
+			configHash,
+			commitSha: options.commitSha ?? "local-session",
+			wallMs: metrics.wallMs,
+			costUsd,
+			costProvenance,
+			tokenUsage,
+			terminalOutcome,
+			...terminalOutcome === "failed" ? { terminalFailureReason: processExitCode !== void 0 && processExitCode !== 0 ? `process exited with code ${processExitCode}` : metrics.turnsAborted > 0 ? "turn aborted" : "session reported terminal failure" } : {},
+			outcome: {
+				...qualityScore === void 0 ? {} : splitTag === "holdout" ? { holdoutScore: qualityScore } : { searchScore: qualityScore },
+				raw: {
+					entries: metrics.entries,
+					user_messages: metrics.userMessages,
+					assistant_messages: metrics.assistantMessages,
+					reasoning_items: metrics.reasoningItems,
+					tool_calls: metrics.toolCalls,
+					tool_outputs: metrics.toolOutputs,
+					tool_errors: metrics.toolErrors,
+					execution_error_count: metrics.toolErrors,
+					process_error_count: terminalOutcome === "failed" ? 1 : 0,
+					unclassified_error_count: metrics.unclassifiedErrors,
+					...processExitCode !== void 0 ? { process_exit_code: processExitCode } : {},
+					patch_attempts: metrics.patchAttempts,
+					patch_successes: metrics.patchSuccesses,
+					patch_failures: metrics.patchFailures,
+					turns_started: metrics.turnsStarted,
+					turns_completed: metrics.turnsCompleted,
+					turns_aborted: metrics.turnsAborted,
+					context_compactions: metrics.contextCompactions,
+					mcp_calls: metrics.mcpCalls,
+					subagent_calls: metrics.subagentCalls,
+					skill_calls: metrics.skillCalls,
+					hook_calls: metrics.hookCalls,
+					web_calls: metrics.webCalls,
+					code_actions: metrics.codeActions,
+					pr_links: metrics.prLinks,
+					file_snapshots: metrics.fileSnapshots,
+					graph_nodes: metrics.graphNodes,
+					graph_edges: metrics.graphEdges,
+					action_candidates: metrics.actionCandidates,
+					verification_reports: metrics.verificationReports,
+					completion_decisions: metrics.completionDecisions,
+					reliability_rows: metrics.reliabilityRows,
+					reliability_lift: metrics.reliabilityLift,
+					input_tokens: metrics.inputTokens,
+					output_tokens: metrics.outputTokens,
+					reasoning_tokens: metrics.reasoningTokens,
+					cached_tokens: metrics.cachedTokens,
+					cache_write_tokens: metrics.cacheWriteTokens,
+					observed_cost_usd: metrics.observedCostUsd,
+					observed_cost_captured: metrics.observedCostCaptured ? 1 : 0,
+					estimated_cost_usd: costProvenance.kind === "estimated" ? costProvenance.usd : 0,
+					process_score: metrics.processScore,
+					explicit_terminal_signal: explicitTerminal ? 1 : 0,
+					quality_label_present: qualityScore !== void 0 ? 1 : 0,
+					cost_observed: costProvenance.kind === "observed" ? 1 : 0,
+					cost_estimated: costProvenance.kind === "estimated" ? 1 : 0,
+					cost_uncaptured: costProvenance.kind === "uncaptured" ? 1 : 0,
+					cost_unknown: costProvenance.kind === "uncaptured" ? 1 : 0
+				}
+			},
+			splitTag,
+			scenarioId: options.scenarioId ?? sessionId
+		}],
+		diagnostics: [{
+			source,
+			sessionId,
+			sourcePath: options.sourcePath,
+			entries: entries.length,
+			malformedLines: options.malformedLines ?? 0,
+			hasExplicitTerminalSignal: explicitTerminal,
+			hasFinalOutput: observation.finalText !== null,
+			hasQualityLabel: qualityScore !== void 0,
+			hasTokenUsage: metrics.inputTokens > 0 || metrics.outputTokens > 0 || metrics.reasoningTokens > 0 || metrics.cachedTokens > 0 || metrics.cacheWriteTokens > 0,
+			hasCost: costProvenance.kind !== "uncaptured",
+			costKind: costProvenance.kind,
+			warnings
+		}],
+		metrics: [metrics],
+		observations: [{
+			...observation,
+			sessionId
+		}]
+	};
+}
+function terminalOutcomeFromSession(terminal) {
+	if (!terminal.explicit) return "unknown";
+	if (terminal.status === "completed") return "succeeded";
+	if (terminal.status === "failed") return "failed";
+	return "unknown";
+}
+function metricsFor(source, entries) {
+	switch (source) {
+		case "codex": return codexMetrics(entries);
+		case "claude-code": return claudeCodeMetrics(entries);
+		case "opencode": return openCodeMetrics(entries);
+		case "kimi-code": return kimiCodeMetrics(entries);
+		case "pi": return piMetrics(entries);
+	}
+}
+function codexMetrics(entries) {
+	const metrics = emptyMetrics(entries.length);
+	const startedToolIds = /* @__PURE__ */ new Set();
+	let startedAt;
+	let completedAt;
+	for (const entry of entries) {
+		const payload = record(entry.payload) ?? {};
+		const entryType = stringField(entry, "type");
+		const payloadType = stringField(payload, "type");
+		const timestamp = timestampMs(entry.timestamp);
+		if (timestamp !== void 0) {
+			startedAt = startedAt === void 0 ? timestamp : Math.min(startedAt, timestamp);
+			completedAt = completedAt === void 0 ? timestamp : Math.max(completedAt, timestamp);
+		}
+		if (entryType === "turn.started") metrics.turnsStarted += 1;
+		if (entryType === "turn.completed") {
+			metrics.turnsCompleted += 1;
+			addCodexExecUsage(metrics, record(entry.usage));
+		}
+		if (entryType === "turn.failed") metrics.turnsAborted += 1;
+		if (entryType === "error") metrics.unclassifiedErrors += 1;
+		const item = record(entry.item);
+		if (item && (entryType === "item.started" || entryType === "item.completed")) addCodexExecItem(metrics, startedToolIds, entryType, item);
+		if (entryType === "response_item") {
+			if (payloadType === "function_call" || payloadType === "custom_tool_call") metrics.toolCalls += 1;
+			if (payloadType === "function_call_output" || payloadType === "custom_tool_call_output") metrics.toolOutputs += 1;
+			if (payloadType === "reasoning") metrics.reasoningItems += 1;
+			if (payloadType === "message" && stringField(payload, "role") === "assistant") metrics.assistantMessages += 1;
+		}
+		if (entryType === "event_msg") {
+			if (payloadType === "user_message") metrics.userMessages += 1;
+			if (payloadType === "agent_message") metrics.assistantMessages += 1;
+			if (payloadType === "task_started") {
+				metrics.turnsStarted += 1;
+				const started = timestampMs(payload.started_at);
+				if (started !== void 0) startedAt = startedAt === void 0 ? started : Math.min(startedAt, started);
+			}
+			if (payloadType === "task_complete") {
+				metrics.turnsCompleted += 1;
+				const completed = timestampMs(payload.completed_at);
+				if (completed !== void 0) completedAt = completedAt === void 0 ? completed : Math.max(completedAt, completed);
+				const duration = numberField(payload, "duration_ms");
+				if (duration !== void 0) metrics.wallMs = Math.max(metrics.wallMs, duration);
+			}
+			if (payloadType === "turn_aborted") {
+				metrics.turnsAborted += 1;
+				const completed = timestampMs(payload.completed_at);
+				if (completed !== void 0) completedAt = completedAt === void 0 ? completed : Math.max(completedAt, completed);
+			}
+			if (payloadType === "context_compacted") metrics.contextCompactions += 1;
+			if (payloadType === "patch_apply_end") {
+				metrics.patchAttempts += 1;
+				if (payload.success === true) metrics.patchSuccesses += 1;
+				else {
+					metrics.patchFailures += 1;
+					metrics.toolErrors += 1;
+				}
+			}
+			if (payloadType === "token_count") setCodexCumulativeUsage(metrics, record(record(payload.info)?.total_token_usage));
+			const result = record(payload.result);
+			if (result && "Err" in result) metrics.unclassifiedErrors += 1;
+		}
+	}
+	if (metrics.wallMs === 0 && startedAt !== void 0 && completedAt !== void 0) metrics.wallMs = Math.max(0, completedAt - startedAt);
+	metrics.processScore = codexProcessScore(metrics);
+	return metrics;
+}
+function addCodexExecItem(metrics, startedToolIds, eventType, item) {
+	const itemType = stringField(item, "type");
+	const itemId = stringField(item, "id");
+	const isTool = itemType === "command_execution" || itemType === "mcp_tool_call" || itemType === "collab_tool_call" || itemType === "web_search";
+	if (eventType === "item.started" && isTool) {
+		metrics.toolCalls += 1;
+		if (itemId) startedToolIds.add(itemId);
+	}
+	if (eventType === "item.completed" && isTool) {
+		if (!itemId || !startedToolIds.has(itemId)) metrics.toolCalls += 1;
+		metrics.toolOutputs += 1;
+	}
+	if (eventType !== "item.completed") return;
+	if (itemType === "agent_message" || itemType === "message") metrics.assistantMessages += 1;
+	if (itemType === "reasoning") metrics.reasoningItems += 1;
+	if (itemType === "file_change") {
+		metrics.patchAttempts += 1;
+		const status = stringField(item, "status");
+		if (status === "completed") metrics.patchSuccesses += 1;
+		if (status === "failed") {
+			metrics.patchFailures += 1;
+			metrics.toolErrors += 1;
+		}
+	}
+	if (itemType === "error") metrics.unclassifiedErrors += 1;
+	else if (codexExecToolFailed(itemType, item)) metrics.toolErrors += 1;
+}
+function codexExecToolFailed(itemType, item) {
+	const status = stringField(item, "status");
+	if (itemType === "command_execution") {
+		const exitCode = numberField(item, "exit_code");
+		return status === "failed" || status === "declined" || exitCode !== void 0 && exitCode !== 0;
+	}
+	if (itemType === "mcp_tool_call") return status === "failed" || record(item.error) !== null;
+	return itemType === "collab_tool_call" && status === "failed";
+}
+function addCodexExecUsage(metrics, usage) {
+	const parsed = readUsage(usage);
+	metrics.inputTokens += parsed.input;
+	metrics.outputTokens += parsed.output;
+	metrics.reasoningTokens += parsed.reasoning;
+	metrics.cachedTokens += parsed.cached;
+	metrics.cacheWriteTokens += parsed.cacheWrite;
+}
+function setCodexCumulativeUsage(metrics, usage) {
+	const parsed = readUsage(usage);
+	metrics.inputTokens = Math.max(metrics.inputTokens, parsed.input);
+	metrics.outputTokens = Math.max(metrics.outputTokens, parsed.output);
+	metrics.reasoningTokens = Math.max(metrics.reasoningTokens, parsed.reasoning);
+	metrics.cachedTokens = Math.max(metrics.cachedTokens, parsed.cached);
+	metrics.cacheWriteTokens = Math.max(metrics.cacheWriteTokens, parsed.cacheWrite);
+}
+function claudeCodeMetrics(entries) {
+	const metrics = emptyMetrics(entries.length);
+	let startedAt;
+	let completedAt;
+	for (const entry of entries) {
+		const type = stringField(entry, "type");
+		const timestamp = timestampMs(entry.timestamp);
+		if (timestamp !== void 0) {
+			startedAt = startedAt === void 0 ? timestamp : Math.min(startedAt, timestamp);
+			completedAt = completedAt === void 0 ? timestamp : Math.max(completedAt, timestamp);
+		}
+		if (type === "user") metrics.userMessages += 1;
+		if (type === "assistant") metrics.assistantMessages += 1;
+		if (type === "pr-link") metrics.prLinks += 1;
+		if (type === "file-history-snapshot") metrics.fileSnapshots += 1;
+		const message = record(entry.message);
+		if (message) addUsage(metrics, record(message.usage));
+		const content = Array.isArray(message?.content) ? message.content : [];
+		for (const item of content) {
+			const part = record(item);
+			if (!part) continue;
+			const partType = stringField(part, "type");
+			if (partType === "thinking") metrics.reasoningItems += 1;
+			if (partType === "tool_use") metrics.toolCalls += 1;
+			if (partType === "tool_result") {
+				metrics.toolOutputs += 1;
+				if (part.is_error === true) metrics.toolErrors += 1;
+			}
+		}
+	}
+	if (startedAt !== void 0 && completedAt !== void 0) metrics.wallMs = Math.max(0, completedAt - startedAt);
+	metrics.processScore = claudeProcessScore(metrics);
+	return metrics;
+}
+function openCodeMetrics(entries) {
+	const metrics = emptyMetrics(entries.length);
+	const messageUsage = emptyTokenTotals();
+	const partUsage = emptyTokenTotals();
+	let messageCost = 0;
+	let partCost = 0;
+	let messageCostCaptured = false;
+	let partCostCaptured = false;
+	let startedAt;
+	let completedAt;
+	for (const entry of entries) {
+		const time = record(entry.time);
+		const created = timestampMs(time?.created);
+		const completed = timestampMs(time?.completed);
+		if (created !== void 0) startedAt = startedAt === void 0 ? created : Math.min(startedAt, created);
+		if (completed !== void 0) completedAt = completedAt === void 0 ? completed : Math.max(completedAt, completed);
+		const role = stringField(entry, "role");
+		if (role === "user") metrics.userMessages += 1;
+		if (role === "assistant") {
+			metrics.assistantMessages += 1;
+			const finish = stringField(entry, "finish");
+			if (finish === "stop") metrics.turnsCompleted += 1;
+			if (finish === "error") metrics.turnsAborted += 1;
+		}
+		const type = stringField(entry, "type");
+		if (type === "reasoning") metrics.reasoningItems += 1;
+		if (type === "tool") {
+			metrics.toolCalls += 1;
+			const status = stringField(record(entry.state) ?? {}, "status");
+			if (status === "completed") metrics.toolOutputs += 1;
+			if (status === "error") {
+				metrics.toolOutputs += 1;
+				metrics.toolErrors += 1;
+			}
+		}
+		if (type === "patch") {
+			metrics.patchAttempts += 1;
+			metrics.patchSuccesses += 1;
+		}
+		const cost = numberField(entry, "cost");
+		if (record(entry.tokens) && role) {
+			addUsageTo(messageUsage, record(entry.tokens));
+			if (cost !== void 0) {
+				messageCost += cost;
+				messageCostCaptured = true;
+			}
+		} else if (record(entry.tokens)) {
+			addUsageTo(partUsage, record(entry.tokens));
+			if (cost !== void 0) {
+				partCost += cost;
+				partCostCaptured = true;
+			}
+		}
+	}
+	const usage = hasTokenTotals(messageUsage) ? messageUsage : partUsage;
+	metrics.inputTokens = usage.input;
+	metrics.outputTokens = usage.output;
+	metrics.reasoningTokens = usage.reasoning;
+	metrics.cachedTokens = usage.cached;
+	metrics.cacheWriteTokens = usage.cacheWrite;
+	metrics.observedCostUsd = messageCostCaptured ? messageCost : partCost;
+	metrics.observedCostCaptured = messageCostCaptured || partCostCaptured;
+	if (metrics.wallMs === 0 && startedAt !== void 0 && completedAt !== void 0) metrics.wallMs = Math.max(0, completedAt - startedAt);
+	metrics.processScore = terminalProcessScore(metrics);
+	return metrics;
+}
+function kimiCodeMetrics(entries) {
+	const metrics = emptyMetrics(entries.length);
+	let startedAt;
+	let completedAt;
+	for (const entry of entries) {
+		const timestamp = timestampMs(entry.timestamp);
+		if (timestamp !== void 0) {
+			startedAt = startedAt === void 0 ? timestamp : Math.min(startedAt, timestamp);
+			completedAt = completedAt === void 0 ? timestamp : Math.max(completedAt, timestamp);
+		}
+		const role = stringField(entry, "role");
+		if (role === "user") metrics.userMessages += 1;
+		if (role === "assistant") metrics.assistantMessages += 1;
+		if (role === "_usage") addUsage(metrics, entry);
+		const message = record(entry.message);
+		const messageType = message ? stringField(message, "type") : void 0;
+		const payload = record(message?.payload) ?? {};
+		if (messageType === "TurnBegin") {
+			metrics.userMessages += 1;
+			metrics.turnsStarted += 1;
+		}
+		if (messageType === "TurnEnd") metrics.turnsCompleted += 1;
+		if (messageType === "StepInterrupted") metrics.turnsAborted += 1;
+		if (messageType === "StepBegin") metrics.reasoningItems += 1;
+		if (messageType === "ContentPart") {
+			const payloadType = stringField(payload, "type");
+			if (payloadType === "think") metrics.reasoningItems += 1;
+			if (payloadType === "text") metrics.assistantMessages += 1;
+		}
+		if (messageType === "ToolCall") metrics.toolCalls += 1;
+		if (messageType === "ToolResult") {
+			metrics.toolOutputs += 1;
+			if (record(payload.return_value)?.is_error === true) metrics.toolErrors += 1;
+		}
+		if (messageType === "StatusUpdate") addUsage(metrics, record(payload.token_usage));
+		if (messageType === "Notification") {
+			const notification = record(payload.payload);
+			const exitCode = numberField(notification ?? {}, "exit_code");
+			if (notification?.timed_out === true || exitCode !== void 0 && exitCode !== 0) metrics.toolErrors += 1;
+		}
+	}
+	if (startedAt !== void 0 && completedAt !== void 0) metrics.wallMs = Math.max(0, completedAt - startedAt);
+	metrics.processScore = terminalProcessScore(metrics);
+	return metrics;
+}
+function piMetrics(entries) {
+	const metrics = emptyMetrics(entries.length);
+	let bestReliabilityScore;
+	for (const entry of entries) {
+		const nodes = Array.isArray(entry.nodes) ? entry.nodes : [];
+		const edges = Array.isArray(entry.edges) ? entry.edges : [];
+		metrics.graphNodes += nodes.length;
+		metrics.graphEdges += edges.length;
+		for (const node of nodes) {
+			const obj = record(node);
+			const kind = stringField(record(obj?.ir) ?? obj ?? {}, "kind");
+			if (kind === "ActionCandidate") metrics.actionCandidates += 1;
+			if (kind === "ToolInvocation") metrics.toolCalls += 1;
+			if (kind === "ToolResult") metrics.toolOutputs += 1;
+			if (kind === "VerificationReport") metrics.verificationReports += 1;
+			if (kind === "CompletionDecision") {
+				metrics.completionDecisions += 1;
+				metrics.turnsCompleted += 1;
+			}
+		}
+		const averageReliability = numberField(entry, "averageNodeReliability");
+		if (averageReliability !== void 0) bestReliabilityScore = maxOptional(bestReliabilityScore, averageReliability);
+		const pessimisticPath = numberField(entry, "pessimisticPathEstimate");
+		if (pessimisticPath !== void 0) bestReliabilityScore = maxOptional(bestReliabilityScore, pessimisticPath);
+		const rows = Array.isArray(entry.rows) ? entry.rows : [];
+		metrics.reliabilityRows += rows.length;
+		for (const row of rows) {
+			const obj = record(row);
+			if (!obj) continue;
+			const lift = numberField(obj, "lift");
+			if (lift !== void 0) metrics.reliabilityLift = Math.max(metrics.reliabilityLift, lift);
+			const validated = numberField(obj, "validatedSuccessEstimate");
+			if (validated !== void 0) bestReliabilityScore = maxOptional(bestReliabilityScore, validated);
+		}
+	}
+	metrics.processScore = bestReliabilityScore !== void 0 ? clamp01(bestReliabilityScore) : metrics.completionDecisions > 0 ? 1 : 0;
+	return metrics;
+}
+function emptyMetrics(entries) {
+	return {
+		entries,
+		userMessages: 0,
+		assistantMessages: 0,
+		reasoningItems: 0,
+		toolCalls: 0,
+		toolOutputs: 0,
+		toolErrors: 0,
+		unclassifiedErrors: 0,
+		patchAttempts: 0,
+		patchSuccesses: 0,
+		patchFailures: 0,
+		turnsStarted: 0,
+		turnsCompleted: 0,
+		turnsAborted: 0,
+		contextCompactions: 0,
+		mcpCalls: 0,
+		subagentCalls: 0,
+		skillCalls: 0,
+		hookCalls: 0,
+		webCalls: 0,
+		codeActions: 0,
+		prLinks: 0,
+		fileSnapshots: 0,
+		graphNodes: 0,
+		graphEdges: 0,
+		actionCandidates: 0,
+		verificationReports: 0,
+		completionDecisions: 0,
+		reliabilityRows: 0,
+		reliabilityLift: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		reasoningTokens: 0,
+		cachedTokens: 0,
+		cacheWriteTokens: 0,
+		observedCostUsd: 0,
+		observedCostCaptured: false,
+		wallMs: 0,
+		processScore: 0
+	};
+}
+function codexProcessScore(metrics) {
+	const terminalTurns = metrics.turnsCompleted + metrics.turnsAborted;
+	return penalizeErrors(terminalTurns > 0 ? metrics.turnsCompleted / terminalTurns : metrics.assistantMessages > 0 ? .5 : 0, metrics);
+}
+function claudeProcessScore(metrics) {
+	return penalizeErrors(metrics.prLinks > 0 ? 1 : metrics.assistantMessages > 0 ? .75 : 0, metrics);
+}
+function terminalProcessScore(metrics) {
+	const terminalTurns = metrics.turnsCompleted + metrics.turnsAborted;
+	return penalizeErrors(terminalTurns > 0 ? metrics.turnsCompleted / terminalTurns : metrics.assistantMessages > 0 ? .75 : metrics.toolCalls > 0 ? .5 : 0, metrics);
+}
+function penalizeErrors(base, metrics) {
+	const operations = Math.max(1, metrics.toolCalls + metrics.patchAttempts);
+	return clamp01(base * (1 - .5 * Math.min(1, (metrics.toolErrors + metrics.patchFailures) / operations)));
+}
+function emptyTokenTotals() {
+	return {
+		input: 0,
+		output: 0,
+		reasoning: 0,
+		cached: 0,
+		cacheWrite: 0
+	};
+}
+function hasTokenTotals(usage) {
+	return usage.input > 0 || usage.output > 0 || usage.reasoning > 0 || usage.cached > 0 || usage.cacheWrite > 0;
+}
+function addUsage(metrics, usage) {
+	const parsed = readUsage(usage);
+	metrics.inputTokens += parsed.input;
+	metrics.outputTokens += parsed.output;
+	metrics.reasoningTokens += parsed.reasoning;
+	metrics.cachedTokens += parsed.cached;
+	metrics.cacheWriteTokens += parsed.cacheWrite;
+}
+function addUsageTo(totals, usage) {
+	const parsed = readUsage(usage);
+	totals.input += parsed.input;
+	totals.output += parsed.output;
+	totals.reasoning += parsed.reasoning;
+	totals.cached += parsed.cached;
+	totals.cacheWrite += parsed.cacheWrite;
+}
+function readUsage(usage) {
+	const parsed = extractUsage(usage);
+	return {
+		input: parsed?.input ?? 0,
+		output: parsed?.output ?? 0,
+		reasoning: parsed?.reasoning ?? 0,
+		cached: parsed?.cached ?? 0,
+		cacheWrite: parsed?.cacheWrite ?? 0
+	};
+}
+function resolveSessionCost(explicit, metrics, model) {
+	if (explicit) {
+		if (explicit.kind === "uncaptured") {
+			if (explicit.usd !== null) throw new Error("uncaptured cost must have usd: null");
+			return {
+				costUsd: null,
+				costProvenance: explicit
+			};
+		}
+		if (!Number.isFinite(explicit.usd) || explicit.usd < 0) throw new Error(`${explicit.kind} cost must be a finite, non-negative USD amount`);
+		return {
+			costUsd: explicit.usd,
+			costProvenance: explicit
+		};
+	}
+	if (metrics.observedCostCaptured) {
+		const costProvenance = {
+			kind: "observed",
+			usd: metrics.observedCostUsd
+		};
+		return {
+			costUsd: metrics.observedCostUsd,
+			costProvenance
+		};
+	}
+	if ((metrics.inputTokens > 0 || metrics.outputTokens > 0) && isModelPriced(model)) {
+		const costUsd = estimateCost(metrics.inputTokens, metrics.outputTokens, model);
+		return {
+			costUsd,
+			costProvenance: {
+				kind: "estimated",
+				usd: costUsd
+			}
+		};
+	}
+	return {
+		costUsd: null,
+		costProvenance: {
+			kind: "uncaptured",
+			usd: null
+		}
+	};
+}
+function diagnosticsFor(metrics, options) {
+	const warnings = [];
+	if (options.invalidQualityScore) warnings.push("non-finite task quality score omitted");
+	else if (!options.hasQualityLabel) warnings.push("task quality score not supplied");
+	if (!options.explicitTerminal) warnings.push("no explicit terminal success/failure signal");
+	if (metrics.inputTokens === 0 && metrics.outputTokens === 0 && metrics.reasoningTokens === 0 && metrics.cachedTokens === 0 && metrics.cacheWriteTokens === 0) warnings.push("missing token usage");
+	if (options.costKind === "estimated") warnings.push("USD cost estimated from token usage and model pricing");
+	if (options.costKind === "uncaptured") warnings.push("USD cost uncaptured");
+	if (options.costKind === "uncaptured" && !isModelPriced(options.model)) warnings.push("model pricing unknown");
+	if (options.malformedLines > 0) warnings.push(`${options.malformedLines} malformed JSONL lines skipped`);
+	return warnings;
+}
+function applyObservedSurfaceMetrics(metrics, observation) {
+	const actions = observation.actions.filter((action) => action.kind === "tool" || action.kind === "patch");
+	metrics.mcpCalls = actions.filter((action) => action.surface === "mcp").length;
+	metrics.subagentCalls = actions.filter((action) => action.surface === "subagent").length;
+	metrics.skillCalls = actions.filter((action) => action.surface === "skill").length;
+	metrics.hookCalls = actions.filter((action) => action.surface === "hook").length;
+	metrics.webCalls = actions.filter((action) => action.surface === "web").length;
+	metrics.codeActions = actions.filter((action) => action.surface === "code").length;
+}
+function sessionIdFromEntries(source, entries) {
+	for (const entry of entries) {
+		if (source === "codex") {
+			const threadId = stringField(entry, "thread_id");
+			if (threadId) return threadId;
+			const payload = record(entry.payload);
+			const id = payload ? stringField(payload, "id") : void 0;
+			if (id) return id;
+		}
+		const payload = record(record(entry.message)?.payload);
+		const sessionId = stringField(entry, "sessionID") ?? stringField(entry, "sessionId") ?? stringField(entry, "session_id") ?? stringField(payload ?? {}, "session_id");
+		if (sessionId) return sessionId;
+	}
+}
+function modelFromEntries(source, entries) {
+	let providerModel;
+	for (const entry of entries) {
+		if (source === "codex") {
+			const payload = record(entry.payload);
+			const model = payload ? stringField(payload, "model") : void 0;
+			if (model) return model;
+			providerModel = providerModel ?? (payload ? stringField(payload, "model_provider") : void 0);
+		}
+		const openCodeModel = stringField(entry, "modelID");
+		if (openCodeModel) {
+			const provider = stringField(entry, "providerID");
+			return provider ? `${provider}/${openCodeModel}` : openCodeModel;
+		}
+		const modelObject = record(entry.model);
+		const nestedModel = stringField(modelObject ?? {}, "modelID");
+		if (nestedModel) {
+			const provider = stringField(modelObject ?? {}, "providerID");
+			return provider ? `${provider}/${nestedModel}` : nestedModel;
+		}
+		const message = record(entry.message);
+		const model = message ? stringField(message, "model") : void 0;
+		if (model) return model;
+	}
+	return providerModel;
+}
+function cwdFromEntries(entries) {
+	for (const entry of entries) {
+		const path = record(entry.path);
+		const cwd = stringField(entry, "cwd") ?? stringField(path ?? {}, "cwd") ?? stringField(path ?? {}, "root") ?? (record(entry.payload) ? stringField(record(entry.payload), "cwd") : void 0);
+		if (cwd) return cwd;
+	}
+}
+function firstUserText(entries) {
+	for (const entry of entries) {
+		const payload = record(entry.payload);
+		if ((payload ? stringField(payload, "type") : void 0) === "user_message") return stringField(payload, "message");
+		if (stringField(entry, "role") === "user") {
+			const content = entry.content;
+			if (typeof content === "string") return content;
+		}
+		const wirePayload = record(record(entry.message)?.payload);
+		const userInput = wirePayload ? stringField(wirePayload, "user_input") : void 0;
+		if (userInput) return userInput;
+		const message = record(entry.message);
+		if (message && stringField(message, "role") === "user") {
+			const content = message.content;
+			if (typeof content === "string") return content;
+			if (Array.isArray(content)) {
+				const text = content.map((part) => {
+					const obj = record(part);
+					return obj ? stringField(obj, "text") : void 0;
+				}).filter((part) => part !== void 0).join("\n");
+				if (text) return text;
+			}
+		}
+	}
+}
+function fallbackSessionId(source, sourcePath) {
+	return hashString(`${source}:${sourcePath ?? "unknown-session"}`).slice(7, 27);
+}
+function withSnapshot(model) {
+	const trimmed = model.trim() || "unknown";
+	if (trimmed.includes("@") || /-\d{8}$/.test(trimmed) || /-\d{4}-\d{2}-\d{2}$/.test(trimmed)) return trimmed;
+	return `${trimmed}@observed-local`;
+}
+function hashJson(value) {
+	return hashString(JSON.stringify(value));
+}
+function hashString(value) {
+	return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function stableSeed(value) {
+	return createHash("sha256").update(value).digest().readUInt32BE(0);
+}
+function maxOptional(current, next) {
+	return current === void 0 ? next : Math.max(current, next);
+}
+function clamp01(value) {
+	if (!Number.isFinite(value)) return 0;
+	return Math.max(0, Math.min(1, value));
+}
+function finiteScore(value) {
+	return value !== void 0 && Number.isFinite(value) ? clamp01(value) : void 0;
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function record(value) {
+	return isRecord(value) ? value : null;
+}
+function stringField(obj, key) {
+	const value = obj[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberField(obj, key) {
+	const value = obj[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function timestampMs(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value > 0xe8d4a51000 ? value : value * 1e3;
+	if (typeof value === "string" && value.length > 0) {
+		const parsed = Date.parse(value);
+		return Number.isFinite(parsed) ? parsed : void 0;
+	}
+}
+//#endregion
+export { fromPiSession as a, observeCodeAgentSession as c, fromOpenCodeSession as i, fromCodexSession as n, fromPigraphSession as o, fromKimiCodeSession as r, parseCodeAgentJsonl as s, fromClaudeCodeSession as t };
+
+//# sourceMappingURL=code-agent-session-BjkMTQ7H.js.map