@tangle-network/agent-runtime 0.337.2 → 0.339.0

package/dist/activation-CVSFxis9.js

@@ -0,0 +1,876 @@
+import { a as defaultStructuralRolloutPolicy } from "./structural-rollout-DpLCXzaL.js";
+import { B as omitTopLevelDigest, F as canonicalCandidateDigest$1, H as verifyCanonicalCandidateDocument, I as canonicalCandidateDocument, z as immutableCandidateValue } from "./sandbox-profile-compat-BzVBFqrz.js";
+import { a as applyExactAgentProfileDiff, g as omitUndefinedObjectFields, i as agentCandidateProfileAsAgentProfile, v as parseExactAgentProfile } from "./profile-Dpei_Sq0.js";
+import { agentImprovementActivationResultSchema, agentImprovementActivationSchema, agentImprovementProposalSchema, agentImprovementReviewSchema, agentProfileDiffSchema, agentProfileImprovementExecutionRefSchema, agentProfileImprovementExperimentSchema, agentProfileModelHintsSchema, agentProfileSchema, canonicalAgentProfileDigest, changedProfileImprovementSurfaces, defineAgentProfileDiff, diffAgentProfiles } from "@tangle-network/agent-interface";
+import { assertProposalFindings } from "@tangle-network/agent-eval/analyst";
+import { campaignSplitDigestFromIdentities } from "@tangle-network/agent-eval/campaign";
+import { verifyAgentProfileImprovementExperimentComparison, verifyCandidateExperimentComparison } from "@tangle-network/agent-eval/contract";
+//#region src/improvement/rollout-policy.ts
+/** The profile extensions namespace the policy persists under. */
+const ROLLOUT_POLICY_EXTENSION = "structural-rollout";
+const isBoundedInt = (v, min) => typeof v === "number" && Number.isInteger(v) && v >= min;
+/** Normalize an untyped policy bag (a parsed surface or a profile extension) into
+*  a full `StructuralRolloutPolicy`, defaults merged. Returns `undefined` when any
+*  present dial violates the policy invariants (mirrors `resolvePolicy`: integer
+*  k ≥ 1, repairRounds ≥ 0, testgen ≥ 0) — a corrupt config must read as "not
+*  configured", never as a fabricated recipe. */
+function normalizeRolloutPolicy(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+	const bag = raw;
+	const k = bag.k ?? defaultStructuralRolloutPolicy.k;
+	const repairRounds = bag.repairRounds ?? defaultStructuralRolloutPolicy.repairRounds;
+	const testgen = bag.testgen ?? defaultStructuralRolloutPolicy.testgen;
+	if (!isBoundedInt(k, 1) || !isBoundedInt(repairRounds, 0) || !isBoundedInt(testgen, 0)) return;
+	return {
+		k,
+		repairRounds,
+		testgen,
+		...typeof bag.diverse === "boolean" ? { diverse: bag.diverse } : {}
+	};
+}
+/** Stable serialization with fixed field order. */
+function serializeRolloutPolicy(policy) {
+	return JSON.stringify({
+		k: policy.k,
+		repairRounds: policy.repairRounds,
+		testgen: policy.testgen,
+		...policy.diverse !== void 0 ? { diverse: policy.diverse } : {}
+	});
+}
+/** Read the persisted policy off the profile. `undefined` when the profile does
+*  not opt into structural rollout. */
+function structuralRolloutPolicyFromProfile(profile) {
+	const bag = profile.extensions?.[ROLLOUT_POLICY_EXTENSION];
+	if (bag === void 0) return void 0;
+	return normalizeRolloutPolicy(bag);
+}
+/** Persist a detached policy under the profile extension without mutating the input. */
+function applyRolloutPolicyToProfile(profile, policy) {
+	const candidate = structuredClone(profile);
+	const bag = {
+		k: policy.k,
+		repairRounds: policy.repairRounds,
+		testgen: policy.testgen,
+		...policy.diverse !== void 0 ? { diverse: policy.diverse } : {}
+	};
+	return {
+		...candidate,
+		extensions: {
+			...candidate.extensions,
+			[ROLLOUT_POLICY_EXTENSION]: bag
+		}
+	};
+}
+//#endregion
+//#region src/intelligence/improvement-surfaces.ts
+const changedSurfaceOrder = [
+	"prompt",
+	"skills",
+	"tools",
+	"mcp",
+	"hooks",
+	"subagents",
+	"agent-profile",
+	"memory",
+	"code",
+	"knowledge",
+	"rollout-policy"
+];
+/** Agent improvement surfaces delivered as exact `AgentProfileDiff` replacements. */
+const AGENT_IMPROVEMENT_PROFILE_SURFACES = [
+	"prompt",
+	"skills",
+	"tools",
+	"mcp",
+	"hooks",
+	"subagents"
+];
+/**
+* Profile changes eligible for the product-owned measured comparison path.
+* The six directly deliverable profile surfaces retain their granular labels;
+* any residual profile axis also adds the complete `agent-profile` surface.
+*/
+const AGENT_PROFILE_MEASURED_SURFACES = [...AGENT_IMPROVEMENT_PROFILE_SURFACES, "agent-profile"];
+function deriveChangedSurfaces(baselineBundle, candidateBundle) {
+	if (baselineBundle.knowledge || candidateBundle.knowledge) assertKnowledgeCandidatePair(baselineBundle, candidateBundle);
+	assertCodeCandidatePair(baselineBundle, candidateBundle);
+	const baseline = improvementSurfaceValues(baselineBundle);
+	const candidate = improvementSurfaceValues(candidateBundle);
+	const changed = changedSurfaceOrder.filter((surface) => canonicalCandidateDigest$1(baseline[surface]) !== canonicalCandidateDigest$1(candidate[surface]));
+	if (changed.length === 0) throw new Error("candidate experiment does not change an agent surface");
+	return changed;
+}
+function assertAgentImprovementActivationTargets(surfaces, experiment, intent, targets) {
+	if (isProfileImprovementExperiment(experiment)) assertProfileImprovementTargetsShareIdentity(targets);
+	const expected = new Set(surfaces);
+	const actual = new Set(targets.map((target) => target.surface));
+	const sourceArm = intent === "activate-candidate" ? "baseline" : "candidate";
+	if (!(isProfileImprovementExperiment(experiment) ? sameAgentImprovementSurfaceSet(surfaces, activationExperimentChangedSurfaces(experiment)) : sameOrderedSurfaces(surfaces, activationExperimentChangedSurfaces(experiment))) || targets.some((target) => !target.identity.trim()) || targets.some((target) => target.expectedBaseDigest !== activationTargetDigest(experiment, sourceArm, target.surface)) || targets.length !== surfaces.length || expected.size !== actual.size || [...expected].some((surface) => !actual.has(surface))) throw new Error("agent improvement activation targets must cover exactly the changed surfaces");
+}
+/** One opaque profile-state transition can change only one complete profile record. */
+function assertProfileImprovementTargetsShareIdentity(targets) {
+	if (new Set(targets.map((target) => target.identity)).size !== 1) throw new Error("profile improvement activation targets must name one profile identity");
+}
+/** Bind caller-owned target identities to the exact source state Runtime measured. */
+function buildAgentImprovementActivationTargets(surfaces, experiment, intent, identities) {
+	const sourceArm = intent === "activate-candidate" ? "baseline" : "candidate";
+	const targets = identities.map((target) => ({
+		...target,
+		expectedBaseDigest: activationTargetDigest(experiment, sourceArm, target.surface)
+	}));
+	assertAgentImprovementActivationTargets(surfaces, experiment, intent, targets);
+	return targets;
+}
+/** Exact host-owned profile state for every changed profile surface. */
+function agentProfileImprovementStateDigest(experiment, arm) {
+	return experiment[arm].stateDigest;
+}
+/** 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) => isAgentProfileMeasuredSurface(surface))) throw new Error("profile improvement experiment does not change a supported surface");
+	return surfaces;
+}
+function agentImprovementTargetDigest(experiment, arm, surface) {
+	if (surface === "knowledge") {
+		const knowledge = assertKnowledgeCandidatePair(experiment.baseline, experiment.candidate);
+		return arm === "baseline" ? knowledge.candidate.baseHash : knowledge.candidate.candidateHash;
+	}
+	if (surface === "code") assertCodeCandidatePair(experiment.baseline, experiment.candidate);
+	return canonicalCandidateDigest$1(improvementSurfaceValues(experiment[arm])[surface]);
+}
+function agentImprovementTargetInput(bundle, surface) {
+	return improvementSurfaceValues(bundle)[surface];
+}
+function activationTargetDigest(experiment, arm, surface) {
+	if (isProfileImprovementExperiment(experiment)) {
+		if (!activationExperimentChangedSurfaces(experiment).includes(surface)) throw new Error("profile improvement activation targets an unchanged surface");
+		return agentProfileImprovementStateDigest(experiment, arm);
+	}
+	return agentImprovementTargetDigest(experiment, arm, surface);
+}
+function activationExperimentChangedSurfaces(experiment) {
+	if (!isProfileImprovementExperiment(experiment)) return deriveChangedSurfaces(experiment.baseline, experiment.candidate);
+	return profileImprovementChangedSurfaces(experiment.change);
+}
+function isProfileImprovementExperiment(experiment) {
+	return experiment.kind === "agent-profile-improvement-experiment";
+}
+function sameOrderedSurfaces(left, right) {
+	return left.length === right.length && left.every((surface, index) => surface === right[index]);
+}
+/** Profile-change surface order is presentation only; its measured contract is set-based. */
+function sameAgentImprovementSurfaceSet(left, right) {
+	return left.length === right.length && left.every((surface) => right.includes(surface));
+}
+/** Return whether a measured surface can be delivered through an agent profile. */
+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.
+* Unrelated profile fields are excluded. The result matches `agentImprovementTargetInput` for the
+* same profile inside a candidate bundle.
+*/
+function agentImprovementProfileSurfaceInput(profile, surface) {
+	return immutableCandidateValue(profileSurfaceInput(parseExactAgentProfile(omitUndefinedObjectFields(profile, "agent improvement profile"), "agent improvement profile"), surface));
+}
+function profileSurfaceInput(profile, surface) {
+	switch (surface) {
+		case "prompt": return { prompt: profile.prompt ?? null };
+		case "skills": return profile.resources?.skills ?? null;
+		case "tools": return {
+			tools: profile.tools ?? null,
+			resources: profile.resources?.tools ?? null
+		};
+		case "mcp": return profile.mcp ?? null;
+		case "hooks": return profile.hooks ?? null;
+		case "subagents": return {
+			subagents: profile.subagents ?? null,
+			resources: profile.resources?.agents ?? null
+		};
+	}
+}
+/** Return the `Sha256Digest` of one profile surface using Runtime's canonical candidate digest. */
+function agentImprovementProfileSurfaceDigest(profile, surface) {
+	return canonicalCandidateDigest$1(agentImprovementProfileSurfaceInput(profile, surface));
+}
+/**
+* Replace one measured profile surface exactly, including array-valued resources.
+* Apply the returned diffs in order: a diff applies its set before its removal,
+* so exact replacement requires a reset record followed by a set record.
+*/
+function agentImprovementTargetProfileDiffs(target, options) {
+	const { remove, set } = improvementSurfaceReplacement(target);
+	const common = {
+		kind: "agent-profile-diff",
+		...options.source ? { source: options.source } : {},
+		metadata: {
+			...options.metadata ?? {},
+			surface: target.surface
+		}
+	};
+	const reset = agentProfileDiffSchema.parse(defineAgentProfileDiff({
+		...common,
+		id: `${options.id}:${target.surface}:reset`,
+		title: `Replace active ${target.surface}`,
+		remove
+	}));
+	if (!set) return [reset];
+	return [reset, agentProfileDiffSchema.parse(defineAgentProfileDiff({
+		...common,
+		id: `${options.id}:${target.surface}:set`,
+		title: `Activate measured ${target.surface}`,
+		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");
+	if (canonicalAgentProfileDigest(baseline) === canonicalAgentProfileDigest(candidate)) throw new Error("profile improvement candidate does not change the profile");
+	const completeChanges = completeAgentProfileReplacementDiffs(baseline, candidate, options);
+	if (canonicalAgentProfileDigest(completeChanges.reduce((profile, change) => applyExactAgentProfileDiff(profile, change, "complete profile improvement candidate change"), baseline)) !== canonicalAgentProfileDigest(candidate)) throw new Error("complete profile improvement change did not reproduce the candidate");
+	return completeChanges;
+}
+function completeAgentProfileReplacementDiffs(baseline, candidate, options) {
+	const [first, ...rest] = diffAgentProfiles(baseline, candidate).map((change) => {
+		const reset = change.remove !== void 0;
+		return agentProfileDiffSchema.parse({
+			...change,
+			...options.source ? { source: options.source } : {},
+			metadata: {
+				...options.metadata ?? {},
+				surface: "agent-profile"
+			},
+			id: `${options.id}:agent-profile:${reset ? "reset" : "set"}`,
+			title: reset ? "Reset changed agent profile fields" : "Set changed agent profile fields"
+		});
+	});
+	if (!first) throw new Error("complete profile differ found no changed fields");
+	return [first, ...rest];
+}
+function improvementSurfaceReplacement(target) {
+	const value = target.desiredInput;
+	switch (target.surface) {
+		case "prompt": {
+			const prompt = exactObject(value, ["prompt"], "prompt activation input").prompt;
+			assertDefined(prompt, "prompt activation input.prompt");
+			return {
+				remove: { prompt: true },
+				...prompt === null ? {} : { set: parseProfileSet({ prompt }) }
+			};
+		}
+		case "skills":
+			assertDefined(value, "skills activation input");
+			return {
+				remove: { resources: { skills: true } },
+				...value === null ? {} : { set: parseProfileSet({ resources: { skills: value } }) }
+			};
+		case "tools": {
+			const parsed = exactObject(value, ["tools", "resources"], "tools activation input");
+			assertDefined(parsed.tools, "tools activation input.tools");
+			assertDefined(parsed.resources, "tools activation input.resources");
+			const set = {
+				...parsed.tools === null ? {} : { tools: parsed.tools },
+				...parsed.resources === null ? {} : { resources: { tools: parsed.resources } }
+			};
+			return {
+				remove: {
+					tools: true,
+					resources: { tools: true }
+				},
+				...Object.keys(set).length === 0 ? {} : { set: parseProfileSet(set) }
+			};
+		}
+		case "mcp":
+			assertDefined(value, "mcp activation input");
+			return {
+				remove: { mcp: true },
+				...value === null ? {} : { set: parseProfileSet({ mcp: value }) }
+			};
+		case "hooks":
+			assertDefined(value, "hooks activation input");
+			return {
+				remove: { hooks: true },
+				...value === null ? {} : { set: parseProfileSet({ hooks: value }) }
+			};
+		case "subagents": {
+			const parsed = exactObject(value, ["subagents", "resources"], "subagents activation input");
+			assertDefined(parsed.subagents, "subagents activation input.subagents");
+			assertDefined(parsed.resources, "subagents activation input.resources");
+			const set = {
+				...parsed.subagents === null ? {} : { subagents: parsed.subagents },
+				...parsed.resources === null ? {} : { resources: { agents: parsed.resources } }
+			};
+			return {
+				remove: {
+					subagents: true,
+					resources: { agents: true }
+				},
+				...Object.keys(set).length === 0 ? {} : { set: parseProfileSet(set) }
+			};
+		}
+	}
+}
+function assertDefined(value, label) {
+	if (value === void 0) throw new Error(`${label} must not be undefined`);
+}
+function exactObject(value, keys, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
+	const record = value;
+	const actual = Object.keys(record).sort();
+	const expected = [...keys].sort();
+	if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) throw new Error(`${label} must contain exactly: ${expected.join(", ")}`);
+	return record;
+}
+function parseProfileSet(value) {
+	return agentProfileSchema.parse(value);
+}
+function assertKnowledgeCandidatePair(baselineBundle, candidateBundle) {
+	const baseline = baselineBundle.knowledge;
+	const candidate = candidateBundle.knowledge;
+	if (!baseline && !candidate) throw new Error("knowledge candidate pair is not present");
+	if (!baseline || !candidate || canonicalCandidateDigest$1({
+		candidate: baseline.candidate,
+		evaluation: baseline.evaluation
+	}) !== canonicalCandidateDigest$1({
+		candidate: candidate.candidate,
+		evaluation: candidate.evaluation
+	})) throw new Error("knowledge experiment arms must share one measured candidate and evaluation identity");
+	return candidate;
+}
+function assertCodeCandidatePair(baselineBundle, candidateBundle) {
+	const baseline = baselineBundle.code;
+	const candidate = candidateBundle.code;
+	if (canonicalCandidateDigest$1(baseline) === canonicalCandidateDigest$1(candidate) || candidate.kind !== "git-patch") return;
+	const baselineTree = baseline.kind === "no-op" ? baseline.baseTree : baseline.kind === "git-patch" ? baseline.candidateTree : void 0;
+	const baselineRepository = baseline.kind === "disabled" ? void 0 : baseline.repository;
+	if (baselineTree !== candidate.baseTree || !baselineRepository || canonicalCandidateDigest$1(baselineRepository) !== canonicalCandidateDigest$1(candidate.repository)) throw new Error("code candidate must be based on the exact repository tree measured by the baseline arm");
+}
+function improvementSurfaceValues(bundle) {
+	const profile = agentCandidateProfileAsAgentProfile(bundle.profile);
+	return {
+		prompt: agentImprovementProfileSurfaceInput(profile, "prompt"),
+		skills: agentImprovementProfileSurfaceInput(profile, "skills"),
+		tools: agentImprovementProfileSurfaceInput(profile, "tools"),
+		mcp: agentImprovementProfileSurfaceInput(profile, "mcp"),
+		hooks: agentImprovementProfileSurfaceInput(profile, "hooks"),
+		subagents: agentImprovementProfileSurfaceInput(profile, "subagents"),
+		"agent-profile": {
+			profile: opaqueProfileSlice(profile),
+			execution: bundle.execution
+		},
+		memory: {
+			instructions: profile.resources?.instructions ?? null,
+			executionPolicy: bundle.memory
+		},
+		code: bundle.code,
+		knowledge: bundle.knowledge ?? null,
+		"rollout-policy": structuralRolloutPolicyFromProfile(profile) ?? null
+	};
+}
+function opaqueProfileSlice(profile) {
+	const { prompt: _prompt, tools: _tools, mcp: _mcp, hooks: _hooks, subagents: _subagents, extensions, resources, ...opaqueProfile } = profile;
+	const { [ROLLOUT_POLICY_EXTENSION]: _rolloutPolicy, ...opaqueExtensions } = extensions ?? {};
+	const { instructions: _instructions, skills: _skills, tools: _resourceTools, agents: _agents, ...opaqueResources } = resources ?? {};
+	return {
+		...opaqueProfile,
+		...Object.keys(opaqueExtensions).length > 0 ? { extensions: opaqueExtensions } : {},
+		...Object.keys(opaqueResources).length > 0 ? { resources: opaqueResources } : {}
+	};
+}
+//#endregion
+//#region src/intelligence/optimization-receipt.ts
+const optimizationReceiptMetadataKey = "optimizationReceipt";
+/** Build a detached receipt only for methods backed by an identified external optimizer. */
+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({
+		kind: "optimization-activation-receipt",
+		method: improvement.method,
+		source: provenance.source,
+		...provenance.bridge ? { bridge: provenance.bridge } : {},
+		...provenance.modules ? { modules: provenance.modules } : {},
+		...provenance.python ? { python: provenance.python } : {},
+		...candidateModel || optimizerModel ? { models: {
+			...candidateModel ? { candidate: candidateModel } : {},
+			...optimizerModel ? { optimizer: optimizerModel } : {}
+		} } : {},
+		usage: {
+			optimizerEvaluations: provenance.evaluationCount,
+			...provenance.tokenUsage ? { optimizerTokens: provenance.tokenUsage } : {}
+		},
+		cost: {
+			optimization: receiptCost(improvement.raw.optimizationCost),
+			finalTest: receiptCost(improvement.raw.testCost),
+			total: receiptCost(improvement.raw.totalCost)
+		},
+		invocation: {
+			runtimeInvocationId: improvement.lineage.invocationId,
+			optimizerRunId: provenance.runId,
+			...provenance.compatibleRunId ? { compatibleOptimizerRunId: provenance.compatibleRunId } : {},
+			resumed: provenance.resumed,
+			artifactDir: provenance.artifactDir
+		},
+		developmentDataDigest: improvement.lineage.developmentSplitDigest,
+		finalTestDataDigest,
+		scenarioPartitions: improvement.lineage.scenarioPartitions
+	}).value;
+}
+/** Add Runtime-owned optimizer evidence without aliasing caller metadata. */
+function attachOptimizationActivationReceipt(metadata, receipt) {
+	assertNoCallerOptimizationReceipt(metadata);
+	return immutableCandidateValue({
+		...metadata ?? {},
+		[optimizationReceiptMetadataKey]: receipt
+	});
+}
+function assertNoCallerOptimizationReceipt(metadata) {
+	if (metadata && Object.hasOwn(metadata, "optimizationReceipt")) throw new Error(`candidate metadata reserves '${optimizationReceiptMetadataKey}' for Runtime`);
+}
+/** Read and verify the optimizer evidence carried by a measured proposal. */
+function optimizationActivationReceiptFromMetadata(metadata) {
+	const value = metadata?.[optimizationReceiptMetadataKey];
+	if (value === void 0) return void 0;
+	return immutableCandidateValue(parseOptimizationActivationReceipt(value));
+}
+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.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));
+}
+function isModules(value) {
+	return value === void 0 || Array.isArray(value) && value.every((module) => isRecord(module) && isNonEmptyString(module.module) && typeof module.sourceSha256 === "string" && /^[0-9a-f]{64}$/.test(module.sourceSha256));
+}
+function isPythonRuntime(value) {
+	return value === void 0 || isRecord(value) && isNonEmptyString(value.implementation) && isNonEmptyString(value.version);
+}
+function isModels(value) {
+	return value === void 0 || isRecord(value) && (value.candidate === void 0 || agentProfileModelHintsSchema.safeParse(value.candidate).success) && isOptionalNonEmptyString(value.optimizer) && (value.candidate !== void 0 || value.optimizer !== void 0);
+}
+function isUsage(value) {
+	if (!isRecord(value) || !isNonNegativeInteger(value.optimizerEvaluations)) return false;
+	if (value.optimizerTokens === void 0) return true;
+	const tokens = value.optimizerTokens;
+	if (!isRecord(tokens)) return false;
+	const inputTokens = tokens.inputTokens;
+	const outputTokens = tokens.outputTokens;
+	const totalTokens = tokens.totalTokens;
+	const calls = tokens.calls;
+	if (!isNonNegativeInteger(inputTokens) || !isNonNegativeInteger(outputTokens) || !isNonNegativeInteger(totalTokens) || !isNonNegativeInteger(calls)) return false;
+	if (!isOptionalNonNegativeInteger(tokens.cachedInputTokens) || !isOptionalNonNegativeInteger(tokens.cacheWriteInputTokens) || !isOptionalNonNegativeInteger(tokens.reasoningTokens)) return false;
+	const cachedInputTokens = typeof tokens.cachedInputTokens === "number" ? tokens.cachedInputTokens : 0;
+	const cacheWriteInputTokens = typeof tokens.cacheWriteInputTokens === "number" ? tokens.cacheWriteInputTokens : 0;
+	const reasoningTokens = typeof tokens.reasoningTokens === "number" ? tokens.reasoningTokens : 0;
+	return totalTokens === inputTokens + outputTokens && cachedInputTokens + cacheWriteInputTokens <= inputTokens && reasoningTokens <= outputTokens && (totalTokens === 0 || calls > 0);
+}
+function isCost(value) {
+	if (!isRecord(value) || !isCostPart(value.optimization) || !isCostPart(value.finalTest) || !isCostPart(value.total)) return false;
+	const optimization = value.optimization;
+	const finalTest = value.finalTest;
+	const total = value.total;
+	return approximatelyEqual(total.totalUsd, optimization.totalUsd + finalTest.totalUsd) && total.accountingComplete === (optimization.accountingComplete && finalTest.accountingComplete);
+}
+function isCostPart(value) {
+	return isRecord(value) && typeof value.totalUsd === "number" && Number.isFinite(value.totalUsd) && value.totalUsd >= 0 && typeof value.accountingComplete === "boolean" && Array.isArray(value.incompleteReasons) && value.incompleteReasons.every((reason) => typeof reason === "string");
+}
+function receiptCost(value) {
+	return {
+		totalUsd: value.totalCostUsd,
+		accountingComplete: value.accountingComplete,
+		incompleteReasons: [...value.incompleteReasons]
+	};
+}
+function approximatelyEqual(left, right) {
+	const tolerance = Number.EPSILON * Math.max(1, Math.abs(left), Math.abs(right)) * 8;
+	return Math.abs(left - right) <= tolerance;
+}
+function isInvocation(value) {
+	return isRecord(value) && isNonEmptyString(value.runtimeInvocationId) && isNonEmptyString(value.optimizerRunId) && isOptionalNonEmptyString(value.compatibleOptimizerRunId) && typeof value.resumed === "boolean" && isNonEmptyString(value.artifactDir);
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function isOptionalNonEmptyString(value) {
+	return value === void 0 || isNonEmptyString(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);
+}
+function isSha256Digest(value) {
+	return typeof value === "string" && /^sha256:[0-9a-f]{64}$/.test(value);
+}
+//#endregion
+//#region src/intelligence/activation.ts
+/** Create the exact result a product stores in the same transaction as its target write. */
+function createAgentImprovementActivationResult(transition, options) {
+	const activation = verifyCanonicalCandidateDocument(agentImprovementActivationSchema.parse(transition.activation), "agent improvement activation");
+	assertTransitionInput(activation, transition);
+	const result = agentImprovementActivationResultSchema.parse(canonicalCandidateDocument({
+		kind: "agent-improvement-activation-result",
+		idempotencyKey: activation.digest,
+		attemptedAt: transition.attemptedAt,
+		completedAt: options.completedAt,
+		outcome: options.outcome
+	}).value);
+	assertResultAgainstActivation(activation, result);
+	assertOutcomeDesiredState(activation, result, new Map(transition.targets.map((target) => [targetIdentity(target), target.desiredDigest])));
+	return immutableCandidateValue(result);
+}
+/**
+* Recompute one historical activation result against the exact measured proposal and authority.
+* The result records that attempt; it is not a query of the target's current state.
+*/
+function verifyAgentImprovementActivationResult(input) {
+	const proposal = verifyAgentImprovementProposal(input.proposal);
+	const activation = verifyAgentImprovementActivation(input);
+	const result = verifyCanonicalCandidateDocument(agentImprovementActivationResultSchema.parse(input.result), "agent improvement activation result");
+	assertResultAgainstActivation(activation, result);
+	assertResultDesiredState(proposal, activation, result);
+	return result;
+}
+/** Validate and execute one product-owned activation transition. */
+async function executeAgentImprovementActivation(input, options) {
+	const proposal = verifyAgentImprovementProposal(input.proposal);
+	const activation = verifyAgentImprovementActivation(input);
+	const observedAt = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+	const attemptedAt = Date.parse(observedAt) < Date.parse(activation.authorizedAt) ? activation.authorizedAt : observedAt;
+	const expired = Date.parse(attemptedAt) >= Date.parse(activation.expiresAt);
+	const transition = immutableCandidateValue(proposal.evaluation.kind === "agent-improvement-measured-comparison" ? sealedCandidateTransition(proposal.evaluation.experiment, activation, attemptedAt, expired) : profileImprovementTransition(proposal.evaluation.experiment, activation, attemptedAt, expired));
+	if (transition.expired) {
+		if (!options.reconcile) return uncertainActivationResult(transition, "RECONCILIATION_UNAVAILABLE");
+		let reconciled;
+		try {
+			reconciled = await options.reconcile(transition);
+		} catch {
+			return uncertainActivationResult(transition, "RECONCILIATION_THROW");
+		}
+		if (reconciled === void 0) return createAgentImprovementActivationResult(transition, {
+			completedAt: transition.attemptedAt,
+			outcome: { status: "expired" }
+		});
+		try {
+			return verifyAgentImprovementActivationResult({
+				...input,
+				result: reconciled
+			});
+		} catch {
+			return uncertainActivationResult(transition, "INVALID_RECONCILIATION");
+		}
+	}
+	let rawResult;
+	try {
+		rawResult = await options.transition(transition);
+	} catch {
+		return uncertainActivationResult(transition, "TRANSITION_THROW");
+	}
+	try {
+		return verifyAgentImprovementActivationResult({
+			...input,
+			result: rawResult
+		});
+	} catch {
+		return uncertainActivationResult(transition, "INVALID_RESULT");
+	}
+}
+function sealedCandidateTransition(experiment, activation, attemptedAt, expired) {
+	const targetArm = activation.intent === "activate-candidate" ? "candidate" : "baseline";
+	return {
+		kind: "sealed-candidate",
+		activation,
+		candidateBundle: experiment.candidate,
+		bundle: experiment[targetArm],
+		targets: activation.targets.map((target) => ({
+			...target,
+			desiredDigest: agentImprovementTargetDigest(experiment, targetArm, target.surface),
+			desiredInput: agentImprovementTargetInput(experiment[targetArm], target.surface)
+		})),
+		attemptedAt,
+		expired
+	};
+}
+function profileImprovementTransition(experiment, activation, attemptedAt, expired) {
+	const sourceArm = activation.intent === "activate-candidate" ? "baseline" : "candidate";
+	const targetArm = activation.intent === "activate-candidate" ? "candidate" : "baseline";
+	const operation = profileImprovementOperation(experiment, activation.intent);
+	return {
+		kind: "profile-improvement",
+		activation,
+		experiment,
+		sourceStateDigest: agentProfileImprovementStateDigest(experiment, sourceArm),
+		desiredStateDigest: agentProfileImprovementStateDigest(experiment, targetArm),
+		operation,
+		targets: activation.targets.map((target) => ({
+			...target,
+			desiredDigest: agentProfileImprovementStateDigest(experiment, targetArm),
+			desiredInput: operation
+		})),
+		attemptedAt,
+		expired
+	};
+}
+function profileImprovementOperation(experiment, intent) {
+	return intent === "activate-candidate" ? {
+		kind: "apply-change",
+		changes: experiment.change
+	} : { kind: "restore-state" };
+}
+function uncertainActivationResult(transition, code) {
+	return createAgentImprovementActivationResult(transition, {
+		completedAt: transition.attemptedAt,
+		outcome: {
+			status: "indeterminate",
+			code,
+			message: "The product transition did not return a trustworthy commit result."
+		}
+	});
+}
+function assertTransitionInput(activation, transition) {
+	if (transition.kind === "sealed-candidate") {
+		assertSealedCandidateTransitionInput(activation, transition);
+		return;
+	}
+	assertProfileImprovementTransitionInput(activation, transition);
+}
+function assertSealedCandidateTransitionInput(activation, transition) {
+	assertAuthorizedTransitionTargets(activation, transition.targets);
+	const desiredInputsMatch = transition.targets.every((target) => canonicalCandidateDigest$1(target.desiredInput) === canonicalCandidateDigest$1(agentImprovementTargetInput(transition.bundle, target.surface)));
+	if (transition.expired !== Date.parse(transition.attemptedAt) >= Date.parse(activation.expiresAt) || transition.candidateBundle.digest !== activation.candidateDigest || !desiredInputsMatch || activation.intent === "activate-candidate" && transition.bundle.digest !== transition.candidateBundle.digest) throw new Error("activation transition does not match its authorization");
+}
+function assertProfileImprovementTransitionInput(activation, transition) {
+	assertAuthorizedTransitionTargets(activation, transition.targets);
+	const targetsAgentProfile = activation.targets.some((target) => target.surface === "agent-profile");
+	const experiment = agentProfileImprovementExperimentSchema.parse(transition.experiment);
+	const sourceArm = activation.intent === "activate-candidate" ? "baseline" : "candidate";
+	const targetArm = activation.intent === "activate-candidate" ? "candidate" : "baseline";
+	const sourceStateDigest = agentProfileImprovementStateDigest(experiment, sourceArm);
+	const desiredStateDigest = agentProfileImprovementStateDigest(experiment, targetArm);
+	const operation = profileImprovementOperation(experiment, activation.intent);
+	const targetsMatch = transition.targets.every((target) => target.expectedBaseDigest === sourceStateDigest && target.desiredDigest === desiredStateDigest && canonicalCandidateDigest$1(target.desiredInput) === canonicalCandidateDigest$1(operation));
+	if (transition.expired !== Date.parse(transition.attemptedAt) >= Date.parse(activation.expiresAt) || experiment.digest !== activation.experimentDigest || experiment.candidate.stateDigest !== activation.candidateDigest || targetsAgentProfile && (activation.executionRef === void 0 || canonicalCandidateDigest$1(activation.executionRef) !== canonicalCandidateDigest$1(experiment.executionRef)) || transition.sourceStateDigest !== sourceStateDigest || transition.desiredStateDigest !== desiredStateDigest || canonicalCandidateDigest$1(transition.operation) !== canonicalCandidateDigest$1(operation) || !targetsMatch) throw new Error("activation transition does not match its authorization");
+}
+function assertAuthorizedTransitionTargets(activation, targets) {
+	const authorized = targetMap(activation.targets);
+	const planned = targetMap(targets);
+	if (authorized.size !== planned.size || [...authorized.entries()].some(([identity, target]) => planned.get(identity)?.expectedBaseDigest !== target.expectedBaseDigest)) throw new Error("activation transition does not match its authorization");
+}
+function assertResultAgainstActivation(activation, result) {
+	const attemptedAt = Date.parse(result.attemptedAt);
+	const completedAt = Date.parse(result.completedAt);
+	const expiresAt = Date.parse(activation.expiresAt);
+	if (result.idempotencyKey !== activation.digest || attemptedAt < Date.parse(activation.authorizedAt) || completedAt < attemptedAt) throw new Error("activation result does not bind its authorization");
+	const expired = attemptedAt >= expiresAt;
+	if (result.outcome.status === "expired" && !expired || expired && ![
+		"expired",
+		"indeterminate",
+		"already-applied"
+	].includes(result.outcome.status)) throw new Error("activation result does not honor its authorization expiry");
+	if (!("targets" in result.outcome)) return;
+	const authorized = targetMap(activation.targets);
+	const observed = new Set(result.outcome.targets.map(targetIdentity));
+	if (authorized.size !== observed.size || [...authorized.keys()].some((identity) => !observed.has(identity))) throw new Error("activation result must cover every authorized target exactly once");
+	if (result.outcome.status === "applied" && result.outcome.targets.some((target) => target.beforeDigest !== authorized.get(targetIdentity(target))?.expectedBaseDigest)) throw new Error("applied activation did not start from its authorized base state");
+}
+function assertResultDesiredState(proposal, activation, result) {
+	if (!("targets" in result.outcome)) return;
+	const targetArm = activation.intent === "activate-candidate" ? "candidate" : "baseline";
+	const desiredStateDigest = proposal.evaluation.kind === "agent-profile-improvement-measured-comparison" ? agentProfileImprovementStateDigest(proposal.evaluation.experiment, targetArm) : void 0;
+	assertOutcomeDesiredState(activation, result, new Map(activation.targets.map((target) => [targetIdentity(target), desiredStateDigest ?? agentImprovementTargetDigest(requireSealedCandidateExperiment(proposal), targetArm, target.surface)])));
+}
+function assertOutcomeDesiredState(activation, result, desired) {
+	if (!("targets" in result.outcome)) return;
+	if (result.outcome.status === "applied") {
+		if (result.outcome.targets.some((target) => target.afterDigest !== desired.get(targetIdentity(target)))) throw new Error("applied activation does not match the requested bundle");
+		return;
+	}
+	const allDesired = result.outcome.targets.every((target) => target.currentDigest === desired.get(targetIdentity(target)));
+	if (result.outcome.status === "already-applied") {
+		if (!allDesired) throw new Error("already-applied activation is not at the requested state");
+		return;
+	}
+	const authorized = targetMap(activation.targets);
+	const hasStaleTarget = result.outcome.targets.some((target) => target.currentDigest !== authorized.get(targetIdentity(target))?.expectedBaseDigest);
+	if (allDesired || !hasStaleTarget) throw new Error("activation conflict does not identify stale target state");
+}
+function targetMap(targets) {
+	return new Map(targets.map((target) => [targetIdentity(target), target]));
+}
+function targetIdentity(target) {
+	return `${target.surface}\u0000${target.identity}`;
+}
+/** Create the reviewable record only from a complete, recomputable experiment result. */
+function createAgentImprovementProposal(options) {
+	const findings = assertProposalFindings(options.findings, "createAgentImprovementProposal findings");
+	const { evaluation, changedSurfaces } = validateShippableAgentImprovementEvaluation(options.evaluation, options.runId, "agent improvement proposal");
+	return agentImprovementProposalSchema.parse(canonicalCandidateDocument({
+		kind: "agent-improvement-proposal",
+		runId: options.runId,
+		changedSurfaces,
+		proposedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+		findings: [...findings],
+		evaluation
+	}).value);
+}
+/** Persist a human or tenant-policy decision bound to one exact proposal. */
+function reviewAgentImprovementProposal(inputProposal, input) {
+	const proposal = verifyAgentImprovementProposal(inputProposal);
+	if (!input.reviewedBy.trim()) throw new Error("candidate review requires reviewedBy");
+	if (!input.reason.trim()) throw new Error("candidate review requires a reason");
+	if (input.decision === "approve" && proposal.evaluation.decision.outcome !== "ship") throw new Error("candidate cannot be approved without a passing experiment");
+	const reviewedAt = (input.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+	if (Date.parse(reviewedAt) < Date.parse(proposal.proposedAt)) throw new Error("candidate review cannot predate its proposal");
+	return agentImprovementReviewSchema.parse(canonicalCandidateDocument({
+		kind: "agent-improvement-review",
+		proposalDigest: proposal.digest,
+		decision: input.decision,
+		reviewedBy: input.reviewedBy,
+		reviewedAt,
+		reason: input.reason,
+		...input.feedback === void 0 ? {} : { feedback: input.feedback }
+	}).value);
+}
+/** Authorize product-owned writes only after the exact candidate was measured and approved. */
+function createAgentImprovementActivation(inputProposal, inputReview, options) {
+	const proposal = verifyAgentImprovementProposal(inputProposal);
+	const review = verifyAgentImprovementReview(inputReview);
+	if (review.decision !== "approve" || review.proposalDigest !== proposal.digest) throw new Error("candidate activation requires an approval for the exact proposal");
+	if (!options.fundingOwner.trim() || !options.authorizedBy.trim()) throw new Error("candidate activation authority must be non-empty");
+	const experiment = proposal.evaluation.experiment;
+	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,
+		authorizedBy: options.authorizedBy,
+		authorizedAt,
+		expiresAt: options.expiresAt
+	}).value);
+}
+/** Validate a proposal and recompute every binding to its measured experiment. */
+function verifyAgentImprovementProposal(input) {
+	const proposal = verifyCanonicalCandidateDocument(agentImprovementProposalSchema.parse(input), "agent improvement proposal");
+	const { changedSurfaces } = validateShippableAgentImprovementEvaluation(proposal.evaluation, proposal.runId, "agent improvement proposal");
+	if (!(proposal.evaluation.kind === "agent-profile-improvement-measured-comparison" ? sameAgentImprovementSurfaceSet(proposal.changedSurfaces, changedSurfaces) : sameOrderedValues(proposal.changedSurfaces, changedSurfaces))) throw new Error("proposal changed surfaces do not match its exact experiment");
+	assertProposalFindings(proposal.findings, "agent improvement proposal findings");
+	return proposal;
+}
+/** Return a sealed bundle experiment; ordinary profile changes need a product-owned executor. */
+function requireSealedCandidateExperiment(proposal) {
+	if (proposal.evaluation.kind !== "agent-improvement-measured-comparison") throw new Error("agent profile improvement activation requires a product profile-diff executor, not a sealed candidate bundle");
+	return proposal.evaluation.experiment;
+}
+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`);
+	if (runId !== evaluation.provenance.runId) throw new Error("proposal runId does not match its measured experiment");
+	return {
+		evaluation,
+		changedSurfaces: evaluation.kind === "agent-profile-improvement-measured-comparison" ? profileImprovementChangedSurfaces(evaluation.experiment.change) : deriveChangedSurfaces(evaluation.experiment.baseline, evaluation.experiment.candidate)
+	};
+}
+/** Use each owning package's complete measurement validator before a proposal is persisted. */
+function verifyAgentImprovementEvaluation(input) {
+	if (typeof input === "object" && input !== null && "kind" in input && input.kind === "agent-profile-improvement-measured-comparison") {
+		const evaluation = verifyAgentProfileImprovementExperimentComparison(input);
+		optimizationActivationReceiptFromMetadata(evaluation.metadata);
+		return evaluation;
+	}
+	const evaluation = verifyCandidateExperimentComparison(input);
+	optimizationActivationReceiptFromMetadata(evaluation.metadata);
+	return evaluation;
+}
+/** Validate the canonical identity and wire shape of an improvement review. */
+function verifyAgentImprovementReview(input) {
+	return verifyCanonicalCandidateDocument(agentImprovementReviewSchema.parse(input), "agent improvement review");
+}
+/** Validate activation authority against the exact proposal, review, experiment, and base state. */
+function verifyAgentImprovementActivation(input) {
+	const proposal = verifyAgentImprovementProposal(input.proposal);
+	const review = verifyAgentImprovementReview(input.review);
+	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;
+}
+function sameOrderedValues(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+//#endregion
+export { serializeRolloutPolicy as C, normalizeRolloutPolicy as S, agentImprovementTargetProfileDiffs as _, reviewAgentImprovementProposal as a, isAgentProfileMeasuredSurface as b, verifyAgentImprovementProposal as c, attachOptimizationActivationReceipt as d, createOptimizationActivationReceipt as f, agentImprovementProfileSurfaceInput as g, agentImprovementProfileSurfaceDigest as h, executeAgentImprovementActivation as i, verifyAgentImprovementReview as l, agentImprovementProfileDiffs as m, createAgentImprovementActivationResult as n, verifyAgentImprovementActivation as o, optimizationActivationReceiptFromMetadata as p, createAgentImprovementProposal as r, verifyAgentImprovementActivationResult as s, createAgentImprovementActivation as t, assertNoCallerOptimizationReceipt as u, assertProfileImprovementTargetsShareIdentity as v, structuralRolloutPolicyFromProfile as w, applyRolloutPolicyToProfile as x, isAgentImprovementProfileSurface as y };
+
+//# sourceMappingURL=activation-CVSFxis9.js.map