@tangle-network/agent-eval 0.126.5 → 0.126.7

package/dist/{chunk-P6WN2KF5.js → chunk-E3IADPLG.js}

@@ -7,7 +7,7 @@ import {
   pairHoldout,
   recoverTruncatedJson,
   surfaceContentHash
-} from "./chunk-3I74FLK6.js";
+} from "./chunk-BTACVO2W.js";
 import {
   SearchLedgerConflictError,
   SearchLedgerError,
@@ -4634,4 +4634,4 @@ export {
   verifyCodeSurface,
   resolveWorktreePath
 };
-//# sourceMappingURL=chunk-P6WN2KF5.js.map
+//# sourceMappingURL=chunk-E3IADPLG.js.map

package/dist/contract/index.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { AgentCandidateExperiment, AgentCandidateBundle, AgentCandidateBenchmarkTask, AgentCandidateBenchmarkCellRef, AgentCandidateExperimentMeasurement, AgentImprovementMeasuredComparison, CandidateExecutionEvidence, AgentCandidateBenchmarkSuiteInputs, AgentCandidateBenchmarkTaskMaterial, AgentCandidateExperimentMaterial } from '@tangle-network/agent-interface';
+import { AgentCandidateExperiment, AgentCandidateBundle, AgentCandidateBenchmarkTask, AgentCandidateBenchmarkCellRef, AgentCandidateExperimentMeasurement, AgentImprovementMeasuredComparison, AgentCandidateEvaluationPolicy, CandidateExecutionEvidence, AgentCandidateBenchmarkSuiteInputs, AgentCandidateBenchmarkTaskMaterial, AgentCandidateExperimentMaterial } from '@tangle-network/agent-interface';
 import { AxFunction, AxAIService } from '@ax-llm/ax';
 
 type CostChannel = 'agent' | 'judge' | 'verifier' | 'analyst' | 'driver' | (string & {});
@@ -1911,6 +1911,8 @@ interface OptimizationMethodProvenance {
     modules?: OptimizationModuleSource[];
     /** Python implementation used by the bridge process. */
     python?: OptimizationPythonRuntime;
+    /** Exact model identifier configured for optimizer-owned model calls. */
+    optimizerModel?: string;
     runId: string;
     /** Content identity shared by compatible resumptions. */
     compatibleRunId?: string;
@@ -3966,6 +3968,39 @@ interface CompareCandidateExperimentOptions {
     searchCostUsd?: number;
     metadata?: AgentImprovementMeasuredComparison['metadata'];
 }
+/** One exact baseline/candidate observation of the same held-out cell. */
+interface PairedMeasurement<TRun> {
+    cellId: string;
+    baseline: TRun;
+    candidate: TRun;
+}
+/** Maps a product-owned run receipt into the measurements required for a fair paired decision. */
+interface PairedMeasurementAdapter<TRun> {
+    score(run: TRun): number;
+    dimensions(run: TRun): readonly {
+        name: string;
+        score: number;
+    }[];
+    costUsd(run: TRun): number;
+    latencyMs(run: TRun): number;
+    completed(run: TRun): boolean;
+    passed(run: TRun): boolean;
+}
+interface EvaluatePairedMeasurementsOptions<TRun> {
+    measurements: readonly PairedMeasurement<TRun>[];
+    policy: AgentCandidateEvaluationPolicy;
+    adapter: PairedMeasurementAdapter<TRun>;
+    /** Whether both arms use the same scorer family as the promotion decision. */
+    sharedScorerChannel: boolean;
+    /** Search or preparation spend that belongs to the same frozen budget. */
+    additionalCostUsd?: number;
+}
+/** Statistical and operational result derived from complete paired receipts. */
+type PairedMeasurementEvaluation = Pick<AgentImprovementMeasuredComparison, 'overall' | 'objectives' | 'decision' | 'power'> & {
+    executionCostUsd: number;
+    totalCostUsd: number;
+    executionDurationMs: number;
+};
 /** Content-address one task before any measured execution can see it. */
 declare function sealCandidateBenchmarkTask(material: AgentCandidateBenchmarkTaskMaterial): AgentCandidateBenchmarkTask;
 /** Freeze task order, repetitions, and every seed before either arm runs. */
@@ -3975,6 +4010,14 @@ declare function sealCandidateExperiment(material: AgentCandidateExperimentMater
 declare function verifyCandidateExperiment(input: unknown): AgentCandidateExperiment;
 /** Execute each signed cell for both arms. The callback is Runtime's one executor. */
 declare function runCandidateExperiment(options: RunCandidateExperimentOptions): Promise<AgentCandidateExperimentMeasurement[]>;
+/**
+ * Calculate the shared paired decision from any complete receipt shape.
+ *
+ * Callers still own sealing their tasks, verifying each receipt against its
+ * expected arm and state, and proving every expected cell exists. This function
+ * only validates the projected measurements and derives their shared decision.
+ */
+declare function evaluatePairedMeasurements<TRun>(options: EvaluatePairedMeasurementsOptions<TRun>): PairedMeasurementEvaluation;
 /** Build the only publishable comparison: paired statistics over Runtime receipts. */
 declare function measuredComparisonFromCandidateExperiment(options: CompareCandidateExperimentOptions): AgentImprovementMeasuredComparison;
 /** Recompute every statistic and decision from the signed experiment receipts. */
@@ -4520,7 +4563,7 @@ type RawAnalystFinding = z.infer<typeof RawAnalystFindingSchema>;
  * item so persisted rows and older model fixtures remain readable. New output
  * always receives the plural shape.
  */
-declare const CanonicalRawAnalystFindingSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+declare const CanonicalRawAnalystFindingSchema: z.ZodPreprocess<z.ZodObject<{
     evidence: z.ZodArray<z.ZodObject<{
         uri: z.ZodString;
         excerpt: z.ZodOptional<z.ZodString>;
@@ -5463,4 +5506,4 @@ interface FromOtelSpansOptions {
 }
 declare function fromOtelSpans(opts: FromOtelSpansOptions): RunRecord[];
 
-export { type AgentEvalAgent, type AgentEvalEvaluateOptions, type AgentEvalImproveOptions, type AgentTraceContributor, type AgentTraceContributorType, type AgentTraceConversation, type AgentTraceFile, type AgentTraceIndex, type AgentTraceRange, type AgentTraceRecord, type AnalystFinding, type AnalyzeRunsOptions, type AuthoringProvenance, type AxisEvidence, type AxisVerdict, type BuildEvidenceVectorOptions, type CampaignAggregates, type CampaignArtifactWriter, type CampaignCellFailureReceipt, type CampaignCellResult, type CampaignCostMeter, type CampaignResult, type CampaignStorage, type CampaignTraceWriter, type CandidateExperimentExecutionInput, type ChatClient, type CodeAgentSessionAction, type CodeAgentSessionActionKind, type CodeAgentSessionActionStatus, type CodeAgentSessionActionSurface, type CodeAgentSessionDiagnostic, type CodeAgentSessionExecutionReceipt, type CodeAgentSessionIntakeOptions, type CodeAgentSessionIntakeResult, type CodeAgentSessionMetrics, type CodeAgentSessionObservation, type CodeAgentSessionSource, type CodeAgentSessionTerminalStatus, type CodeSurface, type CompareCandidateExperimentOptions, type CompareOptimizationMethodsOptions, type ComparisonCost, type CostLedgerHandle, type CostProvenanceSummary, type CreateChatClientOpts, type DefaultAnalystRegistryOptions, type DefaultProductionGateOptions, type DefineAgentEvalOptions, type DefinedAgentEval, type DeploymentOutcome, type DispatchFn as Dispatch, type DispatchContext, type EvalCellScoreDelta, type EvalDimensionDelta, type EvalGenerationDiff, type EvalReportingSuiteInput, type EvalReportingSuiteOptions, type EvalReportingSuiteResult, type EvalRunDiff, type EvidenceVector, type ExecutionInsight, type ExecutionReport, type ExternalOptimizationExample, type ExternalTextEvaluationResponse, type ExternalTextOptimizationMethodConfig, type ExternalTextOptimizerContext, type ExternalTextOptimizerResult, type FailureClusterInsight, type FeedbackTableMeta, type FeedbackTableRow, FileSystemOutcomeStore, type FileSystemOutcomeStoreOptions, type FromFeedbackTableOptions, type FromFeedbackTableResult, type FromOtelSpansOptions, type FromRunRecordDirOptions, type FromRunRecordDirResult, type Gate, type GateContext, type GateDecision, type GateResult, type GenerationCandidate, type GenerationRecord, type GepaAdaptiveEngineRun, type GepaEngineOptions, type GepaEngineRun, type GepaOptimizationMethodConfig, type GepaOptimizationRecipe, type GepaRunnerCommand, type HeldOutGateOptions, type HostedTenant, InMemoryOutcomeStore, type InsightReport, type InterRaterInsight, type JudgeConfig, type JudgeDimension, type JudgeInsight, type JudgeScore, type LiftInsight, type LlmJudgeDimension, type LlmJudgeOptions, type MutableSurface, type ObjectiveSource, type OpenAICompatibleOptimizerModel, type OptimizationMethod, type OptimizationMethodComparison, type OptimizationMethodInput, type OptimizationMethodProvenance, type OptimizationMethodResult, type OptimizationPackageSource, type OptimizationProposer, type OptimizationTokenUsage, type OptimizerConfig, type OptimizerModelBudget, type OutcomeCorrelationInsight, type OutcomeStore, type ParetoSignificanceGateOptions, type ParsedCodeAgentJsonl, type PartitionByAuthoringModelResult, type PromotionObjective, type PromotionPolicy, REFERENCE_EQUIVALENCE_INPUT_LIMITS, REFERENCE_EQUIVALENCE_JUDGE_VERSION, type Recommendation, type ReferenceEquivalenceJudgeInput, type ReferenceEquivalenceJudgeOptions, type ReferenceEquivalenceJudgeResult, type ReferenceEquivalenceScenario, type ReleaseSummary, type RunCampaignOptions, type RunCandidateExperimentOptions, type RunEvalOptions, type RunImprovementLoopOptions, type RunImprovementLoopResult, type RunRecordRejection, type ScalarDistribution, type Scenario$1 as Scenario, type SealCandidateBenchmarkSuiteOptions, type SelfImproveBudget, type SelfImproveOptions, type SelfImproveProgressEvent, type SelfImproveResult, SelfImproveRunError, type SessionScript, type SkillOptOptimizationMethodConfig, type SkillOptRunnerCommand, type SkillOptTrainerConfig, type SummarizeExecutionOptions, type SurfaceProposer, type TokenUsageInsight, analyzeRuns, buildDefaultAnalystRegistry, buildEvidenceVector, campaignSplitDigest, compareOptimizationMethods, composeGate, createChatClient, createReferenceEquivalenceJudge, defaultProductionGate, defineAgentEval, diffGenerations, diffRunBaselineToWinner, diffRuns, evalReportingSuite, 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 { type AgentEvalAgent, type AgentEvalEvaluateOptions, type AgentEvalImproveOptions, type AgentTraceContributor, type AgentTraceContributorType, type AgentTraceConversation, type AgentTraceFile, type AgentTraceIndex, type AgentTraceRange, type AgentTraceRecord, type AnalystFinding, type AnalyzeRunsOptions, type AuthoringProvenance, type AxisEvidence, type AxisVerdict, type BuildEvidenceVectorOptions, type CampaignAggregates, type CampaignArtifactWriter, type CampaignCellFailureReceipt, type CampaignCellResult, type CampaignCostMeter, type CampaignResult, type CampaignStorage, type CampaignTraceWriter, type CandidateExperimentExecutionInput, type ChatClient, type CodeAgentSessionAction, type CodeAgentSessionActionKind, type CodeAgentSessionActionStatus, type CodeAgentSessionActionSurface, type CodeAgentSessionDiagnostic, type CodeAgentSessionExecutionReceipt, type CodeAgentSessionIntakeOptions, type CodeAgentSessionIntakeResult, type CodeAgentSessionMetrics, type CodeAgentSessionObservation, type CodeAgentSessionSource, type CodeAgentSessionTerminalStatus, type CodeSurface, type CompareCandidateExperimentOptions, type CompareOptimizationMethodsOptions, type ComparisonCost, type CostLedgerHandle, type CostProvenanceSummary, type CreateChatClientOpts, type DefaultAnalystRegistryOptions, type DefaultProductionGateOptions, type DefineAgentEvalOptions, type DefinedAgentEval, type DeploymentOutcome, type DispatchFn as Dispatch, type DispatchContext, type EvalCellScoreDelta, type EvalDimensionDelta, type EvalGenerationDiff, type EvalReportingSuiteInput, type EvalReportingSuiteOptions, type EvalReportingSuiteResult, type EvalRunDiff, type EvaluatePairedMeasurementsOptions, type EvidenceVector, type ExecutionInsight, type ExecutionReport, type ExternalOptimizationExample, type ExternalTextEvaluationResponse, type ExternalTextOptimizationMethodConfig, type ExternalTextOptimizerContext, type ExternalTextOptimizerResult, type FailureClusterInsight, type FeedbackTableMeta, type FeedbackTableRow, FileSystemOutcomeStore, type FileSystemOutcomeStoreOptions, type FromFeedbackTableOptions, type FromFeedbackTableResult, type FromOtelSpansOptions, type FromRunRecordDirOptions, type FromRunRecordDirResult, type Gate, type GateContext, type GateDecision, type GateResult, type GenerationCandidate, type GenerationRecord, type GepaAdaptiveEngineRun, type GepaEngineOptions, type GepaEngineRun, type GepaOptimizationMethodConfig, type GepaOptimizationRecipe, type GepaRunnerCommand, type HeldOutGateOptions, type HostedTenant, InMemoryOutcomeStore, type InsightReport, type InterRaterInsight, type JudgeConfig, type JudgeDimension, type JudgeInsight, type JudgeScore, type LiftInsight, type LlmJudgeDimension, type LlmJudgeOptions, type MutableSurface, type ObjectiveSource, type OpenAICompatibleOptimizerModel, type OptimizationMethod, type OptimizationMethodComparison, type OptimizationMethodInput, type OptimizationMethodProvenance, type OptimizationMethodResult, type OptimizationPackageSource, type OptimizationProposer, type OptimizationTokenUsage, type OptimizerConfig, type OptimizerModelBudget, type OutcomeCorrelationInsight, type OutcomeStore, type PairedMeasurement, type PairedMeasurementAdapter, type PairedMeasurementEvaluation, type ParetoSignificanceGateOptions, type ParsedCodeAgentJsonl, type PartitionByAuthoringModelResult, type PromotionObjective, type PromotionPolicy, REFERENCE_EQUIVALENCE_INPUT_LIMITS, REFERENCE_EQUIVALENCE_JUDGE_VERSION, type Recommendation, type ReferenceEquivalenceJudgeInput, type ReferenceEquivalenceJudgeOptions, type ReferenceEquivalenceJudgeResult, type ReferenceEquivalenceScenario, type ReleaseSummary, type RunCampaignOptions, type RunCandidateExperimentOptions, type RunEvalOptions, type RunImprovementLoopOptions, type RunImprovementLoopResult, type RunRecordRejection, type ScalarDistribution, type Scenario$1 as Scenario, type SealCandidateBenchmarkSuiteOptions, type SelfImproveBudget, type SelfImproveOptions, type SelfImproveProgressEvent, type SelfImproveResult, SelfImproveRunError, type SessionScript, type SkillOptOptimizationMethodConfig, type SkillOptRunnerCommand, type SkillOptTrainerConfig, type SummarizeExecutionOptions, type SurfaceProposer, type TokenUsageInsight, 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 };

package/dist/contract/index.js

@@ -40,7 +40,7 @@ import {
   skillOptOptimizationMethod,
   surfaceContentHash,
   surfaceHash
-} from "../chunk-3I74FLK6.js";
+} from "../chunk-BTACVO2W.js";
 import {
   campaignSplitDigest,
   createRunCostLedger,
@@ -698,6 +698,7 @@ import {
   agentCandidateBenchmarkSuiteSchema,
   agentCandidateBenchmarkTaskSchema,
   agentCandidateBundleSchema,
+  agentCandidateEvaluationPolicySchema,
   agentCandidateExperimentSchema,
   agentImprovementMeasuredComparisonSchema,
   candidateExecutionEvidenceSchema,
@@ -800,19 +801,28 @@ async function runCandidateExperiment(options) {
   await Promise.all(lanes);
   return measurements;
 }
-function measuredComparisonFromCandidateExperiment(options) {
-  const experiment = verifyCandidateExperiment(options.experiment);
+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");
+  }
+  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) => verifyMeasurement(experiment, measurement, index)
+    (measurement, index) => projectPairedMeasurement(measurement, index, options.adapter)
   );
-  const expectedN = experiment.benchmark.suite.taskDigests.length * experiment.benchmark.suite.reps;
-  if (measurements.length !== expectedN) {
-    throw new Error(
-      `candidate experiment is incomplete (${measurements.length}/${expectedN} paired cells)`
-    );
+  const cellIds2 = measurements.map((measurement) => measurement.cellId);
+  if (new Set(cellIds2).size !== cellIds2.length) {
+    throw new Error("paired measurement evaluation cell ids must be unique");
   }
-  verifyStableProfileMaterialization(measurements);
-  if (!options.runId.trim()) throw new Error("candidate experiment runId is required");
+  const dimensions = sharedProjectedDimensions(measurements);
+  const baselineScores = measurements.map((measurement) => measurement.baseline.score);
+  const candidateScores = measurements.map((measurement) => measurement.candidate.score);
   const {
     confidenceLevel: confidence,
     resamples,
@@ -822,15 +832,23 @@ function measuredComparisonFromCandidateExperiment(options) {
     budgetUsd,
     criticalDimensions,
     regressionTolerance
-  } = experiment.policy;
-  const baselineScores = measurements.map(scoreOf("baseline"));
-  const candidateScores = measurements.map(scoreOf("candidate"));
+  } = policy;
+  const significance = heldoutSignificance(
+    { before: baselineScores, after: candidateScores, cellIds: cellIds2 },
+    {
+      confidence,
+      resamples,
+      seed: bootstrapSeed,
+      statistic: "mean",
+      deltaThreshold,
+      minProductiveRuns
+    }
+  );
   const overall = measuredEstimate(baselineScores, candidateScores, {
     confidence,
     resamples,
     seed: bootstrapSeed
   });
-  const dimensions = sharedDimensions(measurements);
   const objectives = [
     {
       kind: "objective",
@@ -848,21 +866,33 @@ function measuredComparisonFromCandidateExperiment(options) {
       unit: "score",
       availability: "measured",
       ...measuredEstimate(
-        measurements.map(dimensionOf("baseline", name)),
-        measurements.map(dimensionOf("candidate", name)),
-        { confidence, resamples, seed: bootstrapSeed + index + 1 }
+        measurements.map((measurement) => dimensionScore(measurement.baseline, name)),
+        measurements.map((measurement) => dimensionScore(measurement.candidate, name)),
+        {
+          confidence,
+          resamples,
+          seed: bootstrapSeed + index + 1
+        }
       )
     }))
   ];
   const cost = measuredEstimate(
-    measurements.map(costOf("baseline")),
-    measurements.map(costOf("candidate")),
-    { confidence, resamples, seed: bootstrapSeed + dimensions.length + 1 }
+    measurements.map((measurement) => measurement.baseline.costUsd),
+    measurements.map((measurement) => measurement.candidate.costUsd),
+    {
+      confidence,
+      resamples,
+      seed: bootstrapSeed + dimensions.length + 1
+    }
   );
   const latency = measuredEstimate(
-    measurements.map(latencyOf("baseline")),
-    measurements.map(latencyOf("candidate")),
-    { confidence, resamples, seed: bootstrapSeed + dimensions.length + 2 }
+    measurements.map((measurement) => measurement.baseline.latencyMs),
+    measurements.map((measurement) => measurement.candidate.latencyMs),
+    {
+      confidence,
+      resamples,
+      seed: bootstrapSeed + dimensions.length + 2
+    }
   );
   objectives.push(
     {
@@ -882,23 +912,12 @@ function measuredComparisonFromCandidateExperiment(options) {
       ...latency
     }
   );
-  const significance = heldoutSignificance(
-    { before: baselineScores, after: candidateScores, cellIds: cellIds(experiment) },
-    {
-      confidence,
-      resamples,
-      seed: bootstrapSeed,
-      statistic: "mean",
-      deltaThreshold,
-      minProductiveRuns
-    }
-  );
   const power = baselineScores.length >= 3 ? powerPreflight({
     baselineComposites: baselineScores,
     pairedN: baselineScores.length,
     deltaThreshold,
     confidence,
-    sharedScorerChannel: true
+    sharedScorerChannel: options.sharedScorerChannel
   }) : void 0;
   const powerSufficient = baselineScores.length >= minProductiveRuns && power !== void 0 && !power.underpowered;
   const guardedDimensions = new Set(criticalDimensions);
@@ -909,20 +928,21 @@ function measuredComparisonFromCandidateExperiment(options) {
     (objective) => objective.kind === "dimension" && guardedDimensions.has(objective.name) && objective.availability === "measured" && objective.confidenceInterval.lower < -regressionTolerance
   );
   const executionCostUsd = measurements.reduce(
-    (sum, measurement) => sum + costFromEvidence(measurement.baseline) + costFromEvidence(measurement.candidate),
+    (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 searchCostUsd = options.searchCostUsd ?? 0;
-  const totalCostUsd = executionCostUsd + searchCostUsd;
-  const budgetPassed = budgetUsd === void 0 || totalCostUsd <= budgetUsd;
   const completedRuns = measurements.flatMap((measurement) => [
     measurement.baseline,
     measurement.candidate
   ]);
-  const incompleteRuns = completedRuns.filter((evidence) => !completedSuccessfully(evidence));
-  const failedCandidateResults = measurements.filter(
-    (measurement) => !measurement.candidate.receipt.benchmarkResult.material.passed
-  );
+  const incompleteRuns = completedRuns.filter((run) => !run.completed);
+  const failedCandidateResults = measurements.filter((measurement) => !measurement.candidate.passed);
+  const totalCostUsd = executionCostUsd + additionalCostUsd;
+  const budgetPassed = budgetUsd === void 0 || totalCostUsd <= budgetUsd;
   const checks = [
     { name: "paired-significance", passed: significance.significant },
     { name: "statistical-power", passed: powerSufficient },
@@ -946,17 +966,7 @@ function measuredComparisonFromCandidateExperiment(options) {
     ...failedCandidateResults.length === 0 ? [] : [`candidate failed ${failedCandidateResults.length} benchmark tasks`],
     ...budgetPassed ? [] : [`total cost ${totalCostUsd} exceeded budget ${budgetUsd}`]
   ];
-  const diff = deriveCandidateBundleDiff(experiment);
-  const executionDurationMs = measurements.reduce(
-    (sum, measurement) => sum + latencyFromEvidence(measurement.baseline) + latencyFromEvidence(measurement.candidate),
-    0
-  );
-  const searchDurationMs = options.searchDurationMs ?? 0;
-  const durationMs = executionDurationMs + searchDurationMs;
-  const provisional = agentImprovementMeasuredComparisonSchema.parse({
-    kind: "agent-improvement-measured-comparison",
-    experiment,
-    measurements,
+  return {
     overall: {
       name: "composite",
       direction: "higher-is-better",
@@ -964,7 +974,6 @@ function measuredComparisonFromCandidateExperiment(options) {
       ...overall
     },
     objectives,
-    ...options.candidate ? { candidate: options.candidate } : {},
     decision: {
       outcome: shipped ? "ship" : significance.fewRuns || !powerSufficient ? "need_more_work" : "hold",
       reasons: reasons.length > 0 ? reasons : ["all measured checks passed"],
@@ -976,9 +985,51 @@ function measuredComparisonFromCandidateExperiment(options) {
       minimumDetectableDelta: power?.mde ?? 1,
       confidenceLevel: confidence,
       scaleAssumed: power?.scaleAssumed ?? true,
-      sharedScorerChannel: true,
+      sharedScorerChannel: options.sharedScorerChannel,
       reason: power?.recommendation ?? `need at least ${Math.max(3, minProductiveRuns)} paired runs`
     },
+    executionCostUsd,
+    totalCostUsd,
+    executionDurationMs
+  };
+}
+function measuredComparisonFromCandidateExperiment(options) {
+  const experiment = verifyCandidateExperiment(options.experiment);
+  const measurements = options.measurements.map(
+    (measurement, index) => verifyMeasurement(experiment, measurement, index)
+  );
+  const expectedN = experiment.benchmark.suite.taskDigests.length * experiment.benchmark.suite.reps;
+  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;
+  const evaluation = evaluatePairedMeasurements({
+    measurements: measurements.map((measurement, index) => ({
+      cellId: cellIds(experiment)[index],
+      ...measurement
+    })),
+    policy: experiment.policy,
+    adapter: candidateExecutionEvidenceAdapter,
+    sharedScorerChannel: true,
+    additionalCostUsd: searchCostUsd
+  });
+  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,
+    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-candidate-experiment",
@@ -991,10 +1042,10 @@ function measuredComparisonFromCandidateExperiment(options) {
     evaluation: {
       generationsExplored: options.generationsExplored ?? 0,
       searchDurationMs,
-      executionDurationMs,
+      executionDurationMs: evaluation.executionDurationMs,
       durationMs,
       searchCostUsd,
-      executionCostUsd,
+      executionCostUsd: evaluation.executionCostUsd,
       totalCostUsd
     },
     ...options.metadata ? { metadata: options.metadata } : {}
@@ -1197,6 +1248,65 @@ function verifyMaterialAddressed(evidence, label) {
     throw new Error(`${label} digest is invalid`);
   }
 }
+function projectPairedMeasurement(measurement, index, adapter) {
+  if (typeof measurement.cellId !== "string" || !measurement.cellId.trim()) {
+    throw new Error(`paired measurement ${index} requires a cell id`);
+  }
+  return {
+    cellId: measurement.cellId,
+    baseline: projectRun(measurement.baseline, adapter, `paired measurement ${index} baseline`),
+    candidate: projectRun(measurement.candidate, adapter, `paired measurement ${index} candidate`)
+  };
+}
+function projectRun(run, adapter, label) {
+  const suppliedDimensions = adapter.dimensions(run);
+  if (!Array.isArray(suppliedDimensions)) {
+    throw new Error(`${label} dimensions must be an array`);
+  }
+  const dimensions = /* @__PURE__ */ new Map();
+  for (const dimension of suppliedDimensions) {
+    if (typeof dimension.name !== "string" || !dimension.name.trim()) {
+      throw new Error(`${label} contains an unnamed dimension`);
+    }
+    if (dimensions.has(dimension.name)) {
+      throw new Error(`${label} repeats dimension '${dimension.name}'`);
+    }
+    dimensions.set(dimension.name, finiteMeasurement(dimension.score, `${label} ${dimension.name}`));
+  }
+  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`);
+  }
+  return {
+    score: finiteMeasurement(adapter.score(run), `${label} score`),
+    dimensions,
+    costUsd: nonNegativeMeasurement(adapter.costUsd(run), `${label} cost`),
+    latencyMs: nonNegativeMeasurement(adapter.latencyMs(run), `${label} latency`),
+    completed,
+    passed
+  };
+}
+function sharedProjectedDimensions(measurements) {
+  const expected = [...measurements[0].baseline.dimensions.keys()];
+  for (const [index, measurement] of measurements.entries()) {
+    for (const [arm, run] of [
+      ["baseline", measurement.baseline],
+      ["candidate", measurement.candidate]
+    ]) {
+      const actual = [...run.dimensions.keys()];
+      if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+        throw new Error(`paired measurement ${index} ${arm} dimensions do not match the suite`);
+      }
+    }
+  }
+  return expected;
+}
+function dimensionScore(run, name) {
+  const value = run.dimensions.get(name);
+  if (value === void 0) throw new Error(`paired measurement is missing dimension '${name}'`);
+  return value;
+}
 function measuredEstimate(baseline, candidate, options) {
   const bootstrap = pairedBootstrap(baseline, candidate, {
     confidence: options.confidence,
@@ -1222,46 +1332,22 @@ function measuredEstimate(baseline, candidate, options) {
     n: bootstrap.n
   };
 }
-function sharedDimensions(measurements) {
-  const expected = dimensionNames(measurements[0]?.baseline);
-  for (const [index, measurement] of measurements.entries()) {
-    for (const [arm, evidence] of [
-      ["baseline", measurement.baseline],
-      ["candidate", measurement.candidate]
-    ]) {
-      const actual = dimensionNames(evidence);
-      if (JSON.stringify(actual) !== JSON.stringify(expected)) {
-        throw new Error(
-          `candidate experiment measurement ${index} ${arm} dimensions do not match the suite`
-        );
-      }
-    }
-  }
-  return expected;
-}
-function dimensionNames(evidence) {
-  return (evidence?.receipt.benchmarkResult.material.dimensions ?? []).map(
-    (dimension) => dimension.name
-  );
-}
-function scoreOf(arm) {
-  return (measurement) => measurement[arm].receipt.benchmarkResult.material.score;
-}
-function dimensionOf(arm, name) {
-  return (measurement) => {
-    const dimension = measurement[arm].receipt.benchmarkResult.material.dimensions.find(
-      (entry) => entry.name === name
-    );
-    if (!dimension) throw new Error(`candidate experiment is missing dimension '${name}'`);
-    return dimension.score;
-  };
-}
-function costOf(arm) {
-  return (measurement) => costFromEvidence(measurement[arm]);
+function finiteMeasurement(value, label) {
+  if (!Number.isFinite(value)) throw new Error(`${label} must be finite`);
+  return value;
 }
-function latencyOf(arm) {
-  return (measurement) => latencyFromEvidence(measurement[arm]);
+function nonNegativeMeasurement(value, label) {
+  if (!Number.isFinite(value) || value < 0) throw new Error(`${label} must be non-negative`);
+  return value;
 }
+var candidateExecutionEvidenceAdapter = {
+  score: (evidence) => evidence.receipt.benchmarkResult.material.score,
+  dimensions: (evidence) => evidence.receipt.benchmarkResult.material.dimensions,
+  costUsd: costFromEvidence,
+  latencyMs: latencyFromEvidence,
+  completed: completedSuccessfully,
+  passed: (evidence) => evidence.receipt.benchmarkResult.material.passed
+};
 function costFromEvidence(evidence) {
   return combinedUsage(evidence).costUsdNanos / 1e9;
 }
@@ -1822,6 +1908,7 @@ export {
   diffRunBaselineToWinner,
   diffRuns,
   evalReportingSuite,
+  evaluatePairedMeasurements,
   externalTextOptimizationMethod,
   fromClaudeCodeSession,
   fromCodexSession,