@tangle-network/agent-eval 0.216.1 → 0.218.1

package/dist/{default-registry-DzHiGruW.d.ts → default-registry-DXgLmoDI.d.ts}

@@ -1,42 +1,8 @@
-import { X as TraceAnalysisStore, a as AnalystFinding, r as AnalystContext } from "./types-C1tnkEgM.js";
-import { l as ExactCapableAnalyst } from "./exact-types-ClugMJfI.js";
-import { i as AnalystRegistryOptions, t as AnalystRegistry } from "./registry-D7_hm2fK.js";
-import { a as TraceAnalystLimits, i as TraceAnalysisEngineResult, l as RawAnalystFinding, n as TraceAnalysisEngine } from "./engine-3A_4jOlI.js";
-import { t as TraceToolGroupName } from "./tool-groups-C3NEcdCM.js";
-//#region src/trace-analyst/behavioral-metrics.d.ts
-type SuboptimalCode = 'monotonic-input-growth' | 'output-length-decay' | 'single-tool-dependency' | 'no-self-verification';
-interface SuboptimalSignal {
-  code: SuboptimalCode;
-  severity: 'high' | 'medium' | 'low';
-  /** Human-readable claim, with the backing numbers inlined. */
-  detail: string;
-  /** The exact figures the detector fired on — auditable, no model in the loop. */
-  evidence: Record<string, number | string | boolean>;
-}
-interface BehavioralMetrics {
-  /** The only trace represented by these metrics; null when spans are empty. */
-  traceId: string | null;
-  llmCallCount: number;
-  /** Causally serial LLM timelines. Parallel branches are never joined. */
-  tokenSequences: BehavioralTokenSequence[];
-  /** Token values from the longest serial timeline, retained for convenience. */
-  inputTokenTrajectory: number[];
-  outputTokenTrajectory: number[];
-  toolHistogram: Record<string, number>;
-  totalToolCalls: number;
-  distinctTools: number;
-  /** distinct/total tool calls; 1.0 when there are no tool calls. */
-  toolDiversityRatio: number;
-  hasSelfVerification: boolean;
-  signals: SuboptimalSignal[];
-}
-interface BehavioralTokenSequence {
-  scopeId: string;
-  spanIds: string[];
-  inputTokenTrajectory: Array<number | null>;
-  outputTokenTrajectory: Array<number | null>;
-}
-//#endregion
+import { W as TraceAnalysisStore, n as AnalystContext } from "./types-CW8ewATZ.js";
+import { l as ExactCapableAnalyst } from "./exact-types-CflbJ9f3.js";
+import { i as TraceAnalystLimits, r as TraceAnalysisEngineResult, s as RawAnalystFinding, t as TraceAnalysisEngine } from "./engine-BvZ0R-36.js";
+import { t as TraceToolGroupName } from "./tool-groups-DyNz2JZ_.js";
+import { i as AnalystRegistryOptions, t as AnalystRegistry } from "./registry-ssNoHzwD.js";
 //#region src/analyst/behavioral-analyst.d.ts
 interface BehavioralAnalystOptions {
   /** Refuse larger unfiltered datasets instead of sampling them silently. Default 1,000. */
@@ -44,14 +10,6 @@ interface BehavioralAnalystOptions {
   /** Evidence locations retained per finding. Counts still cover every analyzed trace. Default 20. */
   maxEvidenceRefsPerFinding?: number;
 }
-/**
- * Map computed signals → structured AnalystFindings. Pure: no LLM, no clock
- * dependence beyond `produced_at` (overridable for deterministic tests).
- */
-declare function deriveEfficiencyFindings(metrics: BehavioralMetrics, opts?: {
-  analystId?: string;
-  producedAt?: string;
-}): AnalystFinding[];
 /** The deterministic behavioral/efficiency analyst (no LLM, any-model). */
 declare function behavioralAnalyst(options?: BehavioralAnalystOptions): ExactCapableAnalyst<TraceAnalysisStore>;
 //#endregion
@@ -91,7 +49,6 @@ declare function runTraceAnalyst(args: {
 }): Promise<TraceAnalysisEngineResult>;
 /** Adapt a research definition to the common Analyst registry contract. */
 declare function createTraceAnalyst(definition: TraceAnalystDefinition, options: CreateTraceAnalystOptions): ExactCapableAnalyst<TraceAnalysisStore>;
-declare function renderPriorFindings(prior: AnalystContext['priorFindings']): string;
 //#endregion
 //#region src/analyst/default-registry.d.ts
 interface DefaultAnalystRegistryOptions {
@@ -109,5 +66,5 @@ interface DefaultAnalystRegistryOptions {
 }
 declare function buildDefaultAnalystRegistry(options?: DefaultAnalystRegistryOptions): AnalystRegistry;
 //#endregion
-export { createTraceAnalyst as a, BehavioralAnalystOptions as c, TraceAnalystDefinition as i, behavioralAnalyst as l, buildDefaultAnalystRegistry as n, renderPriorFindings as o, CreateTraceAnalystOptions as r, runTraceAnalyst as s, DefaultAnalystRegistryOptions as t, deriveEfficiencyFindings as u };
-//# sourceMappingURL=default-registry-DzHiGruW.d.ts.map
+export { createTraceAnalyst as a, behavioralAnalyst as c, TraceAnalystDefinition as i, buildDefaultAnalystRegistry as n, runTraceAnalyst as o, CreateTraceAnalystOptions as r, BehavioralAnalystOptions as s, DefaultAnalystRegistryOptions as t };
+//# sourceMappingURL=default-registry-DXgLmoDI.d.ts.map

package/dist/default-registry-DXgLmoDI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-registry-DXgLmoDI.d.ts","names":[],"sources":["../src/analyst/behavioral-analyst.ts","../src/analyst/kind-factory.ts","../src/analyst/default-registry.ts"],"mappings":";;;;;;UA+BiB;;EAEf;;EAEA;;;iBAoGc,kBACd,UAAS,2BACR,oBAAoB;;;;UCrHN;EACf;EACA;EACA;EACA;;EAEA,sBAAsB,SAAS;;EAE/B;;EAEA,WAAW;;EAEX,kBACE,OAAO,oBACP,SAAS,wCACe;EAC1B,SAAS,QAAQ;EACjB,eAAe,KAAK,mBAAmB,SAAS,mBAAmB;EACnE;EACA;;UAGe;EACf,QAAQ;;EAER;EACA;;;iBAIoB,gBAAgB;EACpC,YAAY;EACZ,QAAQ;EACR,OAAO;EACP,SAAS;EACT;IACE,QAAQ;;iBAgHI,mBACd,YAAY,wBACZ,SAAS,4BACR,oBAAoB;;;UCrKN;;;;;;EAMf,SAAS;EACT,uBAAuB;;EAEvB;EACA,aAAa;EACb,WAAW;;iBAGG,4BACd,UAAS,gCACR"}

package/dist/{define-agent-eval-CNTPzIkp.js → define-agent-eval-BGdFKlrc.js}

@@ -1,12 +1,12 @@
-import { s as ValidationError } from "./errors-DVZiqS7K.js";
-import { i as modelHasSnapshot } from "./run-record-Boc5IUTp.js";
-import { t as analyzeRuns } from "./analyze-runs-C84irm4i.js";
-import { $ as evaluationUnitMap, A as assertSearchHistoryAdmissionOptions, G as defaultProductionGate, H as runFinalComparison, Q as captureFinalEvidencePolicy, U as openAutoPr, W as captureJudge, Z as assertIndependentEvaluationSplit, at as resolveRunDir, c as executeOptimizationMethod, d as combineComparisonCosts, f as costFromLedgerSummary, m as runImprovementLoop, nt as runEval, tt as reserveFinalEvidence } from "./llm-judge-CG12SQJq.js";
-import { n as campaignCellToRunRecord } from "./run-record-C5e7FjhJ.js";
-import { F as surfaceHash, G as campaignSplitDigest, N as surfaceContentHash, P as surfaceDispatchRef, T as powerPreflight, d as canonicalDigest, f as emitLoopProvenance, p as loopProvenanceArgsFromResult, t as createCampaignEvidenceReceipt, u as campaignMeasurementDigest, x as pairedCampaignComposites } from "./campaign-evidence-Clrn4hBV.js";
-import { F as inMemoryCampaignStorage, N as createRunCostLedger, P as fsCampaignStorage } from "./external-optimizer-subprocess-BqW0hHcI.js";
-import { t as defineEvaluationClaim } from "./claim-q4HQhK1G.js";
-import { i as startSearchShipper, n as shipBestEffort, o as createHostedClient, r as shipSearchLedger } from "./search-shipper-BOSD46qv.js";
+import { s as ValidationError } from "./errors-BcOs5MKW.js";
+import { i as modelHasSnapshot } from "./run-record-DhEJgoPz.js";
+import { t as analyzeRuns } from "./analyze-runs-DqPJaJ4X.js";
+import { B as defaultProductionGate, E as assertSearchHistoryAdmissionOptions, J as evaluationUnitMap, K as assertIndependentEvaluationSplit, L as runFinalComparison, R as openAutoPr, X as reserveFinalEvidence, Z as runEval, d as costFromLedgerSummary, et as resolveRunDir, p as runImprovementLoop, q as captureFinalEvidencePolicy, s as executeOptimizationMethod, u as combineComparisonCosts, z as captureJudge } from "./llm-judge-Djxh-Uhs.js";
+import { n as campaignCellToRunRecord } from "./run-record-CysKLB93.js";
+import { D as surfaceContentHash, O as surfaceDispatchRef, c as campaignMeasurementDigest, d as loopProvenanceArgsFromResult, h as pairedCampaignComposites, k as surfaceHash, l as canonicalDigest, t as createCampaignEvidenceReceipt, u as emitLoopProvenance, y as powerPreflight, z as campaignSplitDigest } from "./campaign-evidence-DunzcJGv.js";
+import { M as fsCampaignStorage, N as inMemoryCampaignStorage, j as createRunCostLedger } from "./external-optimizer-subprocess-B5gdLRZv.js";
+import { t as defineEvaluationClaim } from "./claim-BPVuyHuy.js";
+import { a as createHostedClient, i as startSearchShipper, n as shipBestEffort, r as shipSearchLedger } from "./search-shipper-Bg2HW3Uv.js";
 import { fileURLToPath } from "node:url";
 //#region src/contract/self-improve-reporting.ts
 function pairedCompositeSummary(baseline, winner, independentUnitByScenarioId) {
@@ -68,16 +68,112 @@ function cellsToRunRecords(cells, candidateId, runId, surface, splitTag, fallbac
 }
 //#endregion
 //#region src/contract/self-improve-method.ts
+const METHOD_FINAL_PHASE = "selfImprove.method-final";
 /** Complete methods own search and selection; this path only measures their final choice. */
 async function runSelfImproveMethod(args) {
-	const { opts, train, selection, holdout, costLedger, storage, runDir, startedAt } = args;
+	const { opts, holdout, costLedger, startedAt } = args;
 	const budget = opts.budget ?? {};
+	assertAutoPrTarget(opts);
+	const evidenceContext = captureEvidenceContext(opts, budget);
+	const baselineSurface = structuredClone(opts.baselineSurface);
+	const { selected, cost: methodCost, history } = await searchWithMethod(args, baselineSurface);
+	const totalCost = () => methodTotalCost(opts.method.name, methodCost, costLedger);
+	const comparison = await measureMethodWinner(args, baselineSurface, selected, totalCost);
+	const evidence = evidenceContext ? methodEvidenceReceipts(comparison, baselineSurface, selected, evidenceContext) : void 0;
+	const deferred = comparison.holdout === "deferred";
+	const report = deferred ? null : pairedCompositeSummary(comparison.baselineOnHoldout, comparison.winnerOnHoldout, opts.claim ? evaluationUnitMap(opts.claim, holdout) : void 0);
+	const baseline = report?.baseline ?? null;
+	const winner = report?.winner ?? null;
+	const lift = baseline && winner ? winner.compositeMean - baseline.compositeMean : void 0;
+	const insight = deferred ? void 0 : await analyzeMethodHoldout(args, comparison, baselineSurface, selected);
+	const cost = totalCost();
+	const optimization = {
+		name: opts.method.name,
+		cost: methodCost,
+		...selected.durationMs === void 0 ? {} : { durationMs: selected.durationMs },
+		...selected.provenance === void 0 ? {} : { provenance: selected.provenance }
+	};
+	const durationMs = Date.now() - startedAt;
+	const receipts = costLedger.list();
+	const provenance = recordMethodProvenance({
+		args,
+		comparison,
+		baselineSurface,
+		selected,
+		report,
+		lift,
+		optimization,
+		cost,
+		durationMs,
+		receipts
+	});
+	opts.onProvenance?.(provenance);
+	opts.onProgress?.({
+		kind: "gate.decided",
+		decision: comparison.gateResult.decision,
+		...lift === void 0 ? {} : { lift }
+	});
+	const prResult = opts.autoOnPromote === "pr" && comparison.gateResult.decision === "ship" ? openAutoPr({
+		result: comparison.winnerOnHoldout,
+		gate: comparison.gateResult,
+		promotedDiff: comparison.promotedDiff,
+		ghOwner: opts.ghOwner,
+		ghRepo: opts.ghRepo
+	}) : void 0;
+	const result = {
+		...evidence ? { evidence } : {},
+		mode: "method",
+		...opts.claim ? { claim: opts.claim } : {},
+		...comparison.finalEvidence ? { finalEvidence: comparison.finalEvidence } : {},
+		searchHistoryCoverage: history,
+		baseline,
+		winner: {
+			surface: selected.winnerSurface,
+			compositeMean: winner?.compositeMean ?? null,
+			perScenario: winner?.perScenario ?? {},
+			label: opts.method.name
+		},
+		...lift === void 0 ? {} : { lift },
+		diff: comparison.promotedDiff,
+		gateDecision: comparison.gateResult.decision,
+		provenance,
+		optimization,
+		cost,
+		ledgerCost: costLedger.summary(),
+		totalCostUsd: cost.totalCostUsd,
+		durationMs,
+		receipts,
+		...insight ? { insight } : {},
+		...selected.searchHistory ? { searchHistory: selected.searchHistory } : {},
+		raw: {
+			...comparison,
+			kind: "method",
+			baselineSurface,
+			winnerSurface: selected.winnerSurface,
+			winnerSurfaceHash: surfaceHash(selected.winnerSurface),
+			method: selected,
+			cost,
+			...prResult ? { prResult } : {}
+		}
+	};
+	await shipMethodSearchLedger(opts, selected);
+	return result;
+}
+/** An auto-PR needs a target repository before any spend. */
+function assertAutoPrTarget(opts) {
 	if (opts.autoOnPromote === "pr" && (!opts.ghOwner || !opts.ghRepo)) throw new Error("selfImprove: autoOnPromote='pr' requires ghOwner + ghRepo");
+}
+/** Detach the caller's evidence context; receipts need a measured holdout. */
+function captureEvidenceContext(opts, budget) {
 	const evidenceContext = opts.evidence === void 0 ? void 0 : structuredClone(opts.evidence);
 	if (evidenceContext && budget.holdout === "deferred") throw new Error("selfImprove: evidence receipts require measured holdout");
-	const baselineSurface = structuredClone(opts.baselineSurface);
-	const judge = opts.judge;
-	const { selected, cost: methodCost, history } = await executeOptimizationMethod({
+	return evidenceContext;
+}
+/** Let the method search and select a winner on the train and selection splits. */
+function searchWithMethod(args, baselineSurface) {
+	const { opts, train, selection, costLedger, storage, runDir } = args;
+	const budget = opts.budget ?? {};
+	return executeOptimizationMethod({
 		method: opts.method,
 		storage,
 		searchHistoryPolicy: opts.searchHistoryPolicy,
@@ -87,7 +183,7 @@ async function runSelfImproveMethod(args) {
 			trainScenarios: train,
 			selectionScenarios: selection,
 			dispatchWithSurface: opts.agent,
-			judges: [judge],
+			judges: [opts.judge],
 			runDir: `${runDir}/optimization/${opts.method.name.replace(/[^a-zA-Z0-9._-]/g, "_")}`,
 			seed: 42,
 			runOptions: {
@@ -105,29 +201,39 @@ async function runSelfImproveMethod(args) {
 			costLedger
 		}
 	});
-	const finalPhase = "selfImprove.method-final";
-	const finalCost = () => combineComparisonCosts([
+}
+/** Spend on the final holdout comparison, read back from the shared ledger. */
+function methodFinalCost(costLedger) {
+	return combineComparisonCosts([
 		"holdout.baseline",
 		"holdout.winner",
 		"holdout.neutralized",
 		"promotion.gate"
 	].map((phase) => ({
 		label: phase,
-		cost: costFromLedgerSummary(costLedger.summary({ phase: `${finalPhase}.${phase}` }))
+		cost: costFromLedgerSummary(costLedger.summary({ phase: `${METHOD_FINAL_PHASE}.${phase}` }))
 	})));
-	const totalCost = () => combineComparisonCosts([{
-		label: opts.method.name,
+}
+/** The method's own spend plus the final comparison's. */
+function methodTotalCost(methodName, methodCost, costLedger) {
+	return combineComparisonCosts([{
+		label: methodName,
 		cost: methodCost
 	}, {
 		label: "final comparison",
-		cost: finalCost()
+		cost: methodFinalCost(costLedger)
 	}]);
+}
+/** Measure baseline and winner on the holdout; the gate holds when spend breaks the budget. */
+function measureMethodWinner(args, baselineSurface, selected, totalCost) {
+	const { opts, holdout, costLedger, storage, runDir } = args;
+	const budget = opts.budget ?? {};
 	const gate = opts.gate ?? defaultProductionGate({
 		holdoutScenarios: holdout,
 		deltaThreshold: opts.claim?.minimumEffect ?? .05,
 		independentUnitByScenarioId: opts.claim ? evaluationUnitMap(opts.claim, holdout) : void 0
 	});
-	const comparison = await runFinalComparison({
+	return runFinalComparison({
 		claim: opts.claim,
 		finalEvidence: opts.finalEvidence,
 		baselineSurface,
@@ -135,7 +241,7 @@ async function runSelfImproveMethod(args) {
 		scenarios: holdout,
 		dispatchWithSurface: opts.agent,
 		dispatchRef: opts.dispatchRef,
-		judges: [judge],
+		judges: [opts.judge],
 		holdout: budget.holdout,
 		neutralize: opts.neutralize,
 		gate: {
@@ -160,7 +266,7 @@ async function runSelfImproveMethod(args) {
 		runDir,
 		storage,
 		costLedger,
-		costPhase: finalPhase,
+		costPhase: METHOD_FINAL_PHASE,
 		reps: budget.reps,
 		maxConcurrency: budget.maxConcurrency ?? 2,
 		dispatchTimeoutMs: opts.dispatchTimeoutMs,
@@ -169,7 +275,10 @@ async function runSelfImproveMethod(args) {
 		expectUsage: opts.expectUsage ?? "assert",
 		label: "selfImprove"
 	});
-	const evidence = evidenceContext ? {
+}
+/** Evidence receipts for the baseline and winner holdout campaigns. */
+function methodEvidenceReceipts(comparison, baselineSurface, selected, evidenceContext) {
+	return {
 		baseline: createCampaignEvidenceReceipt({
 			campaign: comparison.baselineOnHoldout,
 			surface: baselineSurface,
@@ -180,28 +289,26 @@ async function runSelfImproveMethod(args) {
 			surface: selected.winnerSurface,
 			context: evidenceContext
 		})
-	} : void 0;
-	const deferred = comparison.holdout === "deferred";
-	const report = deferred ? null : pairedCompositeSummary(comparison.baselineOnHoldout, comparison.winnerOnHoldout, opts.claim ? evaluationUnitMap(opts.claim, holdout) : void 0);
-	const baseline = report?.baseline ?? null;
-	const winner = report?.winner ?? null;
-	const lift = baseline && winner ? winner.compositeMean - baseline.compositeMean : void 0;
-	const insight = deferred ? void 0 : await analyzeRuns({
+	};
+}
+/** Analyze the measured holdout runs; a winner that is the baseline adds no second candidate. */
+function analyzeMethodHoldout(args, comparison, baselineSurface, selected) {
+	const { opts, holdout, runDir } = args;
+	return analyzeRuns({
 		runs: [...cellsToRunRecords(comparison.baselineOnHoldout.cells, "baseline", runDir, baselineSurface, "holdout", opts.model), ...comparison.winnerOnHoldout === comparison.baselineOnHoldout ? [] : cellsToRunRecords(comparison.winnerOnHoldout.cells, "winner", runDir, selected.winnerSurface, "holdout", opts.model)],
 		baselineCandidateId: "baseline",
 		independentUnitByScenarioId: opts.claim ? evaluationUnitMap(opts.claim, holdout) : void 0,
 		decisionThreshold: opts.claim?.minimumEffect ?? .05,
 		...comparison.winnerOnHoldout === comparison.baselineOnHoldout ? {} : { candidateCandidateId: "winner" }
 	});
-	const cost = totalCost();
-	const optimization = {
-		name: opts.method.name,
-		cost: methodCost,
-		...selected.durationMs === void 0 ? {} : { durationMs: selected.durationMs },
-		...selected.provenance === void 0 ? {} : { provenance: selected.provenance }
-	};
-	const durationMs = Date.now() - startedAt;
-	const receipts = costLedger.list();
+}
+/** Build, persist and return the digest-sealed provenance record. */
+function recordMethodProvenance(input) {
+	const { args, comparison, baselineSurface, selected, report, lift, optimization } = input;
+	const { opts, train, selection, holdout, storage, runDir, startedAt } = args;
+	const budget = opts.budget ?? {};
+	const baseline = report?.baseline ?? null;
+	const winner = report?.winner ?? null;
 	const record = {
 		schema: "tangle.method-improvement",
 		runId: `${runDir}#${startedAt}`,
@@ -218,20 +325,20 @@ async function runSelfImproveMethod(args) {
 			holdoutSplitDigest: campaignSplitDigest(holdout, budget.reps ?? 1),
 			baselineCampaignDigest: campaignMeasurementDigest(comparison.baselineOnHoldout),
 			winnerCampaignDigest: campaignMeasurementDigest(comparison.winnerOnHoldout),
-			costReceiptsDigest: canonicalDigest(receipts),
+			costReceiptsDigest: canonicalDigest(input.receipts),
 			...report ? { holdoutObservations: report.observations } : {},
 			...comparison.neutralizedOnHoldout ? { neutralizedCampaignDigest: campaignMeasurementDigest(comparison.neutralizedOnHoldout) } : {}
 		},
 		gate: comparison.gateResult,
-		...deferred ? { holdout: "deferred" } : {},
+		...comparison.holdout === "deferred" ? { holdout: "deferred" } : {},
 		...baseline && winner ? {
 			baselineHoldoutComposite: baseline.compositeMean,
 			winnerHoldoutComposite: winner.compositeMean,
 			heldOutLift: lift
 		} : {},
-		cost,
-		totalCostUsd: cost.totalCostUsd,
-		totalDurationMs: durationMs
+		cost: input.cost,
+		totalCostUsd: input.cost.totalCostUsd,
+		totalDurationMs: input.durationMs
 	};
 	const serialized = JSON.parse(JSON.stringify(record));
 	const provenance = {
@@ -240,70 +347,23 @@ async function runSelfImproveMethod(args) {
 	};
 	storage.ensureDir(runDir);
 	storage.write(`${runDir}/method-provenance.json`, JSON.stringify(provenance, null, 2));
-	opts.onProvenance?.(provenance);
-	opts.onProgress?.({
-		kind: "gate.decided",
-		decision: comparison.gateResult.decision,
-		...lift === void 0 ? {} : { lift }
-	});
-	const prResult = opts.autoOnPromote === "pr" && comparison.gateResult.decision === "ship" ? openAutoPr({
-		result: comparison.winnerOnHoldout,
-		gate: comparison.gateResult,
-		promotedDiff: comparison.promotedDiff,
-		ghOwner: opts.ghOwner,
-		ghRepo: opts.ghRepo
-	}) : void 0;
-	const result = {
-		...evidence ? { evidence } : {},
-		mode: "method",
-		...opts.claim ? { claim: opts.claim } : {},
-		...comparison.finalEvidence ? { finalEvidence: comparison.finalEvidence } : {},
-		searchHistoryCoverage: history,
-		baseline,
-		winner: {
-			surface: selected.winnerSurface,
-			compositeMean: winner?.compositeMean ?? null,
-			perScenario: winner?.perScenario ?? {},
-			label: opts.method.name
-		},
-		...lift === void 0 ? {} : { lift },
-		diff: comparison.promotedDiff,
-		gateDecision: comparison.gateResult.decision,
-		provenance,
-		optimization,
-		cost,
-		ledgerCost: costLedger.summary(),
-		totalCostUsd: cost.totalCostUsd,
-		durationMs,
-		receipts,
-		...insight ? { insight } : {},
-		...selected.searchHistory ? { searchHistory: selected.searchHistory } : {},
-		raw: {
-			...comparison,
-			kind: "method",
-			baselineSurface,
-			winnerSurface: selected.winnerSurface,
-			winnerSurfaceHash: surfaceHash(selected.winnerSurface),
-			method: selected,
-			cost,
-			...prResult ? { prResult } : {}
-		}
-	};
-	if (opts.hostedTenant) {
-		const receipt = selected.searchHistory;
-		if (receipt) {
-			const path = fileURLToPath(receipt.ledger.uri);
-			await shipBestEffort(() => shipSearchLedger({
-				tenant: opts.hostedTenant,
-				ledger: {
-					path,
-					searchId: receipt.summary.searchId
-				},
-				runKind: "optimization"
-			}), path);
-		} else console.warn(`[agent-eval] hostedTenant: method ${opts.method.name} recorded no search ledger, so nothing was shipped`);
-	}
-	return result;
+	return provenance;
+}
+/** Ship the method's search ledger to the hosted tenant, when one is configured. */
+async function shipMethodSearchLedger(opts, selected) {
+	if (!opts.hostedTenant) return;
+	const receipt = selected.searchHistory;
+	if (receipt) {
+		const path = fileURLToPath(receipt.ledger.uri);
+		await shipBestEffort(() => shipSearchLedger({
+			tenant: opts.hostedTenant,
+			ledger: {
+				path,
+				searchId: receipt.summary.searchId
+			},
+			runKind: "optimization"
+		}), path);
+	} else console.warn(`[agent-eval] hostedTenant: method ${opts.method.name} recorded no search ledger, so nothing was shipped`);
 }
 //#endregion
 //#region src/contract/self-improve.ts
@@ -728,4 +788,4 @@ function requirePositiveInteger(value, field) {
 //#endregion
 export { SelfImproveRunError as n, selfImprove as r, defineAgentEval as t };
 
-//# sourceMappingURL=define-agent-eval-CNTPzIkp.js.map
+//# sourceMappingURL=define-agent-eval-BGdFKlrc.js.map