@tangle-network/agent-eval 0.130.1 → 0.131.1

package/dist/contract/index.js

@@ -1,19 +1,20 @@
 import { s as ValidationError } from "../errors-8YnH8WlF.js";
-import { i as parseRunRecordSafe, r as modelHasSnapshot } from "../run-record-BuoE80Dq.js";
 import { L as createChatClient, t as buildDefaultAnalystRegistry } from "../default-registry-C-vFCSEc.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 { 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-CUmHkGbI.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 { 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 { n as summarizeExecution, t as analyzeRuns } from "../analyze-runs-C1CavBMk.js";
-import { a as campaignCellExecutionEvidence, c as campaignCellToRunRecord, o as campaignCellJudgeDimensions, s as campaignCellTaskScore } from "../reward-hacking-qipEpKvY.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 { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import { agentCandidateBenchmarkSuiteSchema, agentCandidateBenchmarkTaskSchema, agentCandidateBundleSchema, agentCandidateEvaluationPolicySchema, agentCandidateExperimentSchema, agentImprovementMeasuredComparisonSchema, candidateExecutionEvidenceSchema, canonicalCandidateDigest, omitTopLevelDigest } from "@tangle-network/agent-interface";
+import { agentCandidateBenchmarkSuiteSchema, agentCandidateBenchmarkTaskSchema, agentCandidateBundleSchema, agentCandidateEvaluationPolicySchema, agentCandidateExperimentSchema, agentImprovementMeasuredComparisonSchema, agentProfileImprovementExperimentSchema, agentProfileImprovementMeasuredComparisonSchema, agentProfileImprovementRunCellSchema, agentProfileImprovementRunReceiptSchema, agentProfileImprovementSuiteInputsSchema, agentProfileImprovementSuiteSchema, agentProfileImprovementTaskSchema, candidateExecutionEvidenceSchema, canonicalCandidateDigest, canonicalCandidateJson, omitTopLevelDigest } from "@tangle-network/agent-interface";
 //#region src/contract/self-improve.ts
 /**
 * Run one complete improvement job.
@@ -545,6 +546,28 @@ function requirePositiveInteger(value, field) {
 	return value;
 }
 //#endregion
+//#region src/contract/concurrent-map.ts
+/** Map both arms while bounding the actual executions, not the number of pairs. */
+async function mapPairedConcurrent(options) {
+	if (!Number.isSafeInteger(options.count) || options.count < 0) throw new Error(`${options.label} pair count must be a non-negative integer`);
+	if (options.count > Math.floor(Number.MAX_SAFE_INTEGER / 2)) throw new Error(`${options.label} pair count is too large to schedule both arms`);
+	const executions = await mapConcurrentRange({
+		count: options.count * 2,
+		maxConcurrency: options.maxConcurrency,
+		label: options.label,
+		...options.signal ? { signal: options.signal } : {},
+		map(flatIndex, signal) {
+			const index = Math.floor(flatIndex / 2);
+			const arm = flatIndex % 2 === 0 ? "baseline" : "candidate";
+			return options.map(index, arm, signal);
+		}
+	});
+	return Array.from({ length: options.count }, (_, index) => ({
+		baseline: executions[index * 2],
+		candidate: executions[index * 2 + 1]
+	}));
+}
+//#endregion
 //#region src/contract/measured-comparison.ts
 /** Content-address one task before any measured execution can see it. */
 function sealCandidateBenchmarkTask(material) {
@@ -591,16 +614,12 @@ function verifyCandidateExperiment(input) {
 async function runCandidateExperiment(options) {
 	const experiment = verifyCandidateExperiment(options.experiment);
 	const { suite, tasks } = experiment.benchmark;
-	const maxConcurrency = options.maxConcurrency ?? 2;
-	if (!Number.isSafeInteger(maxConcurrency) || maxConcurrency < 1) throw new Error("candidate experiment maxConcurrency must be a positive integer");
-	const measurements = new Array(suite.taskDigests.length * suite.reps);
-	let nextIndex = 0;
-	const lanes = Array.from({ length: Math.min(maxConcurrency, measurements.length) }, async () => {
-		while (true) {
-			if (options.signal?.aborted) throw abortError(options.signal);
-			const index = nextIndex;
-			nextIndex += 1;
-			if (index >= measurements.length) return;
+	return (await mapPairedConcurrent({
+		count: suite.taskDigests.length * suite.reps,
+		maxConcurrency: options.maxConcurrency ?? 2,
+		label: "candidate experiment",
+		...options.signal ? { signal: options.signal } : {},
+		async map(index, arm, signal) {
 			const taskIndex = Math.floor(index / suite.reps);
 			const repetition = index % suite.reps;
 			const task = tasks[taskIndex];
@@ -611,33 +630,17 @@ async function runCandidateExperiment(options) {
 				taskIndex,
 				repetition
 			};
-			const [baseline, candidate] = await Promise.all([options.execute({
+			return options.execute({
 				experiment,
-				arm: "baseline",
-				bundle: experiment.baseline,
+				arm,
+				bundle: experiment[arm],
 				task,
 				benchmarkCell,
 				seed,
-				...options.signal ? { signal: options.signal } : {}
-			}), options.execute({
-				experiment,
-				arm: "candidate",
-				bundle: experiment.candidate,
-				task,
-				benchmarkCell,
-				seed,
-				...options.signal ? { signal: options.signal } : {}
-			})]);
-			const measurement = {
-				baseline,
-				candidate
-			};
-			verifyMeasurement(experiment, measurement, index);
-			measurements[index] = measurement;
+				signal
+			});
 		}
-	});
-	await Promise.all(lanes);
-	return measurements;
+	})).map((measurement, index) => verifyMeasurement(experiment, measurement, index));
 }
 /**
 * Calculate the shared paired decision from any complete receipt shape.
@@ -721,14 +724,17 @@ function evaluatePairedMeasurements(options) {
 		availability: "measured",
 		...latency
 	});
-	const power = baselineScores.length >= 3 ? powerPreflight({
-		baselineComposites: baselineScores,
-		pairedN: baselineScores.length,
+	const power = observedPairedPrecision({
+		baselineScores,
+		candidateScores,
+		delta: overall.delta,
+		lowerBound: overall.confidenceInterval.lower,
 		deltaThreshold,
+		minProductiveRuns,
 		confidence,
 		sharedScorerChannel: options.sharedScorerChannel
-	}) : void 0;
-	const powerSufficient = baselineScores.length >= minProductiveRuns && power !== void 0 && !power.underpowered;
+	});
+	const powerSufficient = power.sufficient;
 	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);
@@ -744,7 +750,7 @@ function evaluatePairedMeasurements(options) {
 			passed: significance.significant
 		},
 		{
-			name: "statistical-power",
+			name: "paired-precision",
 			passed: powerSufficient
 		},
 		{
@@ -767,7 +773,7 @@ function evaluatePairedMeasurements(options) {
 	const shipped = checks.every((check) => check.passed);
 	const reasons = [
 		...significance.significant ? [] : [significance.fewRuns ? `only ${significance.n} paired runs; ${minProductiveRuns} required` : `paired interval lower bound ${significance.bootstrap.low} did not clear ${deltaThreshold}`],
-		...powerSufficient ? [] : [power?.recommendation ?? `need at least ${Math.max(3, minProductiveRuns)} paired runs`],
+		...powerSufficient || significance.fewRuns ? [] : [power.reason],
 		...regressions.length === 0 ? [] : [`critical dimensions regressed: ${regressions.map((entry) => entry.name).join(", ")}`],
 		...missingCriticalDimensions.length === 0 ? [] : [`critical dimensions missing: ${missingCriticalDimensions.join(", ")}`],
 		...incompleteRuns.length === 0 ? [] : [`${incompleteRuns.length} benchmark executions did not exit successfully`],
@@ -790,11 +796,11 @@ function evaluatePairedMeasurements(options) {
 		power: {
 			sufficient: powerSufficient,
 			n: baselineScores.length,
-			minimumDetectableDelta: power?.mde ?? 1,
+			minimumDetectableDelta: power.minimumDetectableDelta,
 			confidenceLevel: confidence,
-			scaleAssumed: power?.scaleAssumed ?? true,
+			scaleAssumed: power.scaleAssumed,
 			sharedScorerChannel: options.sharedScorerChannel,
-			reason: power?.recommendation ?? `need at least ${Math.max(3, minProductiveRuns)} paired runs`
+			reason: power.reason
 		},
 		executionCostUsd,
 		totalCostUsd,
@@ -1102,6 +1108,35 @@ function measuredEstimate(baseline, candidate, options) {
 		n: bootstrap.n
 	};
 }
+function observedPairedPrecision(options) {
+	const n = options.baselineScores.length;
+	const lowerMargin = Math.max(0, options.delta - options.lowerBound);
+	const minimumDetectableDelta = options.deltaThreshold + lowerMargin;
+	const scaleAssumed = [...options.baselineScores, ...options.candidateScores].every((score) => score >= -.001 && score <= 1.001);
+	const headroom = Math.max(0, 1 - mean(options.baselineScores));
+	const enoughRuns = n >= options.minProductiveRuns;
+	const attainable = !scaleAssumed || minimumDetectableDelta <= headroom;
+	const sufficient = enoughRuns && attainable;
+	const scorerNote = options.sharedScorerChannel ? " The same scorer evaluated both arms, so scorer bias is not measured." : "";
+	if (!enoughRuns) return {
+		sufficient,
+		minimumDetectableDelta,
+		scaleAssumed,
+		reason: `only ${n} paired runs; ${options.minProductiveRuns} required.${scorerNote}`
+	};
+	if (!attainable) return {
+		sufficient,
+		minimumDetectableDelta,
+		scaleAssumed,
+		reason: `observed paired uncertainty gives a minimum detectable delta of ${minimumDetectableDelta.toFixed(3)}, above the remaining score headroom ${headroom.toFixed(3)}.${scorerNote}`
+	};
+	return {
+		sufficient,
+		minimumDetectableDelta,
+		scaleAssumed,
+		reason: `observed paired uncertainty gives a minimum detectable delta of ${minimumDetectableDelta.toFixed(3)} at ${options.confidence.toFixed(2)} confidence from ${n} runs.${scorerNote}`
+	};
+}
 function finiteMeasurement(value, label) {
 	if (!Number.isFinite(value)) throw new Error(`${label} must be finite`);
 	return value;
@@ -1148,8 +1183,219 @@ function mean(values) {
 	if (values.length === 0) throw new Error("candidate experiment requires measured values");
 	return values.reduce((sum, value) => sum + value, 0) / values.length;
 }
-function abortError(signal) {
-	return signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("candidate experiment aborted");
+//#endregion
+//#region src/contract/profile-measured-comparison.ts
+/** Content-address one held-out profile task before either state can execute it. */
+function sealAgentProfileImprovementTask(material) {
+	return agentProfileImprovementTaskSchema.parse({
+		...material,
+		digest: canonicalCandidateDigest(material)
+	});
+}
+/** Freeze profile task order, repetitions, seeds, and the held-out split. */
+function sealAgentProfileImprovementSuite(options) {
+	for (const task of options.tasks) verifyAgentProfileImprovementTask(task);
+	const material = {
+		kind: "agent-profile-improvement-suite",
+		digestAlgorithm: "rfc8785-sha256",
+		splitDigest: options.splitDigest,
+		taskDigests: options.tasks.map((task) => task.digest),
+		reps: options.reps,
+		seeds: options.seeds
+	};
+	const suite = agentProfileImprovementSuiteSchema.parse({
+		...material,
+		digest: canonicalCandidateDigest(material)
+	});
+	return agentProfileImprovementSuiteInputsSchema.parse({
+		suite,
+		tasks: options.tasks
+	});
+}
+/** Freeze the two host-owned profile states and their exact held-out work. */
+function sealAgentProfileImprovementExperiment(material) {
+	return verifyAgentProfileImprovementExperiment({
+		...material,
+		digest: canonicalCandidateDigest(material)
+	});
+}
+function verifyAgentProfileImprovementTask(input) {
+	return agentProfileImprovementTaskSchema.parse(input);
+}
+function verifyAgentProfileImprovementSuiteInputs(input) {
+	return agentProfileImprovementSuiteInputsSchema.parse(input);
+}
+function verifyAgentProfileImprovementExperiment(input) {
+	return agentProfileImprovementExperimentSchema.parse(input);
+}
+/**
+* Execute each signed profile cell through the host's one exact-state executor.
+* Eval owns only the cell schedule and receipt checks; the host resolves each
+* state digest and captures its own run, billing, trace, and grader evidence.
+*/
+async function runAgentProfileImprovementExperiment(options) {
+	const experiment = verifyAgentProfileImprovementExperiment(options.experiment);
+	return (await mapPairedConcurrent({
+		count: experiment.benchmark.suite.taskDigests.length * experiment.benchmark.suite.reps,
+		maxConcurrency: options.maxConcurrency ?? 2,
+		label: "profile improvement experiment",
+		...options.signal ? { signal: options.signal } : {},
+		map(index, arm, signal) {
+			return options.execute(profileExecutionInput(experiment, arm, index, signal));
+		}
+	})).map((measurement, index) => verifyProfileMeasurement(experiment, measurement, index));
+}
+/** Build the only publishable profile comparison from complete host receipts. */
+function measuredComparisonFromAgentProfileImprovementExperiment(options) {
+	const experiment = verifyAgentProfileImprovementExperiment(options.experiment);
+	const measurements = options.measurements.map((measurement, index) => verifyProfileMeasurement(experiment, measurement, index));
+	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),
+			...measurement
+		})),
+		policy: experiment.policy,
+		adapter: profileReceiptAdapter,
+		sharedScorerChannel: true,
+		additionalCostUsd: searchCostUsd
+	});
+	const provisional = agentProfileImprovementMeasuredComparisonSchema.parse({
+		kind: "agent-profile-improvement-measured-comparison",
+		experiment,
+		measurements,
+		overall: evaluation.overall,
+		objectives: evaluation.objectives,
+		...options.candidate ? { candidate: options.candidate } : {},
+		decision: evaluation.decision,
+		power: evaluation.power,
+		provenance: {
+			kind: "agent-eval-loop",
+			schema: "agent-profile-improvement-experiment",
+			runId: options.runId,
+			recordDigest: canonicalCandidateDigest({}),
+			baselineContentHash: experiment.baseline.stateDigest,
+			candidateContentHash: experiment.candidate.stateDigest
+		},
+		diff: canonicalCandidateJson(experiment.change),
+		evaluation: {
+			generationsExplored: options.generationsExplored ?? 0,
+			searchDurationMs,
+			executionDurationMs: evaluation.executionDurationMs,
+			durationMs: evaluation.executionDurationMs + searchDurationMs,
+			searchCostUsd,
+			executionCostUsd: evaluation.executionCostUsd,
+			totalCostUsd: evaluation.totalCostUsd
+		},
+		...options.metadata ? { metadata: options.metadata } : {}
+	});
+	const { recordDigest: _recordDigest, ...provenance } = provisional.provenance;
+	return agentProfileImprovementMeasuredComparisonSchema.parse({
+		...provisional,
+		provenance: {
+			...provenance,
+			recordDigest: canonicalCandidateDigest({
+				...provisional,
+				provenance
+			})
+		}
+	});
+}
+/** Recompute a profile comparison from the exact sealed experiment and receipts. */
+function verifyAgentProfileImprovementExperimentComparison(input) {
+	const comparison = agentProfileImprovementMeasuredComparisonSchema.parse(input);
+	if (canonicalCandidateDigest(measuredComparisonFromAgentProfileImprovementExperiment({
+		experiment: comparison.experiment,
+		measurements: comparison.measurements,
+		runId: comparison.provenance.runId,
+		...comparison.candidate ? { candidate: comparison.candidate } : {},
+		generationsExplored: comparison.evaluation.generationsExplored,
+		searchDurationMs: comparison.evaluation.searchDurationMs,
+		searchCostUsd: comparison.evaluation.searchCostUsd,
+		...comparison.metadata ? { metadata: comparison.metadata } : {}
+	})) !== canonicalCandidateDigest(comparison)) throw new Error("profile improvement comparison does not match its Runtime receipts");
+	return comparison;
+}
+function profileExecutionInput(experiment, arm, index, signal) {
+	const { task, taskIndex, repetition, seed } = profileCell(experiment, index);
+	const stateDigest = experiment[arm].stateDigest;
+	const runCellMaterial = {
+		kind: "agent-profile-improvement-run-cell",
+		experimentDigest: experiment.digest,
+		arm,
+		stateDigest,
+		suiteDigest: experiment.benchmark.suite.digest,
+		taskDigest: task.digest,
+		taskIndex,
+		repetition,
+		seed,
+		attempt: 1
+	};
+	return {
+		experiment,
+		arm,
+		stateDigest,
+		task,
+		runCell: agentProfileImprovementRunCellSchema.parse({
+			...runCellMaterial,
+			digest: canonicalCandidateDigest(runCellMaterial)
+		}),
+		seed,
+		...signal ? { signal } : {}
+	};
+}
+function verifyProfileMeasurement(experiment, input, index) {
+	if (input === null || typeof input !== "object" || Array.isArray(input)) throw new Error(`profile improvement measurement ${index} must be an object`);
+	const material = input;
+	const expectedBaseline = profileExecutionInput(experiment, "baseline", index, void 0);
+	const expectedCandidate = profileExecutionInput(experiment, "candidate", index, void 0);
+	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);
+	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) {
+	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`);
+}
+function profileCell(experiment, index) {
+	const { suite, tasks } = experiment.benchmark;
+	const taskIndex = Math.floor(index / suite.reps);
+	const repetition = index % suite.reps;
+	const task = tasks[taskIndex];
+	const seed = suite.seeds[index];
+	if (!task || seed === void 0) throw new Error(`profile improvement experiment cell ${index} is outside the signed suite`);
+	return {
+		task,
+		taskIndex,
+		repetition,
+		seed
+	};
+}
+function profileCellId(experiment, index) {
+	return `${experiment.benchmark.suite.digest}:${index}`;
+}
+const profileReceiptAdapter = {
+	score: (receipt) => receipt.grading.score,
+	dimensions: (receipt) => receipt.grading.dimensions,
+	costUsd: (receipt) => (receipt.usage.costUsdNanos + receipt.grading.usage.costUsdNanos) / 1e9,
+	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
@@ -1885,6 +2131,6 @@ function collectNumericAttrs(spans) {
 	return raw;
 }
 //#endregion
-export { FileSystemOutcomeStore, InMemoryOutcomeStore, REFERENCE_EQUIVALENCE_INPUT_LIMITS, REFERENCE_EQUIVALENCE_JUDGE_VERSION, SelfImproveRunError, analyzeRuns, buildDefaultAnalystRegistry, buildEvidenceVector, campaignSplitDigest, compareOptimizationMethods, composeGate, createChatClient, createReferenceEquivalenceJudge, defaultProductionGate, defineAgentEval, diffGenerations, diffRunBaselineToWinner, diffRuns, evalReportingSuite, evaluatePairedMeasurements, externalTextOptimizationMethod, fromClaudeCodeSession, fromCodexSession, fromFeedbackTable, fromKimiCodeSession, fromOpenCodeSession, fromOtelSpans, fromPiSession, fromPigraphSession, fromRunRecordDir, fsCampaignStorage, gepaOptimizationMethod, heldOutGate, inMemoryCampaignStorage, llmJudge, measuredComparisonFromCandidateExperiment, observeCodeAgentSession, paretoPolicy, paretoSignificanceGate, parseAgentTrace, parseCodeAgentJsonl, partitionRunsByAuthoringModel, runCampaign, runCandidateExperiment, runEval, runImprovementLoop, runReferenceEquivalenceJudge, sealCandidateBenchmarkSuite, sealCandidateBenchmarkTask, sealCandidateExperiment, selfImprove, skillOptOptimizationMethod, summarizeExecution, verifyCandidateBenchmarkSuite, verifyCandidateBenchmarkSuiteInputs, verifyCandidateBenchmarkTask, verifyCandidateExperiment, verifyCandidateExperimentComparison };
+export { FileSystemOutcomeStore, InMemoryOutcomeStore, REFERENCE_EQUIVALENCE_INPUT_LIMITS, REFERENCE_EQUIVALENCE_JUDGE_VERSION, SelfImproveRunError, analyzeRuns, buildDefaultAnalystRegistry, buildEvidenceVector, campaignSplitDigest, compareOptimizationMethods, composeGate, createChatClient, createReferenceEquivalenceJudge, defaultProductionGate, defineAgentEval, diffGenerations, diffRunBaselineToWinner, diffRuns, evalReportingSuite, evaluatePairedMeasurements, externalTextOptimizationMethod, fromClaudeCodeSession, fromCodexSession, fromFeedbackTable, fromKimiCodeSession, fromOpenCodeSession, fromOtelSpans, fromPiSession, fromPigraphSession, fromRunRecordDir, fsCampaignStorage, gepaOptimizationMethod, heldOutGate, inMemoryCampaignStorage, llmJudge, measuredComparisonFromAgentProfileImprovementExperiment, measuredComparisonFromCandidateExperiment, observeCodeAgentSession, paretoPolicy, paretoSignificanceGate, parseAgentTrace, parseCodeAgentJsonl, partitionRunsByAuthoringModel, runAgentProfileImprovementExperiment, runCampaign, runCandidateExperiment, runEval, runImprovementLoop, runReferenceEquivalenceJudge, sealAgentProfileImprovementExperiment, sealAgentProfileImprovementSuite, sealAgentProfileImprovementTask, sealCandidateBenchmarkSuite, sealCandidateBenchmarkTask, sealCandidateExperiment, selfImprove, skillOptOptimizationMethod, summarizeExecution, verifyAgentProfileImprovementExperiment, verifyAgentProfileImprovementExperimentComparison, verifyAgentProfileImprovementSuiteInputs, verifyAgentProfileImprovementTask, verifyCandidateBenchmarkSuite, verifyCandidateBenchmarkSuiteInputs, verifyCandidateBenchmarkTask, verifyCandidateExperiment, verifyCandidateExperimentComparison };
 
 //# sourceMappingURL=index.js.map