@tangle-network/agent-runtime 0.106.0 → 0.107.1

package/dist/{improvement-cycle-C095kS_g.js → improvement-cycle-Ulvvbg5p.js}

@@ -1,17 +1,17 @@
 import { i as ConfigError } from "./errors-DEAvWQPy.js";
-import { $ as parseExactAgentProfile, G as agentCandidateProfileAsAgentProfile, J as candidateMaterializerHarness, Q as parseAgentCandidateProfileActivation, Y as createAgentCandidateProfileActivation, Z as omitUndefinedObjectFields, ct as omitTopLevelDigest, d as verifiedResourceTextByDigest, f as verifyAgentCandidateBundle, it as canonicalCandidateDocument, n as executePreparedAgentCandidate, nt as canonicalCandidateBytes, q as assertCandidateProfileBinding, rt as canonicalCandidateDigest$1, st as immutableCandidateValue, t as prepareAgentCandidateExecution, ut as verifyCanonicalCandidateDocument } from "./prepare-B53sPV7M.js";
+import { $ as parseExactAgentProfile, G as agentCandidateProfileAsAgentProfile, J as candidateMaterializerHarness, K as applyExactAgentProfileDiff, Q as parseAgentCandidateProfileActivation, Y as createAgentCandidateProfileActivation, Z as omitUndefinedObjectFields, ct as omitTopLevelDigest, d as verifiedResourceTextByDigest, f as verifyAgentCandidateBundle, it as canonicalCandidateDocument, n as executePreparedAgentCandidate, nt as canonicalCandidateBytes, q as assertCandidateProfileBinding, rt as canonicalCandidateDigest$1, st as immutableCandidateValue, t as prepareAgentCandidateExecution, ut as verifyCanonicalCandidateDocument } from "./prepare-_WTTffkz.js";
 import { N as runLocalHarness, T as runSettledCommand, j as harnessInvocation } from "./supervisor-DTKhF-RV.js";
 import { E as optimizerMethod, a as defaultStructuralRolloutPolicy } from "./structural-rollout-IXUEplky.js";
-import { t as runAnalystLoop } from "./analyst-loop-DGdtVENg.js";
-import { canonicalJson, makeFinding } from "@tangle-network/agent-eval";
-import { campaignSplitDigest, compareOptimizationMethods, gitWorktreeAdapter, verifyCodeSurface } from "@tangle-network/agent-eval/campaign";
-import { agentCandidateMaterializationReceiptSchema, agentCandidateRunReceiptSchema, agentImprovementActivationSchema, agentImprovementProposalSchema, agentImprovementReviewSchema, agentProfileDiffSchema, agentProfileImprovementMeasuredComparisonSchema, agentProfileModelHintsSchema, agentProfileSchema, candidateExecutionEvidenceSchema, changedProfileImprovementSurfaces, defineAgentProfileDiff, sha256DigestSchema } from "@tangle-network/agent-interface";
+import { t as runAnalystLoop } from "./analyst-loop-C8cGThTW.js";
+import { CostLedger, canonicalJson, makeFinding } from "@tangle-network/agent-eval";
+import { campaignScenarioIdentity, campaignSplitDigestFromIdentities, compareOptimizationMethods, gitWorktreeAdapter, verifyCodeSurface } from "@tangle-network/agent-eval/campaign";
+import { AGENT_IMPROVEMENT_SOURCE_METADATA_KEY, agentCandidateMaterializationReceiptSchema, agentCandidateRunReceiptSchema, agentImprovementActivationSchema, agentImprovementProposalSchema, agentImprovementReviewSchema, agentImprovementSourceMetadata, agentImprovementSourceSchema, agentProfileDiffSchema, agentProfileImprovementArmSchema, agentProfileImprovementExecutionRefSchema, agentProfileImprovementMeasuredComparisonSchema, agentProfileModelHintsSchema, agentProfileSchema, candidateExecutionEvidenceSchema, changedProfileImprovementSurfaces, defineAgentProfileDiff, numbersApproximatelyEqual, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { createHash, randomUUID } from "node:crypto";
 import { applyWorkspacePlan, materializeCandidateProfile, materializeProfile } from "@tangle-network/agent-profile-materialize";
 import { existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import { basename, join, resolve, sep } from "node:path";
 import { spawnSync } from "node:child_process";
-import { measuredComparisonFromCandidateExperiment, runCandidateExperiment, sealCandidateExperiment, selfImprove, verifyCandidateExperiment, verifyCandidateExperimentComparison } from "@tangle-network/agent-eval/contract";
+import { measuredComparisonFromAgentProfileImprovementExperiment, measuredComparisonFromCandidateExperiment, runAgentProfileImprovementExperiment, runCandidateExperiment, sealAgentProfileImprovementExperiment, sealAgentProfileImprovementSuite, sealAgentProfileImprovementTask, sealCandidateExperiment, selfImprove, verifyAgentProfileImprovementExperimentComparison, verifyCandidateExperiment, verifyCandidateExperimentComparison } from "@tangle-network/agent-eval/contract";
 import { assertNoJudgeVerdict } from "@tangle-network/agent-eval/analyst";
 //#region src/improvement/agentic-generator.ts
 /**
@@ -1667,10 +1667,19 @@ function exceeds(value, limit) {
 //#region src/improvement/method-identity.ts
 function buildMethodEvaluationIdentity(input) {
 	const optimizationReps = input.optimizationRunOptions?.reps ?? 1;
+	const finalTestReps = input.reps ?? 1;
+	const scenarioPartitions = immutableCandidateValue({
+		train: input.trainScenarios.map(campaignScenarioIdentity),
+		selection: input.selectionScenarios.map(campaignScenarioIdentity),
+		finalTest: input.testScenarios.map(campaignScenarioIdentity),
+		optimizationReps,
+		finalTestReps
+	});
 	const developmentSplitDigest = canonicalCandidateDigest$1({
-		train: campaignSplitDigest(input.trainScenarios, optimizationReps),
-		selection: campaignSplitDigest(input.selectionScenarios, optimizationReps)
+		train: campaignSplitDigestFromIdentities(scenarioPartitions.train, optimizationReps),
+		selection: campaignSplitDigestFromIdentities(scenarioPartitions.selection, optimizationReps)
 	});
+	const finalTestSplitDigest = campaignSplitDigestFromIdentities(scenarioPartitions.finalTest, finalTestReps);
 	const judgeDescriptors = input.judges.map(judgeDescriptor);
 	return {
 		evaluationRef: canonicalCandidateDigest$1({
@@ -1679,6 +1688,7 @@ function buildMethodEvaluationIdentity(input) {
 			coordinate: profileCoordinate(input.surface, input.baselineSurface, input.skills),
 			candidateValidation: input.validateCandidate ? Function.prototype.toString.call(input.validateCandidate) : null,
 			developmentSplitDigest,
+			finalTestSplitDigest,
 			findings: input.findings,
 			judges: judgeDescriptors,
 			run: {
@@ -1698,6 +1708,8 @@ function buildMethodEvaluationIdentity(input) {
 			}
 		}),
 		developmentSplitDigest,
+		finalTestSplitDigest,
+		scenarioPartitions,
 		judgeDescriptors
 	};
 }
@@ -1752,13 +1764,14 @@ async function runMethodImprovement(profile, opts) {
 		findings,
 		trainScenarios: comparisonOptions.trainScenarios,
 		selectionScenarios: comparisonOptions.selectionScenarios,
+		testScenarios: comparisonOptions.testScenarios,
 		judges: comparisonOptions.judges,
 		seed: comparisonOptions.seed,
 		reps: comparisonOptions.reps,
 		costCeiling: comparisonOptions.costCeiling,
 		optimizationRunOptions
 	});
-	const { evaluationRef, developmentSplitDigest } = identity;
+	const { evaluationRef, developmentSplitDigest, finalTestSplitDigest, scenarioPartitions } = identity;
 	const dispatchRef = `improve:${evaluationRef}`;
 	const identifiedJudges = comparisonOptions.judges.map((judge, index) => Object.freeze({
 		...judge,
@@ -1852,6 +1865,8 @@ async function runMethodImprovement(profile, opts) {
 			invocationId: runtimeInvocationId,
 			runId: score.provenance?.runId ?? runtimeInvocationId,
 			developmentSplitDigest,
+			finalTestSplitDigest,
+			scenarioPartitions,
 			executionRef,
 			baselineProfileDigest
 		}),
@@ -1895,6 +1910,11 @@ const AGENT_IMPROVEMENT_PROFILE_SURFACES = [
 	"hooks",
 	"subagents"
 ];
+/**
+* Portable profile surfaces eligible for shared measured comparisons.
+* Other profile settings can contain credentials or executable configuration.
+*/
+const AGENT_PROFILE_MEASURED_SURFACES = ["prompt", "skills"];
 function deriveChangedSurfaces(baselineBundle, candidateBundle) {
 	if (baselineBundle.knowledge || candidateBundle.knowledge) assertKnowledgeCandidatePair(baselineBundle, candidateBundle);
 	assertCodeCandidatePair(baselineBundle, candidateBundle);
@@ -1932,7 +1952,7 @@ function agentProfileImprovementStateDigest(experiment, arm) {
 /** Map Interface's current profile-improvement contract to Runtime-deliverable surfaces. */
 function profileImprovementChangedSurfaces(change) {
 	const surfaces = changedProfileImprovementSurfaces(change);
-	if (surfaces.length === 0 || !surfaces.every((surface) => surface === "prompt" || surface === "skills")) throw new Error("profile improvement experiment does not change a supported surface");
+	if (surfaces.length === 0 || !surfaces.every((surface) => isAgentProfileMeasuredSurface(surface))) throw new Error("profile improvement experiment does not change a supported surface");
 	return surfaces;
 }
 function agentImprovementTargetDigest(experiment, arm, surface) {
@@ -1971,6 +1991,10 @@ function sameAgentImprovementSurfaceSet(left, right) {
 function isAgentImprovementProfileSurface(surface) {
 	return AGENT_IMPROVEMENT_PROFILE_SURFACES.includes(surface);
 }
+/** Return whether a surface is eligible for shared profile measurement. */
+function isAgentProfileMeasuredSurface(surface) {
+	return AGENT_PROFILE_MEASURED_SURFACES.includes(surface);
+}
 /**
 * Return the canonical current-state input for one profile-deliverable improvement target.
 * Missing slots become `null`; tools and subagents include both their direct and resource slots.
@@ -2029,6 +2053,22 @@ function agentImprovementTargetProfileDiffs(target, options) {
 		set
 	}))];
 }
+/**
+* Derive the ordered profile patch that changes one executable profile into
+* another, then prove the patch preserves the complete candidate state.
+*/
+function agentImprovementProfileDiffs(baselineInput, candidateInput, options) {
+	const baseline = parseExactAgentProfile(omitUndefinedObjectFields(baselineInput, "profile improvement baseline"), "profile improvement baseline");
+	const candidate = parseExactAgentProfile(omitUndefinedObjectFields(candidateInput, "profile improvement candidate"), "profile improvement candidate");
+	const surfaces = AGENT_PROFILE_MEASURED_SURFACES.filter((surface) => agentImprovementProfileSurfaceDigest(baseline, surface) !== agentImprovementProfileSurfaceDigest(candidate, surface));
+	if (surfaces.length === 0) throw new Error("profile improvement candidate does not change a deliverable profile surface");
+	const changes = surfaces.flatMap((surface) => agentImprovementTargetProfileDiffs({
+		surface,
+		desiredInput: agentImprovementProfileSurfaceInput(candidate, surface)
+	}, options));
+	if (canonicalCandidateDigest$1(changes.reduce((profile, change) => applyExactAgentProfileDiff(profile, change, "profile improvement candidate change"), baseline)) !== canonicalCandidateDigest$1(candidate)) throw new Error("profile improvement candidate changes fields that the measured profile contract cannot apply");
+	return changes;
+}
 function improvementSurfaceReplacement(target) {
 	const value = target.desiredInput;
 	switch (target.surface) {
@@ -2163,6 +2203,8 @@ const optimizationReceiptMetadataKey = "optimizationReceipt";
 function createOptimizationActivationReceipt(improvement) {
 	const provenance = improvement.provenance;
 	if (!provenance) return void 0;
+	const finalTestDataDigest = improvement.lineage.finalTestSplitDigest;
+	if (!finalTestDataDigest) throw new Error("method improvement does not retain its final-test split digest");
 	const optimizerModel = provenance.optimizerModel;
 	const candidateModel = improvement.candidate.profile.model;
 	return canonicalCandidateDocument({
@@ -2192,7 +2234,9 @@ function createOptimizationActivationReceipt(improvement) {
 			resumed: provenance.resumed,
 			artifactDir: provenance.artifactDir
 		},
-		developmentDataDigest: improvement.lineage.developmentSplitDigest
+		developmentDataDigest: improvement.lineage.developmentSplitDigest,
+		finalTestDataDigest,
+		scenarioPartitions: improvement.lineage.scenarioPartitions
 	}).value;
 }
 /** Add Runtime-owned optimizer evidence without aliasing caller metadata. */
@@ -2214,11 +2258,32 @@ function optimizationActivationReceiptFromMetadata(metadata) {
 }
 function parseOptimizationActivationReceipt(value) {
 	if (!isRecord(value) || value.kind !== "optimization-activation-receipt") throw new Error("optimization receipt must be an optimization-activation-receipt");
-	if (!isNonEmptyString(value.method) || !isPackageSource(value.source) || value.bridge !== void 0 && !isPackageSource(value.bridge) || !isModules(value.modules) || !isPythonRuntime(value.python) || !isModels(value.models) || !isUsage(value.usage) || !isCost(value.cost) || !isInvocation(value.invocation) || !isSha256Digest(value.developmentDataDigest) || !isSha256Digest(value.digest)) throw new Error("optimization receipt contains invalid evidence");
+	if (!isNonEmptyString(value.method) || !isPackageSource(value.source) || value.bridge !== void 0 && !isPackageSource(value.bridge) || !isModules(value.modules) || !isPythonRuntime(value.python) || !isModels(value.models) || !isUsage(value.usage) || !isCost(value.cost) || !isInvocation(value.invocation) || !isSha256Digest(value.developmentDataDigest) || !isSha256Digest(value.finalTestDataDigest) || !isScenarioPartitions(value.scenarioPartitions) || !isSha256Digest(value.digest)) throw new Error("optimization receipt contains invalid evidence");
 	const receipt = value;
+	if (!hasMatchingScenarioPartitionDigests(receipt)) throw new Error("optimization receipt task identities do not match its split digests");
 	if (canonicalCandidateDigest$1(omitTopLevelDigest(receipt)) !== receipt.digest) throw new Error("optimization receipt digest does not match its evidence");
 	return receipt;
 }
+function isScenarioPartitions(value) {
+	if (!isRecord(value)) return false;
+	return isScenarioIdentityList(value.train) && isScenarioIdentityList(value.selection) && isScenarioIdentityList(value.finalTest) && isPositiveSafeInteger(value.optimizationReps) && isPositiveSafeInteger(value.finalTestReps);
+}
+function isScenarioIdentityList(value) {
+	return Array.isArray(value) && value.every((scenario) => isRecord(scenario) && isNonEmptyString(scenario.id) && isNonEmptyString(scenario.kind) && isSha256Digest(scenario.scenarioDigest));
+}
+function hasMatchingScenarioPartitionDigests(receipt) {
+	try {
+		const { scenarioPartitions } = receipt;
+		const developmentDataDigest = canonicalCandidateDigest$1({
+			train: campaignSplitDigestFromIdentities(scenarioPartitions.train, scenarioPartitions.optimizationReps),
+			selection: campaignSplitDigestFromIdentities(scenarioPartitions.selection, scenarioPartitions.optimizationReps)
+		});
+		const finalTestDataDigest = campaignSplitDigestFromIdentities(scenarioPartitions.finalTest, scenarioPartitions.finalTestReps);
+		return receipt.developmentDataDigest === developmentDataDigest && receipt.finalTestDataDigest === finalTestDataDigest;
+	} catch {
+		return false;
+	}
+}
 function isPackageSource(value) {
 	if (!isRecord(value) || value.kind !== "package" || value.evidence !== "observed" && value.evidence !== "declared" || !isNonEmptyString(value.package) || !isNonEmptyString(value.version)) return false;
 	return isOptionalNonEmptyString(value.sourceUrl) && isOptionalNonEmptyString(value.revision) && (value.sourceSha256 === void 0 || typeof value.sourceSha256 === "string" && /^[0-9a-f]{64}$/.test(value.sourceSha256));
@@ -2284,6 +2349,9 @@ function isOptionalNonEmptyString(value) {
 function isNonNegativeInteger(value) {
 	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
+function isPositiveSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
 function isOptionalNonNegativeInteger(value) {
 	return value === void 0 || isNonNegativeInteger(value);
 }
@@ -2309,10 +2377,12 @@ function sealAgentImprovementExperiment(material, improvement) {
 		runIds: [improvement.lineage.runId],
 		developmentSplitDigest: improvement.lineage.developmentSplitDigest
 	};
-	return sealCandidateExperiment({
+	const experiment = sealCandidateExperiment({
 		...material,
 		candidateLineage
 	});
+	assertCandidateReleaseWorkIsFresh(experiment, improvement);
+	return experiment;
 }
 function assertRuntimeOwnedExperimentFieldsAbsent(material) {
 	if (material === null || typeof material !== "object" || Array.isArray(material)) throw new Error("agent improvement experiment material must be an object");
@@ -2322,9 +2392,18 @@ function assertRuntimeOwnedExperimentFieldsAbsent(material) {
 /** Execute both arms of one immutable experiment and derive its paired result. */
 async function runAgentCandidateExperiment(options) {
 	const experiment = verifyCandidateExperiment(options.experiment);
-	const measurements = await runCandidateExperiment({
+	const preparation = options.preparation ?? {
+		wallDurationMs: 0,
+		cost: {
+			usd: 0,
+			provenance: "observed"
+		}
+	};
+	const costLedger = options.costLedger ?? (experiment.policy.budgetUsd === void 0 ? void 0 : new CostLedger({ costCeilingUsd: experiment.policy.budgetUsd }));
+	const run = await runCandidateExperiment({
 		experiment,
 		...options.maxConcurrency === void 0 ? {} : { maxConcurrency: options.maxConcurrency },
+		...costLedger ? { costLedger } : {},
 		...options.signal ? { signal: options.signal } : {},
 		execute: async (input) => {
 			const placement = await options.placeCell(input);
@@ -2334,19 +2413,20 @@ async function runAgentCandidateExperiment(options) {
 			});
 		}
 	});
+	const evaluation = createAgentImprovementMeasuredComparison({
+		experiment,
+		measurements: run.measurements,
+		preparation,
+		measurement: run.measurement,
+		runId: options.runId,
+		...options.candidate ? { candidate: options.candidate } : {},
+		...options.generationsExplored === void 0 ? {} : { generationsExplored: options.generationsExplored },
+		...options.metadata ? { metadata: options.metadata } : {}
+	});
 	return {
 		experiment,
-		measurements,
-		evaluation: createAgentImprovementMeasuredComparison({
-			experiment,
-			measurements,
-			runId: options.runId,
-			...options.candidate ? { candidate: options.candidate } : {},
-			...options.generationsExplored === void 0 ? {} : { generationsExplored: options.generationsExplored },
-			...options.searchDurationMs === void 0 ? {} : { searchDurationMs: options.searchDurationMs },
-			...options.searchCostUsd === void 0 ? {} : { searchCostUsd: options.searchCostUsd },
-			...options.metadata ? { metadata: options.metadata } : {}
-		})
+		measurements: run.measurements,
+		evaluation
 	};
 }
 /** Execute one exact arm, task, repetition, seed, and attempt through Runtime. */
@@ -2397,14 +2477,246 @@ async function executeAgentCandidateExperimentCell(options) {
 function createAgentImprovementMeasuredComparison(options) {
 	return verifyCandidateExperimentComparison(measuredComparisonFromCandidateExperiment(options));
 }
+async function analyzeAgentImprovement(runId, options, costLedger, signal) {
+	const rawOptions = options;
+	if (rawOptions.knowledgeProposalSource !== void 0 || rawOptions.improvementProposalSource !== void 0) throw new Error("measured agent improvement analysis must not run proposal sources");
+	if (rawOptions.onEvent !== void 0 || rawOptions.log !== void 0) throw new Error("measured agent improvement analysis must not run callbacks");
+	const analysis = await runAnalystLoop({
+		...options,
+		runId,
+		...costLedger ? {
+			costLedger,
+			costPhase: "profile-improvement-analysis"
+		} : {},
+		...signal ? { signal } : {}
+	});
+	if (costLedger) assertAnalysisCostRecorded(analysis, costLedger);
+	return {
+		analysis,
+		findings: [...assertNoJudgeVerdict(analysis.analystResult.findings, "agent improvement findings")]
+	};
+}
+function completeAnalysisAccounting(analysis) {
+	const analysisCost = analysis.analystResult.total_cost_provenance;
+	if (!analysisCost || analysisCost.kind === "uncaptured") throw new Error("agent improvement analysis cost is uncaptured");
+	if (!Number.isFinite(analysis.analystResult.total_cost_usd) || analysis.analystResult.total_cost_usd < 0) throw new Error("agent improvement analysis cost must be finite and non-negative");
+	if (analysisCost.usd !== analysis.analystResult.total_cost_usd) throw new Error("agent improvement analysis cost does not match its provenance");
+	if (!Number.isFinite(analysis.durationMs) || analysis.durationMs < 0) throw new Error("agent improvement analysis duration must be finite and non-negative");
+	return {
+		costUsd: analysis.analystResult.total_cost_usd,
+		durationMs: analysis.durationMs
+	};
+}
+function assertAnalysisCostRecorded(analysis, costLedger) {
+	const reported = completeAnalysisAccounting(analysis);
+	const summary = costLedger.summary();
+	if (!summary.accountingComplete || summary.costProvenance.kind === "uncaptured") throw new Error("agent improvement analysis cost is incomplete in the shared account");
+	const analysisCost = analysis.analystResult.total_cost_provenance;
+	if (!analysisCost || analysisCost.kind === "uncaptured") throw new Error("agent improvement analysis cost is uncaptured");
+	if (!numbersApproximatelyEqual(summary.totalCostUsd, reported.costUsd) || summary.costProvenance.kind !== analysisCost.kind) throw new Error("agent improvement analysis cost does not match the shared account");
+}
+function createProfileImprovementCostLedger(budgetUsd) {
+	if (!Number.isFinite(budgetUsd) || budgetUsd < 0) throw new Error("profile improvement budgetUsd must be a non-negative finite number");
+	return new CostLedger({ costCeilingUsd: budgetUsd });
+}
+function profilePolicyWithBudget(policy, budgetUsd) {
+	if (policy.budgetUsd !== void 0 && !numbersApproximatelyEqual(policy.budgetUsd, budgetUsd)) throw new Error("profile improvement policy budgetUsd must equal the run budgetUsd");
+	return {
+		...policy,
+		budgetUsd
+	};
+}
+function profilePreparationAccounting(costLedger, startedAt) {
+	const summary = costLedger.summary();
+	if (!summary.accountingComplete || summary.costProvenance.kind === "uncaptured") throw new Error("profile improvement preparation cost is incomplete");
+	return {
+		wallDurationMs: Math.max(0, performance.now() - startedAt),
+		cost: {
+			usd: summary.costProvenance.usd,
+			provenance: summary.costProvenance.kind
+		}
+	};
+}
+function completeImprovementSearchAccounting(analysis, improvement) {
+	if (!improvement.cost.accountingComplete) throw new Error(`agent improvement optimization cost is incomplete: ${improvement.cost.incompleteReasons.join(", ") || "unspecified"}`);
+	if (!Number.isFinite(improvement.cost.totalCostUsd) || improvement.cost.totalCostUsd < 0) throw new Error("agent improvement optimization cost must be finite and non-negative");
+	if (!Number.isFinite(improvement.durationMs) || improvement.durationMs < 0) throw new Error("agent improvement optimization duration must be finite and non-negative");
+	return {
+		searchCostUsd: analysis.costUsd + improvement.cost.totalCostUsd,
+		searchDurationMs: analysis.durationMs + improvement.durationMs
+	};
+}
+function profileStateDigest(stateDigest, identity, profile) {
+	return agentProfileImprovementArmSchema.parse({ stateDigest: stateDigest({
+		identity,
+		profile
+	}) }).stateDigest;
+}
+function sealProfileImprovementBenchmark(input) {
+	const tasks = input.tasks.map((task) => sealAgentProfileImprovementTask(task));
+	return sealAgentProfileImprovementSuite({
+		splitDigest: campaignSplitDigestFromIdentities(tasks.map(profileTaskScenarioIdentity), input.reps),
+		tasks,
+		reps: input.reps,
+		seeds: input.seeds
+	});
+}
+function profileTaskScenarioIdentity(task) {
+	return {
+		id: task.scenario.id,
+		kind: task.scenario.kind,
+		scenarioDigest: task.scenario.digest
+	};
+}
+function assertReleaseSplitIsFresh(heldOutSplitDigest, improvement) {
+	const consumedSplits = [improvement.lineage.developmentSplitDigest];
+	if (improvement.mode === "method") {
+		const finalTestSplitDigest = improvement.lineage.finalTestSplitDigest;
+		if (!finalTestSplitDigest) throw new Error("method improvement does not retain its final-test split digest");
+		consumedSplits.push(finalTestSplitDigest);
+	}
+	if (consumedSplits.includes(heldOutSplitDigest)) throw new Error("release benchmark reuses an optimizer development or final-test split");
+}
+function assertReleaseScenariosAreFresh(improvement, heldOutScenarios) {
+	const optimizerScenarios = /* @__PURE__ */ new Map();
+	for (const [partition, scenarios] of [
+		["train", improvement.lineage.scenarioPartitions.train],
+		["selection", improvement.lineage.scenarioPartitions.selection],
+		["final-test", improvement.lineage.scenarioPartitions.finalTest]
+	]) for (const scenario of scenarios) optimizerScenarios.set(canonicalCandidateDigest$1(scenario), partition);
+	const reused = heldOutScenarios.filter((scenario) => optimizerScenarios.has(canonicalCandidateDigest$1(scenario))).map((scenario) => `${scenario.id} (${optimizerScenarios.get(canonicalCandidateDigest$1(scenario))})`);
+	if (reused.length > 0) throw new Error(`release benchmark reuses optimizer scenario(s): [${reused.join(", ")}]`);
+}
+function assertCandidateReleaseWorkIsFresh(experiment, improvement) {
+	for (const splitDigest of new Set(experiment.benchmark.tasks.map((task) => task.benchmark.splitDigest))) assertReleaseSplitIsFresh(splitDigest, improvement);
+	if (improvement.mode !== "method") return;
+	assertReleaseScenariosAreFresh(improvement, experiment.benchmark.tasks.map((task) => task.scenario));
+}
+function assertProfileReleaseWorkIsFresh(benchmark, improvement) {
+	assertReleaseSplitIsFresh(benchmark.suite.splitDigest, improvement);
+	assertReleaseScenariosAreFresh(improvement, benchmark.tasks.map(profileTaskScenarioIdentity));
+}
+function profileImprovementMetadata(metadata, source, optimizationReceipt) {
+	assertNoCallerOptimizationReceipt(metadata);
+	if (metadata && Object.hasOwn(metadata, AGENT_IMPROVEMENT_SOURCE_METADATA_KEY)) throw new Error(`candidate metadata reserves '${AGENT_IMPROVEMENT_SOURCE_METADATA_KEY}' for Runtime`);
+	const sourceMetadata = agentImprovementSourceMetadata(source);
+	const merged = {
+		...metadata ?? {},
+		...sourceMetadata
+	};
+	return optimizationReceipt ? attachOptimizationActivationReceipt(merged, optimizationReceipt) : immutableCandidateValue(merged);
+}
+/**
+* Analyze a product-owned profile, search one profile surface, then run the
+* exact baseline and candidate through the product executor before proposing.
+*/
+async function proposeAgentProfileImprovement(options) {
+	const source = agentImprovementSourceSchema.parse(options.source);
+	if (!isAgentProfileMeasuredSurface(options.improvement.surface ?? "prompt")) throw new Error("measured profile improvement supports prompt or skills; use the sealed-candidate path for this surface");
+	const costLedger = createProfileImprovementCostLedger(options.budgetUsd);
+	const preparationStartedAt = performance.now();
+	const profile = parseExactAgentProfile(options.profile, "profile improvement source");
+	const baselineStateDigest = profileStateDigest(options.stateDigest, source.sourceIdentity, profile);
+	if (baselineStateDigest !== source.sourceDigest) throw new Error("profile improvement source digest does not match the measured profile state");
+	const policy = profilePolicyWithBudget(options.benchmark.policy, options.budgetUsd);
+	if (options.improvement.costCeiling !== void 0 && !numbersApproximatelyEqual(options.improvement.costCeiling, options.budgetUsd)) throw new Error("profile improvement costCeiling must equal the run budgetUsd");
+	const { analysis, findings } = await analyzeAgentImprovement(options.runId, options.analysis, costLedger, options.signal);
+	const improvement = await improve(profile, {
+		...options.improvement,
+		executionRef: options.executor.executionRef.digest,
+		agent: options.executor.optimize,
+		costLedger,
+		costCeiling: options.budgetUsd,
+		findings: [...options.improvement.findings ?? [], ...findings]
+	});
+	try {
+		if (improvement.decision !== "ship") throw new Error("agent profile improvement search did not produce a promotable candidate");
+		const candidateProfile = parseExactAgentProfile(improvement.candidate.profile, "profile improvement candidate");
+		const candidateStateDigest = profileStateDigest(options.stateDigest, source.sourceIdentity, candidateProfile);
+		if (candidateStateDigest === baselineStateDigest) throw new Error("profile improvement candidate state digest matches the baseline");
+		const change = agentImprovementProfileDiffs(profile, candidateProfile, {
+			id: `profile-improvement:${candidateStateDigest}`,
+			metadata: {
+				sourceIdentity: source.sourceIdentity,
+				sourceRevision: source.sourceRevision
+			}
+		});
+		const profileDiffIds = change.map((step) => {
+			if (!step.id) throw new Error("profile improvement change requires an exact diff id");
+			return step.id;
+		});
+		const benchmark = sealProfileImprovementBenchmark({
+			...options.benchmark,
+			policy
+		});
+		assertProfileReleaseWorkIsFresh(benchmark, improvement);
+		const experiment = sealAgentProfileImprovementExperiment({
+			kind: "agent-profile-improvement-experiment",
+			digestAlgorithm: "rfc8785-sha256",
+			source,
+			executionRef: options.executor.executionRef,
+			baseline: { stateDigest: baselineStateDigest },
+			candidate: { stateDigest: candidateStateDigest },
+			change,
+			candidateLineage: {
+				source: "optimizer",
+				parentDigests: [source.sourceDigest],
+				runIds: [improvement.lineage.runId],
+				profileDiffIds,
+				developmentSplitDigest: improvement.lineage.developmentSplitDigest
+			},
+			benchmark,
+			policy
+		});
+		const profilesByStateDigest = /* @__PURE__ */ new Map([[baselineStateDigest, profile], [candidateStateDigest, candidateProfile]]);
+		const preparation = profilePreparationAccounting(costLedger, preparationStartedAt);
+		const run = await runAgentProfileImprovementExperiment({
+			experiment,
+			...options.maxConcurrency === void 0 ? {} : { maxConcurrency: options.maxConcurrency },
+			costLedger,
+			...options.signal ? { signal: options.signal } : {},
+			execute: async (input) => {
+				const measuredProfile = profilesByStateDigest.get(input.stateDigest);
+				if (!measuredProfile) throw new Error("profile improvement execution requested an unknown profile state");
+				return options.executor.measure({
+					...input,
+					profile: measuredProfile
+				});
+			}
+		});
+		const optimizationReceipt = createOptimizationActivationReceipt(improvement);
+		const evaluation = verifyAgentProfileImprovementExperimentComparison(measuredComparisonFromAgentProfileImprovementExperiment({
+			experiment,
+			measurements: run.measurements,
+			runId: options.runId,
+			...options.candidate ? { candidate: options.candidate } : {},
+			generationsExplored: improvement.generationsExplored ?? 0,
+			preparation,
+			measurement: run.measurement,
+			metadata: profileImprovementMetadata(options.metadata, source, optimizationReceipt)
+		}));
+		const proposal = createAgentImprovementProposal({
+			runId: options.runId,
+			findings,
+			evaluation,
+			...options.now ? { now: options.now } : {}
+		});
+		return {
+			analysis,
+			improvement,
+			experiment,
+			measurements: run.measurements,
+			proposal
+		};
+	} catch (cause) {
+		return rethrowAfterCleanup(cause, () => improvement.dispose(), "proposeAgentProfileImprovement failed");
+	}
+}
 /** Analyze, search, then remeasure the resulting exact candidate before proposing it. */
 async function proposeAgentImprovement(options) {
 	assertNoCallerOptimizationReceipt(options.metadata);
-	const analysis = await runAnalystLoop({
-		...options.analysis,
-		runId: options.runId
-	});
-	const findings = assertNoJudgeVerdict(analysis.analystResult.findings, "proposeAgentImprovement findings");
+	const { analysis, findings } = await analyzeAgentImprovement(options.runId, options.analysis);
+	const analysisAccounting = completeAnalysisAccounting(analysis);
 	const improvementInput = {
 		...options.improvement,
 		findings: [...options.improvement.findings ?? [], ...findings]
@@ -2412,6 +2724,14 @@ async function proposeAgentImprovement(options) {
 	const improvement = improvementInput.surface === "code" ? await improve(improvementInput) : await improve(options.profile, improvementInput);
 	try {
 		if (improvement.decision !== "ship") throw new Error("agent improvement search did not produce a promotable candidate");
+		const searchAccounting = completeImprovementSearchAccounting(analysisAccounting, improvement);
+		const preparation = {
+			wallDurationMs: searchAccounting.searchDurationMs,
+			cost: {
+				usd: searchAccounting.searchCostUsd,
+				provenance: "estimated"
+			}
+		};
 		const optimizationReceipt = improvement.mode === "method" ? createOptimizationActivationReceipt(improvement) : void 0;
 		const experiment = sealAgentImprovementExperiment(await options.buildExperiment({
 			analysis,
@@ -2428,8 +2748,7 @@ async function proposeAgentImprovement(options) {
 			...options.candidate ? { candidate: options.candidate } : {},
 			...optimizationReceipt ? { metadata: attachOptimizationActivationReceipt(options.metadata, optimizationReceipt) } : options.metadata ? { metadata: options.metadata } : {},
 			...improvement.generationsExplored === void 0 ? {} : { generationsExplored: improvement.generationsExplored },
-			searchDurationMs: improvement.durationMs,
-			searchCostUsd: improvement.cost.totalCostUsd
+			preparation
 		});
 		const proposal = createAgentImprovementProposal({
 			runId: options.runId,
@@ -2504,12 +2823,14 @@ function createAgentImprovementActivation(inputProposal, inputReview, options) {
 	const authorizedAt = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
 	if (Date.parse(authorizedAt) < Date.parse(review.reviewedAt)) throw new Error("candidate activation cannot predate its approval");
 	const targets = buildAgentImprovementActivationTargets(proposal.changedSurfaces, experiment, options.intent, options.targets);
+	const executionRef = profileActivationExecutionRef(experiment, targets, options.executionRef);
 	return agentImprovementActivationSchema.parse(canonicalCandidateDocument({
 		kind: "agent-improvement-activation",
 		proposalDigest: proposal.digest,
 		reviewDigest: review.digest,
 		experimentDigest: experiment.digest,
 		candidateDigest: measuredCandidateDigest(proposal),
+		...executionRef ? { executionRef } : {},
 		intent: options.intent,
 		targets,
 		fundingOwner: options.fundingOwner,
@@ -2534,6 +2855,17 @@ function requireSealedCandidateExperiment(proposal) {
 function measuredCandidateDigest(proposal) {
 	return proposal.evaluation.kind === "agent-profile-improvement-measured-comparison" ? proposal.evaluation.experiment.candidate.stateDigest : proposal.evaluation.experiment.candidate.digest;
 }
+function profileActivationExecutionRef(experiment, targets, executionRef) {
+	if (!targets.some((target) => target.surface === "agent-profile")) {
+		if (executionRef !== void 0) throw new Error("profile activation executionRef is valid only for agent-profile targets");
+		return;
+	}
+	if (experiment.kind !== "agent-profile-improvement-experiment") throw new Error("agent-profile activation requires a measured profile experiment");
+	if (executionRef === void 0) throw new Error("profile improvement activation requires the measured executor");
+	const parsed = agentProfileImprovementExecutionRefSchema.parse(executionRef);
+	if (canonicalCandidateDigest$1(parsed) !== canonicalCandidateDigest$1(experiment.executionRef)) throw new Error("profile improvement activation executor does not match the measurement");
+	return parsed;
+}
 function validateShippableAgentImprovementEvaluation(input, runId, subject) {
 	const evaluation = verifyAgentImprovementEvaluation(input);
 	if (evaluation.decision.outcome !== "ship") throw new Error(`${subject} requires a passing experiment`);
@@ -2565,6 +2897,7 @@ function verifyAgentImprovementActivation(input) {
 	const activation = verifyCanonicalCandidateDocument(agentImprovementActivationSchema.parse(input.activation), "agent improvement activation");
 	const experiment = proposal.evaluation.experiment;
 	if (review.decision !== "approve" || review.proposalDigest !== proposal.digest || activation.proposalDigest !== proposal.digest || activation.reviewDigest !== review.digest || activation.experimentDigest !== experiment.digest || activation.candidateDigest !== measuredCandidateDigest(proposal) || Date.parse(review.reviewedAt) < Date.parse(proposal.proposedAt) || Date.parse(activation.authorizedAt) < Date.parse(review.reviewedAt)) throw new Error("candidate activation does not bind the measured and approved candidate");
+	if (activation.targets.some((target) => target.surface === "agent-profile") && (proposal.evaluation.kind !== "agent-profile-improvement-measured-comparison" || activation.executionRef === void 0 || canonicalCandidateDigest$1(activation.executionRef) !== canonicalCandidateDigest$1(proposal.evaluation.experiment.executionRef))) throw new Error("profile activation does not bind the measured executor");
 	assertAgentImprovementActivationTargets(proposal.changedSurfaces, experiment, activation.intent, activation.targets);
 	return activation;
 }
@@ -2619,6 +2952,6 @@ function assertNoJudgeDerivedProposalFindings(findings) {
 	throw new Error(`agent improvement proposal findings: judge-derived findings cannot steer an improvement: [${identifiers.join(", ")}]`);
 }
 //#endregion
-export { applyRolloutPolicyToProfile as A, commandVerifier as B, assertProfileImprovementTargetsShareIdentity as C, withMethodRuntimeControls as D, improve as E, LIFTED_FINDING_ANALYST_ID as F, worktreeChangedPaths as G, rawTraceEvidenceProblem as H, isAnalystFinding as I, toAnalystFindings as L, parseRolloutPolicy as M, serializeRolloutPolicy as N, rawTraceDistiller as O, structuralRolloutPolicyFromProfile as P, AGENTIC_PROFILE_RESOURCE_ROOT as R, agentProfileImprovementStateDigest as S, isAgentImprovementProfileSurface as T, requiresRawTraceEvidence as U, defaultBuildPrompt as V, summarizeFindings as W, agentImprovementProfileSurfaceDigest as _, executeAgentCandidateExperimentCell as a, agentImprovementTargetInput as b, reviewAgentImprovementProposal as c, verifyAgentImprovementProposal as d, verifyAgentImprovementReview as f, AGENT_IMPROVEMENT_PROFILE_SURFACES as g, optimizationActivationReceiptFromMetadata as h, createAgentImprovementProposal as i, normalizeRolloutPolicy as j, ROLLOUT_POLICY_EXTENSION as k, runAgentCandidateExperiment as l, createOptimizationActivationReceipt as m, createAgentImprovementActivation as n, proposeAgentImprovement as o, verifyCandidateExecutionEvidence as p, createAgentImprovementMeasuredComparison as r, requireSealedCandidateExperiment as s, AgentCandidateExperimentCellExecutionError as t, verifyAgentImprovementActivation as u, agentImprovementProfileSurfaceInput as v, buildAgentImprovementActivationTargets as w, agentImprovementTargetProfileDiffs as x, agentImprovementTargetDigest as y, agenticGenerator as z };
+export { improve as A, isAnalystFinding as B, agentImprovementTargetInput as C, buildAgentImprovementActivationTargets as D, assertProfileImprovementTargetsShareIdentity as E, normalizeRolloutPolicy as F, defaultBuildPrompt as G, AGENTIC_PROFILE_RESOURCE_ROOT as H, parseRolloutPolicy as I, summarizeFindings as J, rawTraceEvidenceProblem as K, serializeRolloutPolicy as L, rawTraceDistiller as M, ROLLOUT_POLICY_EXTENSION as N, isAgentImprovementProfileSurface as O, applyRolloutPolicyToProfile as P, structuralRolloutPolicyFromProfile as R, agentImprovementTargetDigest as S, agentProfileImprovementStateDigest as T, agenticGenerator as U, toAnalystFindings as V, commandVerifier as W, worktreeChangedPaths as Y, AGENT_IMPROVEMENT_PROFILE_SURFACES as _, executeAgentCandidateExperimentCell as a, agentImprovementProfileSurfaceDigest as b, requireSealedCandidateExperiment as c, verifyAgentImprovementActivation as d, verifyAgentImprovementProposal as f, optimizationActivationReceiptFromMetadata as g, createOptimizationActivationReceipt as h, createAgentImprovementProposal as i, withMethodRuntimeControls as j, isAgentProfileMeasuredSurface as k, reviewAgentImprovementProposal as l, verifyCandidateExecutionEvidence as m, createAgentImprovementActivation as n, proposeAgentImprovement as o, verifyAgentImprovementReview as p, requiresRawTraceEvidence as q, createAgentImprovementMeasuredComparison as r, proposeAgentProfileImprovement as s, AgentCandidateExperimentCellExecutionError as t, runAgentCandidateExperiment as u, AGENT_PROFILE_MEASURED_SURFACES as v, agentImprovementTargetProfileDiffs as w, agentImprovementProfileSurfaceInput as x, agentImprovementProfileDiffs as y, LIFTED_FINDING_ANALYST_ID as z };
 
-//# sourceMappingURL=improvement-cycle-C095kS_g.js.map
+//# sourceMappingURL=improvement-cycle-Ulvvbg5p.js.map