@tangle-network/agent-eval 0.131.1 → 0.133.0

package/dist/contract/index.js

@@ -1,20 +1,21 @@
 import { s as ValidationError } from "../errors-8YnH8WlF.js";
-import { L as createChatClient, t as buildDefaultAnalystRegistry } from "../default-registry-C-vFCSEc.js";
+import { L as createChatClient, t as buildDefaultAnalystRegistry } from "../default-registry-D3T9XbuY.js";
+import { g as isModelPriced, i as CostLedger, m as estimateCost } from "../cost-ledger-BrJxbrMy.js";
 import { LLM_MODEL_ATTR_KEYS, SPAN_KIND_ATTR_KEYS } from "../trace-attributes.js";
 import { b as classifyOtlpSpanRole, x as isOtlpModelCall } from "../tools-BmuN627J.js";
 import { r as mapConcurrentRange } from "../concurrency-MUjT7VjM.js";
-import { B as surfaceContentHash, Ct as llmJudge, M as compareOptimizationMethods, O as composeGate, Q as inMemoryCampaignStorage, S as defaultProductionGate, T as heldoutSignificance, V as surfaceHash, X as createRunCostLedger, Y as runCampaign, Z as fsCampaignStorage, _ as buildEvidenceVector, a as emitLoopProvenance, b as powerPreflight, ct as campaignSplitDigest, d as runImprovementLoop, dt as REFERENCE_EQUIVALENCE_INPUT_LIMITS, ft as REFERENCE_EQUIVALENCE_JUDGE_VERSION, g as gepaOptimizationMethod, j as assertOptimizationResult, k as externalTextOptimizationMethod, mt as runReferenceEquivalenceJudge, o as loopProvenanceArgsFromResult, p as runEval, pt as createReferenceEquivalenceJudge, rt as resolveRunDir, t as skillOptOptimizationMethod, v as paretoPolicy, x as heldOutGate, y as paretoSignificanceGate } from "../skillopt-optimization-method-eOJL2570.js";
+import { B as surfaceContentHash, Ct as llmJudge, M as compareOptimizationMethods, O as composeGate, Q as inMemoryCampaignStorage, S as defaultProductionGate, T as heldoutSignificance, V as surfaceHash, X as createRunCostLedger, Y as runCampaign, Z as fsCampaignStorage, _ as buildEvidenceVector, a as emitLoopProvenance, b as powerPreflight, ct as campaignSplitDigest, d as runImprovementLoop, dt as REFERENCE_EQUIVALENCE_INPUT_LIMITS, ft as REFERENCE_EQUIVALENCE_JUDGE_VERSION, g as gepaOptimizationMethod, j as assertOptimizationResult, k as externalTextOptimizationMethod, mt as runReferenceEquivalenceJudge, o as loopProvenanceArgsFromResult, p as runEval, pt as createReferenceEquivalenceJudge, rt as resolveRunDir, t as skillOptOptimizationMethod, v as paretoPolicy, x as heldOutGate, y as paretoSignificanceGate } from "../skillopt-optimization-method-DgN7U9iR.js";
 import { v as pairedBootstrap } from "../statistics-CnnxdpOg.js";
 import { i as parseRunRecordSafe, r as modelHasSnapshot } from "../run-record-CN8Zd21B.js";
-import { i as summarizeTraceErrors, n as recordAggregateMeasurements, r as summarizeExecutionMeasurements, t as readTaskFailureLabels } from "../task-failure-attributes-CQZlB3et.js";
+import { a as recordAggregateMeasurements, i as readTaskFailureLabels, o as summarizeExecutionMeasurements, s as summarizeTraceErrors, t as extractUsage } from "../extract-usage-2j25whHw.js";
 import { n as summarizeExecution, t as analyzeRuns } from "../analyze-runs-BjPn_fOS.js";
 import { a as campaignCellExecutionEvidence, c as campaignCellToRunRecord, o as campaignCellJudgeDimensions, s as campaignCellTaskScore } from "../reward-hacking-BEvjdUtD.js";
 import { n as InMemoryOutcomeStore, t as FileSystemOutcomeStore } from "../outcome-store-ChBKlTd_.js";
-import { a as fromPiSession, c as observeCodeAgentSession, i as fromOpenCodeSession, n as fromCodexSession, o as fromPigraphSession, r as fromKimiCodeSession, s as parseCodeAgentJsonl, t as fromClaudeCodeSession } from "../code-agent-session-BjkMTQ7H.js";
 import { t as createHostedClient } from "../client-CYzbdJOZ.js";
 import { dirname, join } from "node:path";
+import { createHash } from "node:crypto";
 import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import { agentCandidateBenchmarkSuiteSchema, agentCandidateBenchmarkTaskSchema, agentCandidateBundleSchema, agentCandidateEvaluationPolicySchema, agentCandidateExperimentSchema, agentImprovementMeasuredComparisonSchema, agentProfileImprovementExperimentSchema, agentProfileImprovementMeasuredComparisonSchema, agentProfileImprovementRunCellSchema, agentProfileImprovementRunReceiptSchema, agentProfileImprovementSuiteInputsSchema, agentProfileImprovementSuiteSchema, agentProfileImprovementTaskSchema, candidateExecutionEvidenceSchema, canonicalCandidateDigest, canonicalCandidateJson, omitTopLevelDigest } from "@tangle-network/agent-interface";
+import { agentCandidateBenchmarkSuiteSchema, agentCandidateBenchmarkTaskSchema, agentCandidateBundleSchema, agentCandidateEvaluationPolicySchema, agentCandidateExperimentSchema, agentImprovementMeasuredComparisonSchema, agentProfileImprovementExperimentSchema, agentProfileImprovementMeasuredComparisonSchema, agentProfileImprovementRunCellSchema, agentProfileImprovementRunReceiptSchema, agentProfileImprovementSuiteInputsSchema, agentProfileImprovementSuiteSchema, agentProfileImprovementTaskSchema, candidateExecutionEvidenceSchema, canonicalCandidateDigest, canonicalCandidateJson, numbersApproximatelyEqual, omitTopLevelDigest } from "@tangle-network/agent-interface";
 //#region src/contract/self-improve.ts
 /**
 * Run one complete improvement job.
@@ -417,7 +418,7 @@ function averageComposite(campaign) {
 	const aggs = Object.values(campaign.aggregates.byScenario);
 	return aggs.length === 0 ? 0 : aggs.reduce((s, a) => s + a.meanComposite, 0) / aggs.length;
 }
-function hashString(s) {
+function hashString$1(s) {
 	let h = 2166136261;
 	for (let i = 0; i < s.length; i++) {
 		h ^= s.charCodeAt(i);
@@ -447,7 +448,7 @@ function cellsToRunRecords(cells, candidateId, runId, surface, splitTag, fallbac
 			runId: `${runId}::${candidateId}::${cell.cellId}`,
 			experimentId: runId,
 			candidateId,
-			seed: cell.rep * 1e6 + hashString(cell.scenarioId).slice(0, 6).split("").reduce((a, c) => a * 31 + c.charCodeAt(0) >>> 0, 0),
+			seed: cell.rep * 1e6 + hashString$1(cell.scenarioId).slice(0, 6).split("").reduce((a, c) => a * 31 + c.charCodeAt(0) >>> 0, 0),
 			model,
 			promptHash,
 			configHash,
@@ -546,6 +547,19 @@ function requirePositiveInteger(value, field) {
 	return value;
 }
 //#endregion
+//#region src/contract/fixed-spend.ts
+function addFixedSpend(left, right) {
+	return {
+		inputTokens: left.inputTokens + right.inputTokens,
+		outputTokens: left.outputTokens + right.outputTokens,
+		cachedInputTokens: left.cachedInputTokens + right.cachedInputTokens,
+		reasoningTokens: left.reasoningTokens + right.reasoningTokens,
+		modelCalls: left.modelCalls + right.modelCalls,
+		costUsdNanos: left.costUsdNanos + right.costUsdNanos,
+		costProvenance: left.costProvenance === "observed" && right.costProvenance === "observed" ? "observed" : "estimated"
+	};
+}
+//#endregion
 //#region src/contract/concurrent-map.ts
 /** Map both arms while bounding the actual executions, not the number of pairs. */
 async function mapPairedConcurrent(options) {
@@ -568,6 +582,62 @@ async function mapPairedConcurrent(options) {
 	}));
 }
 //#endregion
+//#region src/contract/paid-paired-measurement.ts
+/**
+* Reserve the complete signed suite before its first cell starts.
+*
+* The host executor receives each task's signed cap through `execute`; this
+* batch reservation prevents a complete comparison from turning into a partial
+* one after earlier analysis or search has used the remaining budget.
+*/
+async function runPaidPairedMeasurement(options) {
+	assertNonNegativeFinite(options.maximumCostUsd, "maximumCostUsd");
+	const costLedger = resolveCostLedger(options);
+	const startedAt = performance.now();
+	const paid = await costLedger.runPaidCall({
+		callId: options.call.callId,
+		channel: options.call.channel,
+		phase: options.call.phase,
+		actor: options.call.actor,
+		model: options.call.model,
+		maximumCharge: { externallyEnforcedMaximumUsd: options.maximumCostUsd },
+		...options.call.tags ? { tags: options.call.tags } : {},
+		...options.signal ? { signal: options.signal } : {},
+		execute: async (signal) => await mapPairedConcurrent({
+			count: options.count,
+			maxConcurrency: options.maxConcurrency,
+			label: options.label,
+			signal,
+			map: options.execute
+		}),
+		receipt: options.receipt
+	});
+	const wallDurationMs = performance.now() - startedAt;
+	if (!paid.succeeded) throw paid.error;
+	if (paid.receipt.costUnknown) throw new Error(`${options.label} did not capture the complete measurement cost`);
+	return {
+		measurements: paid.value,
+		wallDurationMs,
+		cost: paid.receipt.actualCostUsd === void 0 ? {
+			kind: "estimated",
+			usd: paid.receipt.costUsd
+		} : {
+			kind: "observed",
+			usd: paid.receipt.costUsd
+		}
+	};
+}
+function resolveCostLedger(options) {
+	if (options.budgetUsd === void 0) return options.costLedger ?? new CostLedger();
+	assertNonNegativeFinite(options.budgetUsd, "budgetUsd");
+	if (!options.costLedger) throw new Error(`${options.label} with a policy budget requires one shared CostLedger`);
+	if (options.costLedger.costCeilingUsd !== options.budgetUsd) throw new Error(`${options.label} CostLedger ceiling must equal the frozen policy budget`);
+	return options.costLedger;
+}
+function assertNonNegativeFinite(value, label) {
+	if (!Number.isFinite(value) || value < 0) throw new Error(`${label} must be a non-negative finite number`);
+}
+//#endregion
 //#region src/contract/measured-comparison.ts
 /** Content-address one task before any measured execution can see it. */
 function sealCandidateBenchmarkTask(material) {
@@ -614,12 +684,23 @@ function verifyCandidateExperiment(input) {
 async function runCandidateExperiment(options) {
 	const experiment = verifyCandidateExperiment(options.experiment);
 	const { suite, tasks } = experiment.benchmark;
-	return (await mapPairedConcurrent({
+	const run = await runPaidPairedMeasurement({
 		count: suite.taskDigests.length * suite.reps,
 		maxConcurrency: options.maxConcurrency ?? 2,
 		label: "candidate experiment",
+		budgetUsd: experiment.policy.budgetUsd,
+		...options.costLedger ? { costLedger: options.costLedger } : {},
+		maximumCostUsd: candidateMeasurementMaximumCostUsd(experiment),
+		call: {
+			callId: `candidate-measurement:${experiment.digest}`,
+			channel: "measurement",
+			phase: "heldout",
+			actor: experiment.digest,
+			model: candidateMeasurementModel(experiment),
+			tags: { experimentDigest: experiment.digest }
+		},
 		...options.signal ? { signal: options.signal } : {},
-		async map(index, arm, signal) {
+		async execute(index, arm, signal) {
 			const taskIndex = Math.floor(index / suite.reps);
 			const repetition = index % suite.reps;
 			const task = tasks[taskIndex];
@@ -630,7 +711,7 @@ async function runCandidateExperiment(options) {
 				taskIndex,
 				repetition
 			};
-			return options.execute({
+			return verifyExecutionEvidence(await options.execute({
 				experiment,
 				arm,
 				bundle: experiment[arm],
@@ -638,9 +719,22 @@ async function runCandidateExperiment(options) {
 				benchmarkCell,
 				seed,
 				signal
-			});
+			}));
+		},
+		receipt(measurements) {
+			return candidateMeasurementCostReceipt(measurements, candidateMeasurementModel(experiment));
 		}
-	})).map((measurement, index) => verifyMeasurement(experiment, measurement, index));
+	});
+	return {
+		measurements: run.measurements.map((measurement, index) => verifyMeasurement(experiment, measurement, index)),
+		measurement: {
+			wallDurationMs: run.wallDurationMs,
+			cost: {
+				usd: run.cost.usd,
+				provenance: run.cost.kind
+			}
+		}
+	};
 }
 /**
 * Calculate the shared paired decision from any complete receipt shape.
@@ -651,8 +745,11 @@ async function runCandidateExperiment(options) {
 */
 function evaluatePairedMeasurements(options) {
 	if (options.measurements.length === 0) throw new Error("paired measurement evaluation requires at least one paired cell");
-	const additionalCostUsd = options.additionalCostUsd ?? 0;
-	if (!Number.isFinite(additionalCostUsd) || additionalCostUsd < 0) throw new Error("paired measurement evaluation additionalCostUsd must be a non-negative number");
+	const preparationCost = options.preparationCost ?? {
+		usd: 0,
+		provenance: "observed"
+	};
+	if (!Number.isFinite(preparationCost.usd) || preparationCost.usd < 0) throw new Error("paired measurement evaluation preparation cost must be a non-negative number");
 	if (typeof options.sharedScorerChannel !== "boolean") throw new Error("paired measurement evaluation sharedScorerChannel must be a boolean");
 	const policy = agentCandidateEvaluationPolicySchema.parse(options.policy);
 	const measurements = options.measurements.map((measurement, index) => projectPairedMeasurement(measurement, index, options.adapter));
@@ -738,12 +835,22 @@ function evaluatePairedMeasurements(options) {
 	const guardedDimensions = new Set(criticalDimensions);
 	const missingCriticalDimensions = criticalDimensions.filter((dimension) => !dimensions.includes(dimension));
 	const regressions = objectives.filter((objective) => objective.kind === "dimension" && guardedDimensions.has(objective.name) && objective.availability === "measured" && objective.confidenceInterval.lower < -regressionTolerance);
-	const executionCostUsd = measurements.reduce((sum, measurement) => sum + measurement.baseline.costUsd + measurement.candidate.costUsd, 0);
-	const executionDurationMs = measurements.reduce((sum, measurement) => sum + measurement.baseline.latencyMs + measurement.candidate.latencyMs, 0);
+	const measurementCostUsd = measurements.reduce((sum, measurement) => sum + measurement.baseline.costUsd + measurement.candidate.costUsd, 0);
+	const measurementWorkDurationMs = measurements.reduce((sum, measurement) => sum + measurement.baseline.latencyMs + measurement.candidate.latencyMs, 0);
 	const incompleteRuns = measurements.flatMap((measurement) => [measurement.baseline, measurement.candidate]).filter((run) => !run.completed);
 	const failedCandidateResults = measurements.filter((measurement) => !measurement.candidate.passed);
-	const totalCostUsd = executionCostUsd + additionalCostUsd;
-	const budgetPassed = budgetUsd === void 0 || totalCostUsd <= budgetUsd;
+	const derivedMeasurementCost = {
+		usd: measurementCostUsd,
+		provenance: measurements.every((measurement) => measurement.baseline.costProvenance === "observed" && measurement.candidate.costProvenance === "observed") ? "observed" : "estimated"
+	};
+	const measurementCost = options.measurementCost ?? derivedMeasurementCost;
+	assertKnownCost(measurementCost, "paired measurement cost");
+	if (options.measurementCost !== void 0 && (measurementCost.provenance !== derivedMeasurementCost.provenance || !numbersApproximatelyEqual(measurementCost.usd, derivedMeasurementCost.usd))) throw new Error("paired measurement cost does not match its signed receipts");
+	const totalCost = {
+		usd: preparationCost.usd + measurementCost.usd,
+		provenance: preparationCost.provenance === "observed" && measurementCost.provenance === "observed" ? "observed" : "estimated"
+	};
+	const budgetPassed = budgetUsd === void 0 || totalCost.usd < budgetUsd || numbersApproximatelyEqual(totalCost.usd, budgetUsd);
 	const checks = [
 		{
 			name: "paired-significance",
@@ -778,7 +885,7 @@ function evaluatePairedMeasurements(options) {
 		...missingCriticalDimensions.length === 0 ? [] : [`critical dimensions missing: ${missingCriticalDimensions.join(", ")}`],
 		...incompleteRuns.length === 0 ? [] : [`${incompleteRuns.length} benchmark executions did not exit successfully`],
 		...failedCandidateResults.length === 0 ? [] : [`candidate failed ${failedCandidateResults.length} benchmark tasks`],
-		...budgetPassed ? [] : [`total cost ${totalCostUsd} exceeded budget ${budgetUsd}`]
+		...budgetPassed ? [] : [`total cost ${totalCost.usd} exceeded budget ${budgetUsd}`]
 	];
 	return {
 		overall: {
@@ -802,9 +909,9 @@ function evaluatePairedMeasurements(options) {
 			sharedScorerChannel: options.sharedScorerChannel,
 			reason: power.reason
 		},
-		executionCostUsd,
-		totalCostUsd,
-		executionDurationMs
+		measurementCost,
+		totalCost,
+		measurementWorkDurationMs
 	};
 }
 /** Build the only publishable comparison: paired statistics over Runtime receipts. */
@@ -815,7 +922,8 @@ function measuredComparisonFromCandidateExperiment(options) {
 	if (measurements.length !== expectedN) throw new Error(`candidate experiment is incomplete (${measurements.length}/${expectedN} paired cells)`);
 	verifyStableProfileMaterialization(measurements);
 	if (!options.runId.trim()) throw new Error("candidate experiment runId is required");
-	const searchCostUsd = options.searchCostUsd ?? 0;
+	assertPhaseAccounting(options.preparation, "candidate preparation");
+	assertPhaseAccounting(options.measurement, "candidate measurement");
 	const evaluation = evaluatePairedMeasurements({
 		measurements: measurements.map((measurement, index) => ({
 			cellId: cellIds(experiment)[index],
@@ -824,12 +932,10 @@ function measuredComparisonFromCandidateExperiment(options) {
 		policy: experiment.policy,
 		adapter: candidateExecutionEvidenceAdapter,
 		sharedScorerChannel: true,
-		additionalCostUsd: searchCostUsd
+		preparationCost: options.preparation.cost,
+		measurementCost: options.measurement.cost
 	});
 	const diff = deriveCandidateBundleDiff(experiment);
-	const searchDurationMs = options.searchDurationMs ?? 0;
-	const totalCostUsd = evaluation.totalCostUsd;
-	const durationMs = evaluation.executionDurationMs + searchDurationMs;
 	const provisional = agentImprovementMeasuredComparisonSchema.parse({
 		kind: "agent-improvement-measured-comparison",
 		experiment,
@@ -850,12 +956,16 @@ function measuredComparisonFromCandidateExperiment(options) {
 		diff,
 		evaluation: {
 			generationsExplored: options.generationsExplored ?? 0,
-			searchDurationMs,
-			executionDurationMs: evaluation.executionDurationMs,
-			durationMs,
-			searchCostUsd,
-			executionCostUsd: evaluation.executionCostUsd,
-			totalCostUsd
+			preparation: options.preparation,
+			measurement: {
+				wallDurationMs: options.measurement.wallDurationMs,
+				workDurationMs: evaluation.measurementWorkDurationMs,
+				cost: evaluation.measurementCost
+			},
+			total: {
+				wallDurationMs: options.preparation.wallDurationMs + options.measurement.wallDurationMs,
+				cost: evaluation.totalCost
+			}
 		},
 		...options.metadata ? { metadata: options.metadata } : {}
 	});
@@ -880,12 +990,52 @@ function verifyCandidateExperimentComparison(input) {
 		runId: comparison.provenance.runId,
 		...comparison.candidate ? { candidate: comparison.candidate } : {},
 		generationsExplored: comparison.evaluation.generationsExplored,
-		searchDurationMs: comparison.evaluation.searchDurationMs,
-		searchCostUsd: comparison.evaluation.searchCostUsd,
+		preparation: comparison.evaluation.preparation,
+		measurement: {
+			wallDurationMs: comparison.evaluation.measurement.wallDurationMs,
+			cost: comparison.evaluation.measurement.cost
+		},
 		...comparison.metadata ? { metadata: comparison.metadata } : {}
 	})) !== canonicalCandidateDigest(comparison)) throw new Error("candidate experiment comparison does not match its Runtime receipts");
 	return comparison;
 }
+function candidateMeasurementMaximumCostUsd(experiment) {
+	const maximum = experiment.benchmark.tasks.reduce((sum, task) => sum + task.limits.maxCostUsd * experiment.benchmark.suite.reps * 2, 0);
+	if (!Number.isFinite(maximum) || maximum < 0) throw new Error("candidate measurement maximum cost is invalid");
+	return maximum;
+}
+function candidateMeasurementModel(experiment) {
+	const models = [...new Set(experiment.benchmark.tasks.map((task) => task.model.model))];
+	return models.length === 1 ? models[0] : "multiple-models";
+}
+function candidateMeasurementCostReceipt(measurements, model) {
+	const usage = measurements.reduce((sum, measurement) => addFixedSpend(addFixedSpend(sum, combinedUsage(measurement.baseline)), combinedUsage(measurement.candidate)), {
+		inputTokens: 0,
+		outputTokens: 0,
+		cachedInputTokens: 0,
+		reasoningTokens: 0,
+		modelCalls: 0,
+		costUsdNanos: 0,
+		costProvenance: "observed"
+	});
+	const costUsd = usage.costUsdNanos / 1e9;
+	return {
+		model,
+		inputTokens: usage.inputTokens,
+		outputTokens: usage.outputTokens,
+		cachedTokens: usage.cachedInputTokens,
+		reasoningTokens: usage.reasoningTokens,
+		...usage.costProvenance === "observed" ? { actualCostUsd: costUsd } : { estimatedCostUsd: costUsd }
+	};
+}
+function assertPhaseAccounting(accounting, label) {
+	if (!Number.isFinite(accounting.wallDurationMs) || accounting.wallDurationMs < 0) throw new Error(`${label} wall duration must be a non-negative number`);
+	assertKnownCost(accounting.cost, `${label} cost`);
+}
+function assertKnownCost(cost, label) {
+	if (!Number.isFinite(cost.usd) || cost.usd < 0) throw new Error(`${label} must be a non-negative number`);
+	if (cost.provenance !== "observed" && cost.provenance !== "estimated") throw new Error(`${label} provenance must be observed or estimated`);
+}
 function deriveCandidateBundleDiff(experiment) {
 	const changed = [
 		"profile",
@@ -1061,10 +1211,13 @@ function projectRun(run, adapter, label) {
 	const completed = adapter.completed(run);
 	const passed = adapter.passed(run);
 	if (typeof completed !== "boolean" || typeof passed !== "boolean") throw new Error(`${label} completion and pass values must be booleans`);
+	const costProvenance = adapter.costProvenance(run);
+	if (costProvenance !== "observed" && costProvenance !== "estimated") throw new Error(`${label} cost provenance must be observed or estimated`);
 	return {
 		score: finiteMeasurement(adapter.score(run), `${label} score`),
 		dimensions,
 		costUsd: nonNegativeMeasurement(adapter.costUsd(run), `${label} cost`),
+		costProvenance,
 		latencyMs: nonNegativeMeasurement(adapter.latencyMs(run), `${label} latency`),
 		completed,
 		passed
@@ -1149,6 +1302,7 @@ const candidateExecutionEvidenceAdapter = {
 	score: (evidence) => evidence.receipt.benchmarkResult.material.score,
 	dimensions: (evidence) => evidence.receipt.benchmarkResult.material.dimensions,
 	costUsd: costFromEvidence,
+	costProvenance: (evidence) => combinedUsage(evidence).costProvenance,
 	latencyMs: latencyFromEvidence,
 	completed: completedSuccessfully,
 	passed: (evidence) => evidence.receipt.benchmarkResult.material.passed
@@ -1162,14 +1316,7 @@ function latencyFromEvidence(evidence) {
 function combinedUsage(evidence) {
 	const candidate = evidence.receipt.modelSettlement.material.usage;
 	const grader = evidence.receipt.benchmarkResult.material.grading.usage;
-	return {
-		inputTokens: candidate.inputTokens + grader.inputTokens,
-		outputTokens: candidate.outputTokens + grader.outputTokens,
-		cachedInputTokens: candidate.cachedInputTokens + grader.cachedInputTokens,
-		reasoningTokens: candidate.reasoningTokens + grader.reasoningTokens,
-		modelCalls: candidate.modelCalls + grader.modelCalls,
-		costUsdNanos: candidate.costUsdNanos + grader.costUsdNanos
-	};
+	return addFixedSpend(candidate, grader);
 }
 function cellIds(experiment) {
 	const { suite, tasks } = experiment.benchmark;
@@ -1235,15 +1382,45 @@ function verifyAgentProfileImprovementExperiment(input) {
 */
 async function runAgentProfileImprovementExperiment(options) {
 	const experiment = verifyAgentProfileImprovementExperiment(options.experiment);
-	return (await mapPairedConcurrent({
+	const run = await runPaidPairedMeasurement({
 		count: experiment.benchmark.suite.taskDigests.length * experiment.benchmark.suite.reps,
 		maxConcurrency: options.maxConcurrency ?? 2,
 		label: "profile improvement experiment",
+		budgetUsd: experiment.policy.budgetUsd,
+		...options.costLedger ? { costLedger: options.costLedger } : {},
+		maximumCostUsd: profileMeasurementMaximumCostUsd(experiment),
+		call: {
+			callId: `profile-improvement-measurement:${experiment.digest}`,
+			channel: "measurement",
+			phase: "heldout",
+			actor: experiment.executionRef.identity,
+			model: profileMeasurementModel(experiment),
+			tags: {
+				experimentDigest: experiment.digest,
+				executorDigest: experiment.executionRef.digest
+			}
+		},
 		...options.signal ? { signal: options.signal } : {},
-		map(index, arm, signal) {
-			return options.execute(profileExecutionInput(experiment, arm, index, signal));
+		async execute(index, arm, signal) {
+			const expected = profileExecutionInput(experiment, arm, index, signal);
+			const receipt = agentProfileImprovementRunReceiptSchema.parse(await options.execute(expected));
+			verifyProfileReceiptContract(receipt, expected, index);
+			return receipt;
+		},
+		receipt(measurements) {
+			return profileMeasurementCostReceipt(measurements, profileMeasurementModel(experiment));
+		}
+	});
+	return {
+		measurements: run.measurements.map((measurement, index) => verifyProfileMeasurement(experiment, measurement, index)),
+		measurement: {
+			wallDurationMs: run.wallDurationMs,
+			cost: {
+				usd: run.cost.usd,
+				provenance: run.cost.kind
+			}
 		}
-	})).map((measurement, index) => verifyProfileMeasurement(experiment, measurement, index));
+	};
 }
 /** Build the only publishable profile comparison from complete host receipts. */
 function measuredComparisonFromAgentProfileImprovementExperiment(options) {
@@ -1252,8 +1429,6 @@ function measuredComparisonFromAgentProfileImprovementExperiment(options) {
 	const expectedCount = experiment.benchmark.suite.taskDigests.length * experiment.benchmark.suite.reps;
 	if (measurements.length !== expectedCount) throw new Error(`profile improvement experiment is incomplete (${measurements.length}/${expectedCount} paired cells)`);
 	if (!options.runId.trim()) throw new Error("profile improvement experiment runId is required");
-	const searchCostUsd = nonNegative(options.searchCostUsd ?? 0, "searchCostUsd");
-	const searchDurationMs = nonNegative(options.searchDurationMs ?? 0, "searchDurationMs");
 	const evaluation = evaluatePairedMeasurements({
 		measurements: measurements.map((measurement, index) => ({
 			cellId: profileCellId(experiment, index),
@@ -1262,7 +1437,8 @@ function measuredComparisonFromAgentProfileImprovementExperiment(options) {
 		policy: experiment.policy,
 		adapter: profileReceiptAdapter,
 		sharedScorerChannel: true,
-		additionalCostUsd: searchCostUsd
+		preparationCost: options.preparation.cost,
+		measurementCost: options.measurement.cost
 	});
 	const provisional = agentProfileImprovementMeasuredComparisonSchema.parse({
 		kind: "agent-profile-improvement-measured-comparison",
@@ -1284,12 +1460,16 @@ function measuredComparisonFromAgentProfileImprovementExperiment(options) {
 		diff: canonicalCandidateJson(experiment.change),
 		evaluation: {
 			generationsExplored: options.generationsExplored ?? 0,
-			searchDurationMs,
-			executionDurationMs: evaluation.executionDurationMs,
-			durationMs: evaluation.executionDurationMs + searchDurationMs,
-			searchCostUsd,
-			executionCostUsd: evaluation.executionCostUsd,
-			totalCostUsd: evaluation.totalCostUsd
+			preparation: options.preparation,
+			measurement: {
+				wallDurationMs: options.measurement.wallDurationMs,
+				workDurationMs: evaluation.measurementWorkDurationMs,
+				cost: evaluation.measurementCost
+			},
+			total: {
+				wallDurationMs: options.preparation.wallDurationMs + options.measurement.wallDurationMs,
+				cost: evaluation.totalCost
+			}
 		},
 		...options.metadata ? { metadata: options.metadata } : {}
 	});
@@ -1314,12 +1494,48 @@ function verifyAgentProfileImprovementExperimentComparison(input) {
 		runId: comparison.provenance.runId,
 		...comparison.candidate ? { candidate: comparison.candidate } : {},
 		generationsExplored: comparison.evaluation.generationsExplored,
-		searchDurationMs: comparison.evaluation.searchDurationMs,
-		searchCostUsd: comparison.evaluation.searchCostUsd,
+		preparation: comparison.evaluation.preparation,
+		measurement: {
+			wallDurationMs: comparison.evaluation.measurement.wallDurationMs,
+			cost: comparison.evaluation.measurement.cost
+		},
 		...comparison.metadata ? { metadata: comparison.metadata } : {}
 	})) !== canonicalCandidateDigest(comparison)) throw new Error("profile improvement comparison does not match its Runtime receipts");
 	return comparison;
 }
+function profileMeasurementMaximumCostUsd(experiment) {
+	const pairs = experiment.benchmark.suite.reps;
+	const maximum = experiment.benchmark.tasks.reduce((sum, task) => sum + task.limits.maxCostUsd * pairs * 2, 0);
+	if (!Number.isFinite(maximum) || maximum < 0) throw new Error("profile improvement measurement maximum cost is invalid");
+	return maximum;
+}
+function profileMeasurementModel(experiment) {
+	const models = [...new Set(experiment.benchmark.tasks.map((task) => task.model.model))];
+	return models.length === 1 ? models[0] : "multiple-models";
+}
+function profileMeasurementCostReceipt(measurements, model) {
+	const usage = measurements.reduce((sum, measurement) => addFixedSpend(addFixedSpend(sum, combinedProfileUsage(measurement.baseline)), combinedProfileUsage(measurement.candidate)), {
+		inputTokens: 0,
+		outputTokens: 0,
+		cachedInputTokens: 0,
+		reasoningTokens: 0,
+		modelCalls: 0,
+		costUsdNanos: 0,
+		costProvenance: "observed"
+	});
+	const costUsd = usage.costUsdNanos / 1e9;
+	return {
+		model,
+		inputTokens: usage.inputTokens,
+		outputTokens: usage.outputTokens,
+		cachedTokens: usage.cachedInputTokens,
+		reasoningTokens: usage.reasoningTokens,
+		...usage.costProvenance === "observed" ? { actualCostUsd: costUsd } : { estimatedCostUsd: costUsd }
+	};
+}
+function combinedProfileUsage(receipt) {
+	return addFixedSpend(receipt.usage, receipt.grading.usage);
+}
 function profileExecutionInput(experiment, arm, index, signal) {
 	const { task, taskIndex, repetition, seed } = profileCell(experiment, index);
 	const stateDigest = experiment[arm].stateDigest;
@@ -1356,17 +1572,18 @@ function verifyProfileMeasurement(experiment, input, index) {
 	const baseline = agentProfileImprovementRunReceiptSchema.parse(material.baseline);
 	const candidate = agentProfileImprovementRunReceiptSchema.parse(material.candidate);
 	if (baseline.runCell.digest !== expectedBaseline.runCell.digest || candidate.runCell.digest !== expectedCandidate.runCell.digest) throw new Error(`profile improvement measurement ${index} substituted a measured arm`);
-	verifyProfileReceiptTaskContract(baseline, expectedBaseline, index);
-	verifyProfileReceiptTaskContract(candidate, expectedCandidate, index);
+	verifyProfileReceiptContract(baseline, expectedBaseline, index);
+	verifyProfileReceiptContract(candidate, expectedCandidate, index);
 	if (baseline.executionId === candidate.executionId || baseline.digest === candidate.digest) throw new Error(`profile improvement measurement ${index} reused one execution across arms`);
 	return {
 		baseline,
 		candidate
 	};
 }
-function verifyProfileReceiptTaskContract(receipt, expected, index) {
+function verifyProfileReceiptContract(receipt, expected, index) {
 	const task = expected.task;
 	if (canonicalCandidateDigest(receipt.resolvedModel) !== canonicalCandidateDigest(task.model) || canonicalCandidateDigest(receipt.limits) !== canonicalCandidateDigest(task.limits) || canonicalCandidateDigest(receipt.grading.grader) !== canonicalCandidateDigest(task.grader)) throw new Error(`profile improvement measurement ${index} substituted its ${expected.arm} task contract`);
+	if (canonicalCandidateDigest(receipt.executionRef) !== canonicalCandidateDigest(expected.experiment.executionRef)) throw new Error(`profile improvement measurement ${index} substituted its ${expected.arm} executor`);
 }
 function profileCell(experiment, index) {
 	const { suite, tasks } = experiment.benchmark;
@@ -1389,14 +1606,11 @@ const profileReceiptAdapter = {
 	score: (receipt) => receipt.grading.score,
 	dimensions: (receipt) => receipt.grading.dimensions,
 	costUsd: (receipt) => (receipt.usage.costUsdNanos + receipt.grading.usage.costUsdNanos) / 1e9,
+	costProvenance: (receipt) => receipt.usage.costProvenance === "observed" && receipt.grading.usage.costProvenance === "observed" ? "observed" : "estimated",
 	latencyMs: (receipt) => receipt.timing.durationMs + receipt.grading.timing.durationMs,
 	completed: (receipt) => receipt.outcome.status === "succeeded",
 	passed: (receipt) => receipt.grading.passed
 };
-function nonNegative(value, label) {
-	if (!Number.isFinite(value) || value < 0) throw new Error(`${label} must be a non-negative number`);
-	return value;
-}
 //#endregion
 //#region src/contract/intake/run-record-dir.ts
 /**
@@ -1784,6 +1998,1390 @@ function partitionRunsByAuthoringModel(runs, index) {
 	};
 }
 //#endregion
+//#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
 //#region src/contract/intake/feedback-table.ts
 function fromFeedbackTable(opts) {
 	const { ratings, meta = [], scale, emitRaterScores = true } = opts;