@tangle-network/agent-knowledge 7.0.0 → 7.0.2

package/dist/{memory-CIYRB_Q8.js → memory-DAFfGTJH.js}

@@ -1,10 +1,10 @@
 import { r as stableId, t as sha256 } from "./ids-Bevz_pXV.js";
-import { B as memoryWriteResultToSourceRecord, C as appendDurableJournalEvent, D as reconcileInterruptedMemoryPaidCalls, E as readActiveAttemptJournal, O as reserveRecoveryAttempts, S as appendAttemptJournalEvent, T as hasSettledPaidCall, _ as memoryRecoveryDelayMs, b as runBoundedMemoryLifecycle, f as acquireAgentMemoryRunLease, g as createMemoryExecutionPool, u as scoreMemoryBenchmarkArtifact, v as releaseMemoryAdapterCreatedAfterAbort, w as assertNoInterruptedPaidCalls, x as sleepForMemoryRecovery, y as resolveMemoryCleanupTimeoutMs, z as memoryHitToSourceRecord } from "./benchmarks-C8L7HJb4.js";
+import { A as reserveRecoveryAttempts, C as sleepForMemoryRecovery, D as hasSettledPaidCall, E as assertNoInterruptedPaidCalls, H as memoryWriteResultToSourceRecord, O as readActiveAttemptJournal, S as runBoundedMemoryLifecycle, T as appendDurableJournalEvent, V as memoryHitToSourceRecord, _ as MEMORY_OPERATION_CANCELLATION_TIMEOUT_MS, b as memoryRecoveryDelayMs, f as acquireAgentMemoryRunLease, g as MEMORY_CAMPAIGN_DISPATCH_SHUTDOWN_TIMEOUT_MS, k as reconcileInterruptedMemoryPaidCalls, u as scoreMemoryBenchmarkArtifact, v as createBoundedMemoryAdapter, w as appendAttemptJournalEvent, x as resolveMemoryCleanupTimeoutMs, y as createMemoryExecutionPool } from "./benchmarks-CPl4AO1k.js";
 import { randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
-import { canonicalJson, mulberry32 } from "@tangle-network/agent-eval";
+import { canonicalJson, comparePairedArms, mulberry32, pairArms } from "@tangle-network/agent-eval";
 import { z } from "zod";
-import { compareOptimizationMethods, createRunCostLedger, fsCampaignStorage, heldoutSignificance, resolveRunDir, runCampaign, surfaceHash } from "@tangle-network/agent-eval/campaign";
+import { assertCampaignSplitIdentity, canonicalDigest, compareOptimizationMethods, createRunCostLedger, fsCampaignStorage, heldoutSignificance, resolveRunDir, runCampaign, surfaceHash } from "@tangle-network/agent-eval/campaign";
 //#region src/immutable-ref.ts
 const SHA256_REF = /^sha256:[a-f0-9]{64}$/;
 const GIT_REF = /^git:[a-f0-9]{40}$/;
@@ -1035,7 +1035,8 @@ function assertMemorySequences(sequences) {
 		if (sequence.steps.length === 0) throw new Error(`memory experiment sequence ${sequence.id} has no steps`);
 		assertUnique(sequence.steps.map((step) => step.id), `step in sequence ${sequence.id}`);
 		let probeCount = 0;
-		for (const step of sequence.steps) {
+		const retentionMeasurements = /* @__PURE__ */ new Map();
+		for (const [stepOrdinal, step] of sequence.steps.entries()) {
 			for (const write of step.writes ?? []) {
 				assertNonEmptyString(write.text, `memory experiment write in ${sequence.id}/${step.id}`);
 				if (write.id !== void 0) assertNonEmptyString(write.id, `memory experiment write id in ${sequence.id}/${step.id}`);
@@ -1050,12 +1051,69 @@ function assertMemorySequences(sequences) {
 				assertStringList(probe.expectedEventIds, `${sequence.id}/${step.id}/${probe.id} event ids`);
 				assertStringList(probe.expectedActorIds, `${sequence.id}/${step.id}/${probe.id} actor ids`);
 				if (probe.referenceAnswer !== void 0) assertNonEmptyString(probe.referenceAnswer, `memory experiment reference answer ${sequence.id}/${step.id}/${probe.id}`);
+				if (probe.retentionKey !== void 0) {
+					assertNonEmptyString(probe.retentionKey, `memory experiment retention key ${sequence.id}/${step.id}/${probe.id}`);
+					if (probe.retentionKey !== probe.retentionKey.trim()) throw new Error(`memory experiment retention key ${sequence.id}/${step.id}/${probe.id} must not have surrounding whitespace`);
+					const definition = retentionMeasurementDefinition(step.scope, probe);
+					const prior = retentionMeasurements.get(probe.retentionKey);
+					if (prior?.stepOrdinals.has(stepOrdinal)) throw new Error(`memory experiment retention key ${sequence.id}/${probe.retentionKey} may appear only once per step`);
+					if (prior && prior.definition !== definition) throw new Error(`memory experiment retention key ${sequence.id}/${probe.retentionKey} must repeat the exact same measurement`);
+					const measurement = prior ?? {
+						definition,
+						stepOrdinals: /* @__PURE__ */ new Set()
+					};
+					measurement.stepOrdinals.add(stepOrdinal);
+					retentionMeasurements.set(probe.retentionKey, measurement);
+				}
+				if (probe.transferKey !== void 0) {
+					assertNonEmptyString(probe.transferKey, `memory experiment transfer key ${sequence.id}/${step.id}/${probe.id}`);
+					if (probe.transferKey !== probe.transferKey.trim()) throw new Error(`memory experiment transfer key ${sequence.id}/${step.id}/${probe.id} must not have surrounding whitespace`);
+					if (probe.retentionKey !== void 0) throw new Error(`memory experiment probe ${sequence.id}/${step.id}/${probe.id} cannot be both transfer and retention`);
+					if (stepOrdinal === 0) throw new Error(`memory experiment transfer probe ${sequence.id}/${step.id}/${probe.id} must run after the first step`);
+				}
 				if (!((probe.requiredFacts?.length ?? 0) > 0 || (probe.forbiddenFacts?.length ?? 0) > 0 || (probe.expectedEventIds?.length ?? 0) > 0 || (probe.expectedActorIds?.length ?? 0) > 0 || Boolean(probe.referenceAnswer?.trim()))) throw new Error(`memory experiment probe ${sequence.id}/${step.id}/${probe.id} has no measurable target`);
 			}
 		}
 		if (probeCount === 0) throw new Error(`memory experiment sequence ${sequence.id} has no probes`);
+		for (const [retentionKey, measurement] of retentionMeasurements) if (measurement.stepOrdinals.size < 2) throw new Error(`memory experiment retention key ${sequence.id}/${retentionKey} must appear in at least two distinct steps`);
+	}
+}
+function assertMemoryLearningSequences(sequences) {
+	for (const sequence of sequences) {
+		if (sequence.steps.length < 2) throw new Error(`memory learning sequence ${sequence.id} requires at least two ordered steps`);
+		if (!sequence.steps.slice(1).some((step) => (step.probes?.length ?? 0) > 0)) throw new Error(`memory learning sequence ${sequence.id} requires a probe after the first step`);
 	}
 }
+function retentionMeasurementDefinition(stepScope, probe) {
+	return canonicalJson({
+		query: probe.query,
+		scope: compactScope({
+			...stepScope ?? {},
+			...probe.scope ?? {},
+			tags: {
+				...stepScope?.tags ?? {},
+				...probe.scope?.tags ?? {}
+			}
+		}),
+		limit: probe.limit ?? null,
+		taskKind: probe.taskKind ?? "memory-recall",
+		requiredFacts: normalizeFactMatchers(probe.requiredFacts ?? []),
+		forbiddenFacts: normalizeFactMatchers(probe.forbiddenFacts ?? []),
+		expectedEventIds: [...probe.expectedEventIds ?? []],
+		expectedActorIds: [...probe.expectedActorIds ?? []],
+		referenceAnswer: probe.referenceAnswer ?? null
+	});
+}
+function normalizeFactMatchers(matchers) {
+	return matchers.map((matcher) => ({
+		id: matcher.id,
+		anyOf: [...matcher.anyOf],
+		weight: matcher.weight ?? 1,
+		sourceEventIds: [...matcher.sourceEventIds ?? []],
+		validAt: matcher.validAt ?? null,
+		obsolete: matcher.obsolete ?? false
+	}));
+}
 function normalizeCleanupScope(scope) {
 	const normalized = compactScope(scope);
 	if (normalized.tags && Object.keys(normalized.tags).length === 0) delete normalized.tags;
@@ -1119,7 +1177,7 @@ function buildAgentMemorySequencesFromBenchmarkCases(cases, options = {}) {
 				eventIndex
 			}) ?? {
 				agentId: memoryAgentId,
-				sessionId: testCase.id
+				sessionId: "benchmark-session"
 			}),
 			writes: [{
 				id: event.id,
@@ -1138,7 +1196,7 @@ function buildAgentMemorySequencesFromBenchmarkCases(cases, options = {}) {
 			id: "probe",
 			scope: compactScope(options.probeScope?.(testCase) ?? {
 				agentId: memoryAgentId,
-				sessionId: testCase.id
+				sessionId: "benchmark-session"
 			}),
 			probes: [{
 				id: "answer",
@@ -1212,6 +1270,759 @@ function agentMemorySequenceJudge() {
 	};
 }
 //#endregion
+//#region src/memory/experiment/metrics.ts
+function rankAgentMemoryExperiment(candidates, scenarios, campaign, costByCandidate) {
+	const scenarioById = new Map(scenarios.map((scenario) => [scenario.id, scenario]));
+	return candidates.map((candidate) => {
+		const candidateScenarios = scenarios.filter((scenario) => scenario.candidateId === candidate.id);
+		const cells = campaign.cells.filter((cell) => scenarioById.get(cell.scenarioId)?.candidateId === candidate.id);
+		const successful = cells.filter((cell) => !cell.error && cell.artifact);
+		const dimensionRows = successful.map((cell) => cell.artifact.dimensions);
+		return {
+			rank: 0,
+			candidateId: candidate.id,
+			label: candidate.label ?? candidate.id,
+			scoreMean: mean$1(cells.map((cell) => !cell.error && cell.artifact ? cell.artifact.score : 0)),
+			passRate: mean$1(cells.map((cell) => !cell.error && cell.artifact?.passed ? 1 : 0)),
+			totalSequences: candidateScenarios.length,
+			totalCells: cells.length,
+			totalProbes: successful.reduce((sum, cell) => sum + cell.artifact.probes.length, 0),
+			cellsFailed: cells.filter((cell) => Boolean(cell.error)).length,
+			totalCostUsd: normalizeUsd(costByCandidate.get(candidate.id) ?? 0),
+			durationMs: cells.reduce((sum, cell) => sum + cell.durationMs, 0),
+			dimensions: meanDimensions(dimensionRows)
+		};
+	}).sort((a, b) => Number(a.cellsFailed > 0) - Number(b.cellsFailed > 0) || b.scoreMean - a.scoreMean || b.passRate - a.passRate || a.totalCostUsd - b.totalCostUsd || a.candidateId.localeCompare(b.candidateId)).map((row, index) => ({
+		...row,
+		rank: index + 1
+	}));
+}
+function memoryExperimentCostByCandidate(costLedger, runDir, scenarios, candidateIdsInput) {
+	const candidateByScenario = new Map(scenarios.map((scenario) => [scenario.id, scenario.candidateId]));
+	const candidateIds = new Set(candidateIdsInput);
+	const sequenceIds = new Set(scenarios.map((scenario) => scenario.sequenceId));
+	for (const candidateId of candidateIds) for (const sequenceId of sequenceIds) candidateByScenario.set(`${stableId("candidate", candidateId)}:${sequenceId}`, candidateId);
+	const totals = /* @__PURE__ */ new Map();
+	for (const receipt of costLedger.list()) {
+		if (receipt.tags?.runDir !== runDir) continue;
+		const scenarioCandidate = receipt.tags.scenarioId ? candidateByScenario.get(receipt.tags.scenarioId) : void 0;
+		const recoveryCandidate = receipt.tags.memoryRecovery === "attempt" && receipt.tags.candidateId ? receipt.tags.candidateId : void 0;
+		const candidateId = scenarioCandidate ?? recoveryCandidate;
+		if (!candidateId || !candidateIds.has(candidateId)) continue;
+		totals.set(candidateId, (totals.get(candidateId) ?? 0) + receipt.costUsd);
+	}
+	return totals;
+}
+function renderAgentMemoryExperimentRanking(rows, totalCostUsd, unrankedRecoveryCostUsd) {
+	return [
+		"# Agent Memory Experiment",
+		"",
+		`- total cost: $${format(totalCostUsd)}`,
+		`- retired-candidate cost: $${format(unrankedRecoveryCostUsd)}`,
+		"",
+		"| rank | candidate | sequences | cells | probes | failed | score | pass rate | cost | duration ms |",
+		"| ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
+		...rows.map((row) => `| ${row.rank} | ${row.label} | ${row.totalSequences} | ${row.totalCells} | ${row.totalProbes} | ${row.cellsFailed} | ${format(row.scoreMean)} | ${format(row.passRate)} | $${format(row.totalCostUsd)} | ${format(row.durationMs)} |`),
+		""
+	].join("\n");
+}
+function meanDimensions(rows) {
+	const values = /* @__PURE__ */ new Map();
+	for (const row of rows) for (const [key, value] of Object.entries(row)) {
+		if (!Number.isFinite(value)) continue;
+		const bucket = values.get(key) ?? [];
+		bucket.push(value);
+		values.set(key, bucket);
+	}
+	return Object.fromEntries([...values].map(([key, bucket]) => [key, mean$1(bucket)]));
+}
+function countDimensions(rows) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const row of rows) for (const key of new Set(row)) counts.set(key, (counts.get(key) ?? 0) + 1);
+	return Object.fromEntries(counts);
+}
+function mean$1(values) {
+	return values.length === 0 ? 0 : values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function format(value) {
+	return Number.isFinite(value) ? value.toFixed(4) : "0.0000";
+}
+function normalizeUsd(value) {
+	return Number(value.toFixed(12));
+}
+//#endregion
+//#region src/memory/experiment/probe-evaluation.ts
+function scoreAgentMemoryProbe(sequence, step, probe, evidence) {
+	return scoreMemoryBenchmarkArtifact(memoryProbeBenchmarkCase(sequence, step, probe), evidence);
+}
+function memoryProbeBenchmarkCase(sequence, step, probe) {
+	return {
+		id: `${sequence.id}:${step.id}:${probe.id}`,
+		family: sequence.family,
+		taskKind: probe.taskKind ?? "memory-recall",
+		split: sequence.split,
+		events: [],
+		prompt: probe.query,
+		requiredFacts: probe.requiredFacts && probe.requiredFacts.length > 0 ? probe.requiredFacts : probe.referenceAnswer ? [{
+			id: `${probe.id}:reference`,
+			anyOf: [probe.referenceAnswer]
+		}] : void 0,
+		forbiddenFacts: probe.forbiddenFacts,
+		expectedEventIds: probe.expectedEventIds,
+		expectedActorIds: probe.expectedActorIds,
+		referenceAnswer: probe.referenceAnswer
+	};
+}
+//#endregion
+//#region src/memory/experiment/learning-evidence.ts
+function assertStoredAgentMemoryEvidence(storage, result, sequences) {
+	const sequenceById = new Map(sequences.map((sequence) => [sequence.id, sequence]));
+	for (const cell of result.campaign.cells) {
+		if (cell.error || !cell.artifact) throw new Error(`memory learning cell '${cell.cellId}' has no valid artifact${cell.error ? `: ${cell.error}` : ""}`);
+		const sequence = sequenceById.get(cell.artifact.sequenceId);
+		if (!sequence) throw new Error(`memory learning cell '${cell.cellId}' references unknown sequence '${cell.artifact.sequenceId}'`);
+		assertStoredCellEvidence(storage, cell.cellId, cell.artifact, sequence);
+	}
+}
+function assertStoredCellEvidence(storage, cellId, artifact, sequence) {
+	const definitions = indexProbeDefinitions(sequence);
+	if (artifact.probes.length !== definitions.size) throw new Error(`memory learning cell '${cellId}' has ${artifact.probes.length} probes; expected ${definitions.size}`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const probe of artifact.probes) {
+		const key = probeKey(probe.stepOrdinal, probe.stepId, probe.id);
+		const definition = definitions.get(key);
+		if (!definition || seen.has(key)) throw new Error(`memory learning cell '${cellId}' has unexpected probe '${key}'`);
+		seen.add(key);
+		assertStoredProbeEvidence(storage, cellId, probe, definition, sequence);
+	}
+	const expectedScore = mean$1(artifact.probes.map((probe) => probe.score));
+	const expectedPassed = artifact.probes.length > 0 && artifact.probes.every((probe) => probe.passed);
+	const expectedDimensions = meanDimensions(artifact.probes.map((probe) => probe.dimensions));
+	const expectedCounts = countDimensions(artifact.probes.map((probe) => probe.applicableDimensions));
+	if (artifact.score !== expectedScore || artifact.passed !== expectedPassed || canonicalJson(artifact.dimensions) !== canonicalJson(expectedDimensions) || canonicalJson(artifact.dimensionSampleCounts) !== canonicalJson(expectedCounts)) throw new Error(`memory learning cell '${cellId}' aggregate does not match its probes`);
+}
+function assertStoredProbeEvidence(storage, cellId, observed, definition, sequence) {
+	const { probe, step } = definition;
+	if (observed.query !== probe.query || observed.retentionKey !== probe.retentionKey || observed.transferKey !== probe.transferKey) throw new Error(`memory learning cell '${cellId}' probe '${observed.id}' changed definition`);
+	const raw = storage.read(observed.evidencePath);
+	if (raw === void 0) throw new Error(`memory learning probe evidence is missing at '${observed.evidencePath}'`);
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		throw new Error(`memory learning probe evidence is malformed at '${observed.evidencePath}'`, { cause: error });
+	}
+	if (canonicalDigest(parsed) !== observed.evidenceRef) throw new Error(`memory learning probe evidence hash does not match at '${observed.evidencePath}'`);
+	const evidence = parseProbeEvidence(parsed, observed.evidencePath);
+	const expected = scoreAgentMemoryProbe(sequence, step, probe, evidence);
+	const observedEvaluation = {
+		score: observed.score,
+		passed: observed.passed,
+		dimensions: observed.dimensions,
+		applicableDimensions: observed.applicableDimensions,
+		notes: observed.notes
+	};
+	const expectedEvaluation = {
+		score: expected.score,
+		passed: expected.passed,
+		dimensions: expected.dimensions,
+		applicableDimensions: expected.applicableDimensions ?? Object.keys(expected.dimensions),
+		notes: expected.notes
+	};
+	if (canonicalJson(observedEvaluation) !== canonicalJson(expectedEvaluation)) throw new Error(`memory learning probe score does not match saved evidence at '${observed.evidencePath}'`);
+	if (canonicalJson(observed.hitIds) !== canonicalJson(evidence.usedMemoryIds)) throw new Error(`memory learning probe hits do not match saved evidence at '${observed.evidencePath}'`);
+}
+function indexProbeDefinitions(sequence) {
+	const definitions = /* @__PURE__ */ new Map();
+	for (const [stepOrdinal, step] of sequence.steps.entries()) for (const probe of step.probes ?? []) definitions.set(probeKey(stepOrdinal, step.id, probe.id), {
+		step,
+		stepOrdinal,
+		probe
+	});
+	return definitions;
+}
+function probeKey(stepOrdinal, stepId, probeId) {
+	return JSON.stringify([
+		stepOrdinal,
+		stepId,
+		probeId
+	]);
+}
+function parseProbeEvidence(value, path) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`memory learning probe evidence has invalid shape at '${path}'`);
+	const record = value;
+	if (typeof record.answer !== "string" || !isStringArray(record.rememberedFacts) || !isStringArray(record.citedEventIds) || !isStringArray(record.usedMemoryIds) || !isStringArray(record.actorIds)) throw new Error(`memory learning probe evidence has invalid shape at '${path}'`);
+	return {
+		answer: record.answer,
+		rememberedFacts: record.rememberedFacts,
+		citedEventIds: record.citedEventIds,
+		usedMemoryIds: record.usedMemoryIds,
+		actorIds: record.actorIds
+	};
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+//#endregion
+//#region src/memory/experiment/learning-metrics.ts
+function measureAgentMemoryLearning(paired, stateful, stateless) {
+	const cells = paired.map(toCellComparison);
+	const transferCells = paired.flatMap(toTransferCells);
+	const forgettingProbes = paired.flatMap(toForgettingComparisons);
+	const gainUnits = collapseLearningCells(cells);
+	const forgetting = summarizeForgetting(forgettingProbes, stateful.campaign.seed);
+	const preTreatment = measurePreTreatment(paired, stateful.campaign.seed);
+	if (!paired[0]) throw new Error("cannot compare memory learning: no paired cells");
+	return {
+		comparisonRef: stateful.comparisonRef,
+		evidence: {
+			splitRef: evidenceRef(stateful.campaign.splitDigest, "task split"),
+			statefulManifestRef: evidenceRef(stateful.campaign.manifestHash, "stateful campaign manifest"),
+			statelessManifestRef: evidenceRef(stateless.campaign.manifestHash, "stateless campaign manifest"),
+			statefulRunDir: stateful.campaign.runDir,
+			statelessRunDir: stateless.campaign.runDir,
+			candidateRefs: stateful.candidateRefs.map((candidate) => ({ ...candidate })),
+			executionRef: stateful.executionRef
+		},
+		cells,
+		preTreatment,
+		gain: comparePairedRewards(gainUnits, stateful.campaign.seed, "overall gain"),
+		gainByCandidate: summarizeCandidateGain(cells, stateful.campaign.seed),
+		transfer: {
+			definition: "explicit-transfer-probes",
+			cells: transferCells,
+			byStep: summarizeTransfer(transferCells, stateful.campaign.seed)
+		},
+		forgetting: {
+			definition: "prior-peak-minus-final",
+			probes: forgettingProbes,
+			...forgetting
+		}
+	};
+}
+function measurePreTreatment(paired, seed) {
+	const cells = paired.flatMap((pair) => {
+		const probes = pair.probes.filter((probe) => probe.stateful.stepOrdinal === 0);
+		if (probes.length === 0) return [];
+		return [{
+			sequenceId: pair.stateful.artifact.sequenceId,
+			statefulReward: mean$1(probes.map((probe) => probe.stateful.score)),
+			statelessReward: mean$1(probes.map((probe) => probe.stateless.score)),
+			exact: probes.every((probe) => probe.stateful.score === probe.stateless.score)
+		}];
+	});
+	const bySequence = /* @__PURE__ */ new Map();
+	for (const cell of cells) {
+		const unit = bySequence.get(cell.sequenceId) ?? {
+			statefulRewards: [],
+			statelessRewards: [],
+			exact: true
+		};
+		unit.statefulRewards.push(cell.statefulReward);
+		unit.statelessRewards.push(cell.statelessReward);
+		unit.exact &&= cell.exact;
+		bySequence.set(cell.sequenceId, unit);
+	}
+	const units = [...bySequence.entries()].map(([sequenceId, unit]) => ({
+		pairKey: sequenceId,
+		statefulReward: mean$1(unit.statefulRewards),
+		statelessReward: mean$1(unit.statelessRewards),
+		exact: unit.exact
+	}));
+	return {
+		definition: "first-step-probes",
+		cells: cells.length,
+		n: units.length,
+		exactMatchRate: units.length === 0 ? null : mean$1(units.map((unit) => unit.exact ? 1 : 0)),
+		difference: units.length === 0 ? null : comparePairedRewards(units, seed, "pre-treatment difference")
+	};
+}
+function toCellComparison(pair) {
+	const probes = pair.probes.filter((probe) => probe.stateful.stepOrdinal > 0);
+	if (probes.length === 0) throw new Error(`cannot compare memory learning: cell ${pair.stateful.cell.cellId} has no probe after the first step`);
+	const statefulReward = mean$1(probes.map((probe) => probe.stateful.score));
+	const statelessReward = mean$1(probes.map((probe) => probe.stateless.score));
+	return {
+		cellId: pair.stateful.cell.cellId,
+		candidateId: pair.stateful.artifact.candidateId,
+		sequenceId: pair.stateful.artifact.sequenceId,
+		rep: pair.stateful.cell.rep,
+		seed: pair.stateful.cell.seed,
+		statefulArtifactRef: pair.stateful.artifactRef,
+		statelessArtifactRef: pair.stateless.artifactRef,
+		probeCount: probes.length,
+		statefulReward,
+		statelessReward,
+		gain: difference(statefulReward, statelessReward)
+	};
+}
+function toTransferCells(pair) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const probe of pair.probes) {
+		const transferKey = probe.stateful.transferKey;
+		if (transferKey === void 0) continue;
+		const key = JSON.stringify([probe.stateful.stepOrdinal, transferKey]);
+		const group = groups.get(key) ?? {
+			stepOrdinal: probe.stateful.stepOrdinal,
+			transferKey,
+			probes: []
+		};
+		group.probes.push(probe);
+		groups.set(key, group);
+	}
+	return [...groups.values()].map(({ stepOrdinal, transferKey, probes }) => {
+		const stepIds = sortedUnique$1(probes.map((probe) => probe.stateful.stepId));
+		if (stepIds.length !== 1) throw new Error(`cannot compare memory learning: step ordinal ${stepOrdinal} maps to multiple step ids in ${pair.stateful.cell.cellId}`);
+		const statefulReward = mean$1(probes.map((probe) => probe.stateful.score));
+		const statelessReward = mean$1(probes.map((probe) => probe.stateless.score));
+		return {
+			cellId: pair.stateful.cell.cellId,
+			candidateId: pair.stateful.artifact.candidateId,
+			sequenceId: pair.stateful.artifact.sequenceId,
+			rep: pair.stateful.cell.rep,
+			seed: pair.stateful.cell.seed,
+			stepId: stepIds[0],
+			stepOrdinal,
+			transferKey,
+			probeCount: probes.length,
+			statefulArtifactRef: pair.stateful.artifactRef,
+			statelessArtifactRef: pair.stateless.artifactRef,
+			statefulReward,
+			statelessReward,
+			gain: difference(statefulReward, statelessReward)
+		};
+	}).sort((left, right) => left.stepOrdinal - right.stepOrdinal || left.transferKey.localeCompare(right.transferKey));
+}
+function toForgettingComparisons(pair) {
+	const byRetentionKey = /* @__PURE__ */ new Map();
+	for (const probe of pair.probes) {
+		const retentionKey = probe.stateful.retentionKey;
+		if (retentionKey === void 0) continue;
+		const probes = byRetentionKey.get(retentionKey) ?? [];
+		probes.push(probe);
+		byRetentionKey.set(retentionKey, probes);
+	}
+	return [...byRetentionKey.entries()].map(([retentionKey, observations]) => {
+		observations.sort((left, right) => left.stateful.stepOrdinal - right.stateful.stepOrdinal);
+		if (observations.length < 2) throw new Error(`cannot compare memory learning: retention key ${retentionKey} in ${pair.stateful.cell.cellId} has fewer than two observations`);
+		const ordinals = observations.map((probe) => probe.stateful.stepOrdinal);
+		if (new Set(ordinals).size !== ordinals.length) throw new Error(`cannot compare memory learning: retention key ${retentionKey} in ${pair.stateful.cell.cellId} repeats within one step`);
+		const final = observations[observations.length - 1];
+		const prior = observations.slice(0, -1);
+		const statefulPeak = maxProbe(prior, (probe) => probe.stateful.score);
+		const statelessPeak = maxProbe(prior, (probe) => probe.stateless.score);
+		const statefulForgetting = difference(statefulPeak.reward, final.stateful.score);
+		const statelessForgetting = difference(statelessPeak.reward, final.stateless.score);
+		return {
+			cellId: pair.stateful.cell.cellId,
+			candidateId: pair.stateful.artifact.candidateId,
+			sequenceId: pair.stateful.artifact.sequenceId,
+			rep: pair.stateful.cell.rep,
+			seed: pair.stateful.cell.seed,
+			retentionKey,
+			observations: observations.length,
+			firstStepOrdinal: observations[0].stateful.stepOrdinal,
+			finalStepOrdinal: final.stateful.stepOrdinal,
+			statefulArtifactRef: pair.stateful.artifactRef,
+			statelessArtifactRef: pair.stateless.artifactRef,
+			statefulPriorPeakReward: statefulPeak.reward,
+			statefulPriorPeakStepOrdinal: statefulPeak.stepOrdinal,
+			statefulFinalReward: final.stateful.score,
+			statefulForgetting,
+			statelessPriorPeakReward: statelessPeak.reward,
+			statelessPriorPeakStepOrdinal: statelessPeak.stepOrdinal,
+			statelessFinalReward: final.stateless.score,
+			statelessForgetting,
+			excessForgetting: difference(statefulForgetting, statelessForgetting)
+		};
+	}).sort((left, right) => left.retentionKey.localeCompare(right.retentionKey) || left.sequenceId.localeCompare(right.sequenceId) || left.rep - right.rep || left.seed - right.seed);
+}
+function summarizeCandidateGain(cells, seed) {
+	return sortedUnique$1(cells.map((cell) => cell.candidateId)).map((candidateId) => {
+		const units = collapseLearningCells(cells.filter((cell) => cell.candidateId === candidateId));
+		return {
+			candidateId,
+			cells: cells.filter((cell) => cell.candidateId === candidateId).length,
+			gain: comparePairedRewards(units, seed, `candidate ${candidateId} gain`)
+		};
+	});
+}
+function summarizeTransfer(cells, seed) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const cell of cells) {
+		const key = JSON.stringify([
+			cell.candidateId,
+			cell.transferKey,
+			cell.stepOrdinal
+		]);
+		const group = groups.get(key) ?? {
+			candidateId: cell.candidateId,
+			transferKey: cell.transferKey,
+			stepOrdinal: cell.stepOrdinal,
+			rewardsBySequence: /* @__PURE__ */ new Map()
+		};
+		const rewards = group.rewardsBySequence.get(cell.sequenceId) ?? {
+			stateful: [],
+			stateless: []
+		};
+		rewards.stateful.push(cell.statefulReward);
+		rewards.stateless.push(cell.statelessReward);
+		group.rewardsBySequence.set(cell.sequenceId, rewards);
+		groups.set(key, group);
+	}
+	return [...groups.values()].sort((left, right) => left.candidateId.localeCompare(right.candidateId) || left.transferKey.localeCompare(right.transferKey) || left.stepOrdinal - right.stepOrdinal).map(({ candidateId, transferKey, stepOrdinal, rewardsBySequence }) => {
+		return {
+			candidateId,
+			transferKey,
+			stepOrdinal,
+			gain: comparePairedRewards([...rewardsBySequence.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([sequenceId, rewards]) => ({
+				pairKey: sequenceId,
+				statefulReward: mean$1(rewards.stateful),
+				statelessReward: mean$1(rewards.stateless)
+			})), seed, `transfer ${candidateId}:${transferKey}:${stepOrdinal}`)
+		};
+	});
+}
+function collapseLearningCells(cells) {
+	const bySequence = /* @__PURE__ */ new Map();
+	for (const cell of cells) {
+		const unit = bySequence.get(cell.sequenceId) ?? {
+			statefulRewards: [],
+			statelessRewards: []
+		};
+		unit.statefulRewards.push(cell.statefulReward);
+		unit.statelessRewards.push(cell.statelessReward);
+		bySequence.set(cell.sequenceId, unit);
+	}
+	return [...bySequence.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([sequenceId, unit]) => ({
+		pairKey: sequenceId,
+		statefulReward: mean$1(unit.statefulRewards),
+		statelessReward: mean$1(unit.statelessRewards)
+	}));
+}
+function summarizeForgetting(probes, seed) {
+	const byTarget = /* @__PURE__ */ new Map();
+	for (const probe of probes) {
+		const key = JSON.stringify([probe.sequenceId, probe.retentionKey]);
+		const unit = byTarget.get(key) ?? {
+			stateful: [],
+			stateless: [],
+			excess: []
+		};
+		unit.stateful.push(probe.statefulForgetting);
+		unit.stateless.push(probe.statelessForgetting);
+		unit.excess.push(probe.excessForgetting);
+		byTarget.set(key, unit);
+	}
+	const units = [...byTarget.entries()].map(([pairKey, unit]) => ({
+		pairKey,
+		statefulReward: mean$1(unit.stateful),
+		statelessReward: mean$1(unit.stateless),
+		excess: mean$1(unit.excess)
+	}));
+	return {
+		n: units.length,
+		meanStatefulForgetting: optionalMean(units.map((unit) => unit.statefulReward)),
+		meanStatelessForgetting: optionalMean(units.map((unit) => unit.statelessReward)),
+		meanExcessForgetting: optionalMean(units.map((unit) => unit.excess)),
+		excess: units.length === 0 ? null : comparePairedRewards(units, seed, "excess forgetting")
+	};
+}
+function comparePairedRewards(units, seed, label) {
+	const comparison = comparePairedArms(units.flatMap((unit) => [{
+		pairKey: unit.pairKey,
+		arm: "stateless",
+		metrics: { reward: unit.statelessReward }
+	}, {
+		pairKey: unit.pairKey,
+		arm: "stateful",
+		metrics: { reward: unit.statefulReward }
+	}]), {
+		baselineArm: "stateless",
+		treatmentArm: "stateful",
+		metricNames: ["reward"],
+		bootstrap: {
+			statistic: "mean",
+			seed
+		}
+	});
+	const metric = comparison.metricDeltas[0];
+	if (comparison.nPairs !== units.length || comparison.nUnpairedBaseline !== 0 || comparison.nUnpairedTreatment !== 0 || !metric || metric.n !== units.length || metric.nMissing !== 0 || !metric.bootstrapCi) throw new Error(`cannot compare memory learning: incomplete paired ${label}`);
+	return metric.bootstrapCi;
+}
+function maxProbe(probes, reward) {
+	let best = probes[0];
+	for (const probe of probes.slice(1)) if (reward(probe) > reward(best)) best = probe;
+	return {
+		reward: reward(best),
+		stepOrdinal: best.stateful.stepOrdinal
+	};
+}
+function optionalMean(values) {
+	return values.length === 0 ? null : mean$1(values);
+}
+function difference(left, right) {
+	const value = left - right;
+	return Object.is(value, -0) ? 0 : value;
+}
+function sortedUnique$1(values) {
+	return [...new Set(values)].sort();
+}
+function evidenceRef(value, label) {
+	if (typeof value === "string" && /^sha256:[a-f0-9]{64}$/.test(value)) return value;
+	if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)) throw new Error(`cannot compare memory learning: ${label} must be a full lowercase sha256 digest; received ${String(value)}`);
+	return `sha256:${value}`;
+}
+//#endregion
+//#region src/memory/experiment/comparison-ref.ts
+const MEMORY_EXPERIMENT_IMPLEMENTATION_REF = `sha256:${sha256(canonicalJson({
+	stateful: "retain declared sequence scopes across ordered steps",
+	stateless: "clear every declared sequence scope before each step after the first",
+	isolation: "provider scopes receive an opaque branch id but no experiment or sequence labels",
+	recovery: "unfinished attempts bind cleanup to the exact sequence sha256",
+	gain: "post-first-step stateful minus stateless reward",
+	inference: "average candidates and repetitions within each sequence before paired bootstrap",
+	preTreatment: "report first-step score balance separately from gain",
+	transfer: "only probes with explicit transferKey after the first step",
+	forgetting: "signed prior peak minus final score for exact repeated retentionKey probes",
+	evidence: "full sha256 design, manifest, split, artifact, and probe scoring-input references"
+}))}`;
+const COMPARISON_REF_PATTERN = /^sha256:[a-f0-9]{64}$/;
+function resolveAgentMemoryMode(value) {
+	if (value === void 0) return "stateful";
+	if (value !== "stateful" && value !== "stateless") throw new Error("memory experiment memoryMode must be 'stateful' or 'stateless'");
+	return value;
+}
+function memoryExperimentComparisonRef(options, resolvedRunDir) {
+	return `sha256:${sha256(canonicalJson({
+		implementationRef: MEMORY_EXPERIMENT_IMPLEMENTATION_REF,
+		experimentId: options.experimentId,
+		experimentRunId: options.experimentRunId ?? resolvedRunDir,
+		sequences: options.sequences,
+		candidates: options.candidates.map(candidateConditions),
+		recoveryCandidates: (options.recoveryCandidates ?? []).map(candidateConditions),
+		executeStepRef: options.executeStepRef ?? "fixtures",
+		cleanupBranches: options.cleanupBranches ?? true,
+		seed: options.seed ?? 42,
+		reps: options.reps ?? 1,
+		resumable: options.resumable ?? true,
+		costCeilingUsd: options.costCeiling ?? options.costLedger?.costCeilingUsd ?? 0,
+		costPhase: options.costPhase ?? null,
+		maxConcurrency: options.maxConcurrency ?? 2,
+		dispatchTimeoutMs: options.dispatchTimeoutMs || null,
+		cleanupTimeoutMs: options.cleanupTimeoutMs ?? 18e4,
+		maxRecoveryAttempts: options.maxRecoveryAttempts ?? 1e3,
+		maxRecoveryRetriesPerAttempt: options.maxRecoveryRetriesPerAttempt ?? 3
+	}))}`;
+}
+function assertAgentMemoryExperimentComparisonRef(value, label) {
+	if (typeof value !== "string" || !COMPARISON_REF_PATTERN.test(value)) throw new Error(`${label} must be a full lowercase sha256 reference`);
+}
+function candidateConditions(candidate) {
+	return {
+		id: candidate.id,
+		label: candidate.label ?? null,
+		ref: candidate.ref,
+		policy: candidate.policy ?? null,
+		baseScope: candidate.baseScope ?? null,
+		externalCostUsdPerSequence: candidate.externalCostUsdPerSequence ?? 0,
+		externalRecoveryCostUsdPerAttempt: candidate.externalRecoveryCostUsdPerAttempt ?? 0,
+		externalCostAccounting: candidate.externalCostAccounting ?? "exact"
+	};
+}
+//#endregion
+//#region src/memory/experiment/learning-pairs.ts
+function pairAgentMemoryLearningRuns(options) {
+	assertComparableDesign(options.stateful, options.stateless);
+	const statefulCells = indexCompleteCells("stateful", options.stateful);
+	const statelessCells = indexCompleteCells("stateless", options.stateless);
+	const matched = pairArms([...memoryLearningArmRows("stateful", statefulCells.values()), ...memoryLearningArmRows("stateless", statelessCells.values())], {
+		baselineArm: "stateless",
+		treatmentArm: "stateful"
+	});
+	if (matched.unpairedBaseline.length > 0 || matched.unpairedTreatment.length > 0) throw new Error(`cannot compare memory learning: unmatched experiment cell identities; stateful-only=${unpairedCellIds(matched.unpairedTreatment).join(", ") || "none"}; stateless-only=${unpairedCellIds(matched.unpairedBaseline).join(", ") || "none"}`);
+	return matched.pairs.map((pair) => {
+		const stateful = pair.treatment.indexed;
+		const stateless = pair.baseline.indexed;
+		if (stateful.cell.cellId !== stateless.cell.cellId) throw new Error(`cannot compare memory learning: cell identity differs for ${pair.pairKey} (${stateful.cell.cellId} vs ${stateless.cell.cellId})`);
+		return {
+			stateful,
+			stateless,
+			probes: pairProbes(stateful, stateless)
+		};
+	}).sort(comparePairedCells);
+}
+function memoryLearningArmRows(arm, cells) {
+	return [...cells].map((indexed) => ({
+		arm,
+		pairKey: JSON.stringify([indexed.artifact.candidateId, indexed.artifact.sequenceId]),
+		repKey: JSON.stringify([indexed.cell.rep, indexed.cell.seed]),
+		indexed
+	}));
+}
+function unpairedCellIds(rows) {
+	return rows.map((row) => row.indexed).map((indexed) => cellIdentity(indexed.artifact, indexed.cell.rep, indexed.cell.seed)).sort();
+}
+function assertComparableDesign(stateful, stateless) {
+	if (stateful.memoryMode !== "stateful") throw new Error(`cannot compare memory learning: stateful arm is labeled ${String(stateful.memoryMode)}`);
+	if (stateless.memoryMode !== "stateless") throw new Error(`cannot compare memory learning: stateless arm is labeled ${String(stateless.memoryMode)}`);
+	assertAgentMemoryExperimentComparisonRef(stateful.comparisonRef, "cannot compare memory learning: stateful comparisonRef");
+	assertAgentMemoryExperimentComparisonRef(stateless.comparisonRef, "cannot compare memory learning: stateless comparisonRef");
+	if (stateful.comparisonRef !== stateless.comparisonRef) throw new Error(`cannot compare memory learning: experimental conditions differ (${stateful.comparisonRef} vs ${stateless.comparisonRef})`);
+	if (stateful.campaign.manifestHash === stateless.campaign.manifestHash) throw new Error("cannot compare memory learning: campaign cache identity does not distinguish memoryMode");
+	assertRunSplitIdentity("stateful", stateful);
+	assertRunSplitIdentity("stateless", stateless);
+	if (stateful.campaign.splitDigest !== stateless.campaign.splitDigest) throw new Error("cannot compare memory learning: stateful and stateless task identities differ");
+	if (stateful.campaign.reps !== stateless.campaign.reps) throw new Error(`cannot compare memory learning: repetitions differ (${stateful.campaign.reps} vs ${stateless.campaign.reps})`);
+	if (stateful.campaign.seed !== stateless.campaign.seed) throw new Error(`cannot compare memory learning: campaign seeds differ (${stateful.campaign.seed} vs ${stateless.campaign.seed})`);
+	if (JSON.stringify(stateful.candidateRefs) !== JSON.stringify(stateless.candidateRefs) || stateful.candidateRefs.length === 0) throw new Error("cannot compare memory learning: candidate references differ between arms");
+	const candidateIds = /* @__PURE__ */ new Set();
+	for (const candidate of stateful.candidateRefs) {
+		assertNonEmpty(candidate.id, "candidate reference id");
+		if (candidateIds.has(candidate.id)) throw new Error(`cannot compare memory learning: duplicate candidate reference ${candidate.id}`);
+		candidateIds.add(candidate.id);
+		try {
+			assertImmutableRef(candidate.ref, `${candidate.id}: candidate reference`);
+		} catch (error) {
+			throw new Error(`cannot compare memory learning: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	if (stateful.executionRef !== stateless.executionRef) throw new Error("cannot compare memory learning: executor references differ between arms");
+	if (stateful.executionRef !== "fixtures") try {
+		assertImmutableRef(stateful.executionRef, "memory learning executor reference");
+	} catch (error) {
+		throw new Error(`cannot compare memory learning: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function assertRunSplitIdentity(arm, result) {
+	try {
+		assertCampaignSplitIdentity(result.campaign.scenarios, result.campaign.reps, result.campaign.splitDigest);
+	} catch (error) {
+		throw new Error(`cannot compare memory learning: ${arm} run has invalid task identity: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function indexCompleteCells(arm, result) {
+	const expectedCellIds = new Set(result.campaign.scenarios.flatMap((scenario) => Array.from({ length: result.campaign.reps }, (_, rep) => `${scenario.id}:${rep}`)));
+	const byIdentity = /* @__PURE__ */ new Map();
+	const seenCellIds = /* @__PURE__ */ new Set();
+	for (const cell of result.campaign.cells) {
+		if (!expectedCellIds.has(cell.cellId)) throw new Error(`cannot compare memory learning: ${arm} run has unexpected cell ${cell.cellId}`);
+		if (seenCellIds.has(cell.cellId)) throw new Error(`cannot compare memory learning: ${arm} run duplicates cell ${cell.cellId}`);
+		seenCellIds.add(cell.cellId);
+		if (cell.cellId !== `${cell.scenarioId}:${cell.rep}`) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} does not match its scenario and repetition`);
+		if (cell.manifestHash !== result.campaign.manifestHash) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} manifest differs from its campaign`);
+		if (cell.error) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} failed: ${cell.error}`);
+		const artifact = cell.artifact;
+		if (!artifact) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} has no artifact`);
+		assertArtifactIdentity(arm, result, cell, artifact);
+		if (!Number.isSafeInteger(cell.rep) || cell.rep < 0 || cell.rep >= result.campaign.reps) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} has invalid rep`);
+		if (!Number.isSafeInteger(cell.seed)) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} has invalid seed`);
+		assertReward(artifact.score, `${arm} cell ${cell.cellId} reward`);
+		if (artifact.probes.length === 0) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} has no probes`);
+		for (const probe of artifact.probes) assertProbe(arm, cell.cellId, probe);
+		const probeMean = mean$1(artifact.probes.map((probe) => probe.score));
+		if (Math.abs(probeMean - artifact.score) > 1e-12) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} reward does not equal its probe mean`);
+		const identity = cellIdentity(artifact, cell.rep, cell.seed);
+		if (byIdentity.has(identity)) throw new Error(`cannot compare memory learning: ${arm} run duplicates identity ${identity}`);
+		byIdentity.set(identity, {
+			cell,
+			artifact,
+			artifactRef: canonicalDigest(artifact)
+		});
+	}
+	const missing = [...expectedCellIds].filter((cellId) => !seenCellIds.has(cellId));
+	if (missing.length > 0) throw new Error(`cannot compare memory learning: ${arm} run is missing cells ${missing.sort().join(", ")}`);
+	return byIdentity;
+}
+function assertArtifactIdentity(arm, result, cell, artifact) {
+	assertNonEmpty(artifact.candidateId, `${arm} cell ${cell.cellId} candidateId`);
+	assertNonEmpty(artifact.sequenceId, `${arm} cell ${cell.cellId} sequenceId`);
+	if (!result.candidateRefs.some((candidate) => candidate.id === artifact.candidateId)) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} uses an undeclared candidate`);
+	if (artifact.memoryMode !== arm) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} artifact is labeled ${String(artifact.memoryMode)}`);
+	if (artifact.comparisonRef !== result.comparisonRef) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} comparisonRef differs from its run`);
+	if (!/^sha256:[a-f0-9]{64}$/.test(artifact.branchDigest)) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} has invalid branch evidence`);
+	const expectedScenarioId = `${stableId("candidate", artifact.candidateId)}:${artifact.sequenceId}`;
+	if (cell.scenarioId !== expectedScenarioId) throw new Error(`cannot compare memory learning: ${arm} cell ${cell.cellId} artifact identity does not match its scenario`);
+}
+function pairProbes(stateful, stateless) {
+	const statefulProbes = indexProbes("stateful", stateful);
+	const statelessProbes = indexProbes("stateless", stateless);
+	assertSameKeys(statefulProbes, statelessProbes, `probe in cell ${stateful.cell.cellId}`);
+	return [...statefulProbes.entries()].map(([key, statefulProbe]) => {
+		const statelessProbe = statelessProbes.get(key);
+		if (!statelessProbe) throw new Error(`cannot compare memory learning: missing stateless probe ${key} in ${stateful.cell.cellId}`);
+		if (statefulProbe.query !== statelessProbe.query) throw new Error(`cannot compare memory learning: probe query differs for ${key} in ${stateful.cell.cellId}`);
+		if (statefulProbe.retentionKey !== statelessProbe.retentionKey) throw new Error(`cannot compare memory learning: retention identity differs for ${key} in ${stateful.cell.cellId}`);
+		if (statefulProbe.transferKey !== statelessProbe.transferKey) throw new Error(`cannot compare memory learning: transfer identity differs for ${key} in ${stateful.cell.cellId}`);
+		if (sortedUnique(statefulProbe.applicableDimensions).join("\0") !== sortedUnique(statelessProbe.applicableDimensions).join("\0")) throw new Error(`cannot compare memory learning: measured dimensions differ for ${key} in ${stateful.cell.cellId}`);
+		return {
+			stateful: statefulProbe,
+			stateless: statelessProbe
+		};
+	}).sort((left, right) => left.stateful.stepOrdinal !== right.stateful.stepOrdinal ? left.stateful.stepOrdinal - right.stateful.stepOrdinal : left.stateful.id.localeCompare(right.stateful.id));
+}
+function indexProbes(arm, indexed) {
+	const probes = /* @__PURE__ */ new Map();
+	for (const probe of indexed.artifact.probes) {
+		const key = probeIdentity(probe);
+		if (probes.has(key)) throw new Error(`cannot compare memory learning: ${arm} cell ${indexed.cell.cellId} duplicates probe ${key}`);
+		probes.set(key, probe);
+	}
+	return probes;
+}
+function assertProbe(arm, cellId, probe) {
+	assertNonEmpty(probe.id, `${arm} cell ${cellId} probe id`);
+	assertNonEmpty(probe.stepId, `${arm} cell ${cellId} probe ${probe.id} stepId`);
+	assertNonEmpty(probe.query, `${arm} cell ${cellId} probe ${probe.id} query`);
+	if (!Number.isSafeInteger(probe.stepOrdinal) || probe.stepOrdinal < 0) throw new Error(`cannot compare memory learning: ${arm} cell ${cellId} probe ${probe.id} has invalid stepOrdinal`);
+	if (probe.retentionKey !== void 0) {
+		assertNonEmpty(probe.retentionKey, `${arm} cell ${cellId} probe ${probe.id} retentionKey`);
+		if (probe.retentionKey !== probe.retentionKey.trim()) throw new Error(`cannot compare memory learning: ${arm} cell ${cellId} probe ${probe.id} retentionKey has surrounding whitespace`);
+	}
+	if (probe.transferKey !== void 0) {
+		assertNonEmpty(probe.transferKey, `${arm} cell ${cellId} probe ${probe.id} transferKey`);
+		if (probe.transferKey !== probe.transferKey.trim()) throw new Error(`cannot compare memory learning: ${arm} cell ${cellId} probe ${probe.id} transferKey has surrounding whitespace`);
+		if (probe.retentionKey !== void 0 || probe.stepOrdinal === 0) throw new Error(`cannot compare memory learning: ${arm} cell ${cellId} probe ${probe.id} has invalid transfer placement`);
+	}
+	if (!/^sha256:[a-f0-9]{64}$/.test(probe.evidenceRef)) throw new Error(`cannot compare memory learning: ${arm} cell ${cellId} probe ${probe.id} has invalid evidence`);
+	const expectedEvidenceSuffix = `/memory-evidence/${probe.evidenceRef.slice(7)}.json`;
+	if (!probe.evidencePath.endsWith(expectedEvidenceSuffix)) throw new Error(`cannot compare memory learning: ${arm} cell ${cellId} probe ${probe.id} evidence is missing`);
+	assertReward(probe.score, `${arm} cell ${cellId} probe ${probe.id} reward`);
+}
+function assertReward(value, label) {
+	if (!Number.isFinite(value) || value < 0 || value > 1) throw new Error(`cannot compare memory learning: ${label} must be finite and between 0 and 1`);
+}
+function assertNonEmpty(value, label) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`cannot compare memory learning: ${label} must be a non-empty string`);
+}
+function assertSameKeys(left, right, label) {
+	const missingRight = [...left.keys()].filter((key) => !right.has(key));
+	const missingLeft = [...right.keys()].filter((key) => !left.has(key));
+	if (missingRight.length === 0 && missingLeft.length === 0) return;
+	throw new Error(`cannot compare memory learning: unmatched ${label} identities; stateful-only=${missingRight.sort().join(", ") || "none"}; stateless-only=${missingLeft.sort().join(", ") || "none"}`);
+}
+function cellIdentity(artifact, rep, seed) {
+	return JSON.stringify([
+		artifact.candidateId,
+		artifact.sequenceId,
+		rep,
+		seed
+	]);
+}
+function probeIdentity(probe) {
+	return JSON.stringify([
+		probe.stepOrdinal,
+		probe.stepId,
+		probe.id
+	]);
+}
+function comparePairedCells(left, right) {
+	return left.stateful.artifact.candidateId.localeCompare(right.stateful.artifact.candidateId) || left.stateful.artifact.sequenceId.localeCompare(right.stateful.artifact.sequenceId) || left.stateful.cell.rep - right.stateful.cell.rep || left.stateful.cell.seed - right.stateful.cell.seed;
+}
+function sortedUnique(values) {
+	return [...new Set(values)].sort();
+}
+//#endregion
 //#region src/memory/experiment/cost.ts
 function createAgentMemoryCostRecorder(input) {
 	let observedCostUsd = 0;
@@ -1265,6 +2076,7 @@ function createAgentMemoryExecutionContext(dispatch, sequence) {
 			signal: signal.signal,
 			cost
 		}),
+		abort: signal.abort,
 		dispose: signal.dispose
 	};
 }
@@ -1309,6 +2121,7 @@ function relayAbortWithoutReason(source) {
 	else source.addEventListener("abort", abort, { once: true });
 	return {
 		signal: controller.signal,
+		abort,
 		dispose() {
 			source.removeEventListener("abort", abort);
 		}
@@ -1361,85 +2174,6 @@ function redactPrivateValues(value, privateValues) {
 	return redacted;
 }
 //#endregion
-//#region src/memory/experiment/metrics.ts
-function rankAgentMemoryExperiment(candidates, scenarios, campaign, costByCandidate) {
-	const scenarioById = new Map(scenarios.map((scenario) => [scenario.id, scenario]));
-	return candidates.map((candidate) => {
-		const candidateScenarios = scenarios.filter((scenario) => scenario.candidateId === candidate.id);
-		const cells = campaign.cells.filter((cell) => scenarioById.get(cell.scenarioId)?.candidateId === candidate.id);
-		const successful = cells.filter((cell) => !cell.error && cell.artifact);
-		const dimensionRows = successful.map((cell) => cell.artifact.dimensions);
-		return {
-			rank: 0,
-			candidateId: candidate.id,
-			label: candidate.label ?? candidate.id,
-			scoreMean: mean$1(cells.map((cell) => !cell.error && cell.artifact ? cell.artifact.score : 0)),
-			passRate: mean$1(cells.map((cell) => !cell.error && cell.artifact?.passed ? 1 : 0)),
-			totalSequences: candidateScenarios.length,
-			totalCells: cells.length,
-			totalProbes: successful.reduce((sum, cell) => sum + cell.artifact.probes.length, 0),
-			cellsFailed: cells.filter((cell) => Boolean(cell.error)).length,
-			totalCostUsd: normalizeUsd(costByCandidate.get(candidate.id) ?? 0),
-			durationMs: cells.reduce((sum, cell) => sum + cell.durationMs, 0),
-			dimensions: meanDimensions(dimensionRows)
-		};
-	}).sort((a, b) => Number(a.cellsFailed > 0) - Number(b.cellsFailed > 0) || b.scoreMean - a.scoreMean || b.passRate - a.passRate || a.totalCostUsd - b.totalCostUsd || a.candidateId.localeCompare(b.candidateId)).map((row, index) => ({
-		...row,
-		rank: index + 1
-	}));
-}
-function memoryExperimentCostByCandidate(costLedger, runDir, scenarios, candidateIdsInput) {
-	const candidateByScenario = new Map(scenarios.map((scenario) => [scenario.id, scenario.candidateId]));
-	const candidateIds = new Set(candidateIdsInput);
-	const totals = /* @__PURE__ */ new Map();
-	for (const receipt of costLedger.list()) {
-		if (receipt.tags?.runDir !== runDir) continue;
-		const scenarioCandidate = receipt.tags.scenarioId ? candidateByScenario.get(receipt.tags.scenarioId) : void 0;
-		const recoveryCandidate = receipt.tags.memoryRecovery === "attempt" && receipt.tags.candidateId ? receipt.tags.candidateId : void 0;
-		const candidateId = scenarioCandidate ?? recoveryCandidate;
-		if (!candidateId || !candidateIds.has(candidateId)) continue;
-		totals.set(candidateId, (totals.get(candidateId) ?? 0) + receipt.costUsd);
-	}
-	return totals;
-}
-function renderAgentMemoryExperimentRanking(rows, totalCostUsd, unrankedRecoveryCostUsd) {
-	return [
-		"# Agent Memory Experiment",
-		"",
-		`- total cost: $${format(totalCostUsd)}`,
-		`- retired-candidate recovery cost: $${format(unrankedRecoveryCostUsd)}`,
-		"",
-		"| rank | candidate | sequences | cells | probes | failed | score | pass rate | cost | duration ms |",
-		"| ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
-		...rows.map((row) => `| ${row.rank} | ${row.label} | ${row.totalSequences} | ${row.totalCells} | ${row.totalProbes} | ${row.cellsFailed} | ${format(row.scoreMean)} | ${format(row.passRate)} | $${format(row.totalCostUsd)} | ${format(row.durationMs)} |`),
-		""
-	].join("\n");
-}
-function meanDimensions(rows) {
-	const values = /* @__PURE__ */ new Map();
-	for (const row of rows) for (const [key, value] of Object.entries(row)) {
-		if (!Number.isFinite(value)) continue;
-		const bucket = values.get(key) ?? [];
-		bucket.push(value);
-		values.set(key, bucket);
-	}
-	return Object.fromEntries([...values].map(([key, bucket]) => [key, mean$1(bucket)]));
-}
-function countDimensions(rows) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const row of rows) for (const key of new Set(row)) counts.set(key, (counts.get(key) ?? 0) + 1);
-	return Object.fromEntries(counts);
-}
-function mean$1(values) {
-	return values.length === 0 ? 0 : values.reduce((sum, value) => sum + value, 0) / values.length;
-}
-function format(value) {
-	return Number.isFinite(value) ? value.toFixed(4) : "0.0000";
-}
-function normalizeUsd(value) {
-	return Number(value.toFixed(12));
-}
-//#endregion
 //#region src/memory/experiment/runtime.ts
 var AgentMemoryCleanupError = class extends AggregateError {
 	constructor(errors, message) {
@@ -1487,12 +2221,8 @@ function mergeScopes$2(base, extra) {
 		}
 	};
 }
-function memoryExperimentBaseScope(options, candidate, sequenceId) {
-	return mergeScopes$2(candidate.baseScope, { tags: {
-		memoryExperimentId: options.experimentId,
-		memoryCandidateId: candidate.id,
-		memorySequenceId: sequenceId
-	} });
+function memoryExperimentBaseScope(candidate) {
+	return mergeScopes$2(candidate.baseScope);
 }
 function sequenceCleanupScopes(sequence) {
 	const scopes = /* @__PURE__ */ new Map();
@@ -1519,40 +2249,53 @@ async function clearSequenceScopes(memory, sequence) {
 //#endregion
 //#region src/memory/experiment/recovery.ts
 async function recoverAbandonedMemoryAttempts(input) {
+	input.options.signal?.throwIfAborted();
 	let attempts = readActiveMemoryAttempts(input.storage, input.attemptLogPath);
 	if (attempts.length > input.maxRecoveryAttempts) throw new Error(`memory experiment has ${attempts.length} unfinished attempts; maxRecoveryAttempts is ${input.maxRecoveryAttempts}`);
 	for (const attempt of attempts) {
 		const candidate = input.candidateById.get(attempt.candidateId);
 		if (!candidate) throw new Error(`cannot recover memory branch '${attempt.branchId}': candidate '${attempt.candidateId}' is missing; pass it in recoveryCandidates`);
 		assertMemoryAttemptCandidateMatches(attempt, candidate);
-		if (!input.sequenceById.has(attempt.sequenceId)) throw new Error(`cannot recover memory branch '${attempt.branchId}': sequence '${attempt.sequenceId}' is missing`);
+		const sequence = input.sequenceById.get(attempt.sequenceId);
+		if (!sequence) throw new Error(`cannot recover memory branch '${attempt.branchId}': sequence '${attempt.sequenceId}' is missing`);
+		assertMemoryAttemptSequenceMatches(attempt, sequence);
 		if ((input.options.cleanupBranches ?? true) !== attempt.cleanupBranches) throw new Error(`cannot recover memory branch '${attempt.branchId}': cleanupBranches changed`);
 	}
 	reconcileInterruptedMemoryPaidCalls(input.costLedger);
 	assertNoInterruptedPaidCalls(input.costLedger, "memory experiment recovery");
-	for (const attempt of attempts) if ((input.candidateById.get(attempt.candidateId).externalCostUsdPerSequence ?? 0) > 0 && !hasSettledPaidCall(input.costLedger, memoryAttemptCostCallId(attempt, "execute", 0))) appendMemoryAttemptEvent(input.storage, input.attemptLogPath, {
-		...attempt,
-		status: "cleaned",
-		recovery: true,
-		recordedAt: (input.options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
-	});
+	for (const attempt of attempts) if ((input.candidateById.get(attempt.candidateId).externalCostUsdPerSequence ?? 0) > 0 && !hasSettledPaidCall(input.costLedger, memoryAttemptCostCallId(attempt, "execute", 0))) {
+		await input.lease.assertOwned();
+		appendMemoryAttemptEvent(input.storage, input.attemptLogPath, {
+			...attempt,
+			status: "cleaned",
+			recovery: true,
+			recordedAt: (input.options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+		});
+	}
 	attempts = readActiveMemoryAttempts(input.storage, input.attemptLogPath);
-	const recoveryGenerations = reserveRecoveryAttempts({
-		storage: input.storage,
-		path: input.recoveryLogPath,
-		attemptIds: attempts.map((attempt) => attempt.branchId),
-		maxRetriesPerAttempt: input.maxRecoveryRetriesPerAttempt,
-		label: "memory recovery attempt log",
-		now: input.options.now
-	});
+	const recoveryGenerations = /* @__PURE__ */ new Map();
+	for (const attempt of attempts.sort((left, right) => left.branchId.localeCompare(right.branchId))) {
+		await input.lease.assertOwned();
+		const reserved = reserveRecoveryAttempts({
+			storage: input.storage,
+			path: input.recoveryLogPath,
+			attemptIds: [attempt.branchId],
+			maxRetriesPerAttempt: input.maxRecoveryRetriesPerAttempt,
+			label: "memory recovery attempt log",
+			now: input.options.now
+		});
+		recoveryGenerations.set(attempt.branchId, reserved.get(attempt.branchId));
+	}
 	const pool = createMemoryExecutionPool(input.maxConcurrency);
-	const failures = (await Promise.allSettled(attempts.sort((left, right) => left.branchId.localeCompare(right.branchId)).map((attempt) => pool.run(async () => {
+	const failures = (await Promise.allSettled(attempts.map((attempt) => pool.run(async () => {
+		input.options.signal?.throwIfAborted();
 		await input.lease.assertOwned();
 		const candidate = input.candidateById.get(attempt.candidateId);
 		if (!candidate) throw new Error(`cannot recover memory branch '${attempt.branchId}': candidate '${attempt.candidateId}' is missing; pass it in recoveryCandidates`);
 		assertMemoryAttemptCandidateMatches(attempt, candidate);
 		const sequence = input.sequenceById.get(attempt.sequenceId);
 		if (!sequence) throw new Error(`cannot recover memory branch '${attempt.branchId}': sequence '${attempt.sequenceId}' is missing`);
+		assertMemoryAttemptSequenceMatches(attempt, sequence);
 		if ((input.options.cleanupBranches ?? true) !== attempt.cleanupBranches) throw new Error(`cannot recover memory branch '${attempt.branchId}': cleanupBranches changed`);
 		const recoveryCostUsd = candidate.externalRecoveryCostUsdPerAttempt ?? 0;
 		const recoveryGeneration = recoveryGenerations.get(attempt.branchId);
@@ -1578,6 +2321,7 @@ async function recoverAbandonedMemoryAttempts(input) {
 					costRecorder.record(actualCostUsd);
 				}
 			});
+			await input.lease.assertOwned();
 			appendMemoryAttemptEvent(input.storage, input.attemptLogPath, {
 				...attempt,
 				status: "cleaned",
@@ -1615,34 +2359,30 @@ async function recoverMemoryAttempt(input) {
 	let memory;
 	let primaryError;
 	try {
-		const abortController = new AbortController();
-		const creation = Promise.resolve().then(() => candidate.createAdapter({
-			branchId: attempt.branchId,
-			purpose: "recovery",
-			signal: abortController.signal,
-			maximumCostUsd: candidate.externalRecoveryCostUsdPerAttempt ?? 0,
-			markExternalCall: onExternalCall,
-			recordExternalCost
-		}));
-		releaseMemoryAdapterCreatedAfterAbort({
-			creation,
-			signal: abortController.signal,
+		options.signal?.throwIfAborted();
+		const recovered = await createBoundedMemoryAdapter({
+			operation: `${candidate.id}: recovery adapter creation`,
+			timeoutMs: cleanupTimeoutMs,
+			signal: options.signal,
+			create: (signal) => candidate.createAdapter({
+				branchId: attempt.branchId,
+				purpose: "recovery",
+				signal,
+				maximumCostUsd: candidate.externalRecoveryCostUsdPerAttempt ?? 0,
+				markExternalCall: onExternalCall,
+				recordExternalCost
+			}),
 			dispose: candidate.disposeAdapter ? async (created) => {
 				onExternalCall();
 				await candidate.disposeAdapter?.(created);
 			} : void 0
 		});
-		const recovered = await runBoundedMemoryLifecycle({
-			operation: `${candidate.id}: recovery adapter creation`,
-			timeoutMs: cleanupTimeoutMs,
-			abortController,
-			run: () => creation
-		});
+		options.signal?.throwIfAborted();
 		await lease.assertOwned();
 		if (recovered === null) return;
 		rawAdapter = recovered;
 		adapter = trackExternalMemoryCalls(recovered, onExternalCall);
-		await sleepForMemoryRecovery(memoryRecoveryDelayMs(adapter), () => lease.assertOwned(), cleanupTimeoutMs, `${candidate.id}: abandoned branch recovery visibility wait`);
+		await sleepForMemoryRecovery(memoryRecoveryDelayMs(adapter), () => lease.assertOwned(), cleanupTimeoutMs, `${candidate.id}: abandoned branch recovery visibility wait`, options.signal);
 		if (cleanupBranches) {
 			if (!adapter.clear) throw new Error(`${candidate.id}: abandoned branch recovery requires an adapter with scoped clear support`);
 			memory = createAgentMemoryBranch({
@@ -1651,7 +2391,7 @@ async function recoverMemoryAttempt(input) {
 				lifetime: "attempt",
 				policy: candidate.policy,
 				allowedWriteScopes: sequenceCleanupScopes(sequence),
-				baseScope: memoryExperimentBaseScope(options, candidate, sequence.id)
+				baseScope: memoryExperimentBaseScope(candidate)
 			});
 			await runBoundedMemoryLifecycle({
 				operation: `${candidate.id}: abandoned branch cleanup`,
@@ -1713,6 +2453,7 @@ function memoryAttemptCostCallId(attempt, purpose, generation) {
 		externalCostUsdPerSequence: attempt.externalCostUsdPerSequence,
 		externalRecoveryCostUsdPerAttempt: attempt.externalRecoveryCostUsdPerAttempt,
 		sequenceId: attempt.sequenceId,
+		sequenceRef: attempt.sequenceRef,
 		rep: attempt.rep,
 		seed: attempt.seed
 	}));
@@ -1732,6 +2473,7 @@ function memoryAttemptEvent(input) {
 		candidateId: input.candidate.id,
 		candidateRef: input.candidate.ref,
 		sequenceId: input.sequence.id,
+		sequenceRef: canonicalDigest(input.sequence),
 		rep: input.rep,
 		seed: input.seed,
 		cleanupBranches: input.cleanupBranches ?? true,
@@ -1761,11 +2503,14 @@ function readActiveMemoryAttempts(storage, path) {
 }
 function parseMemoryAttemptEvent(value, path, line) {
 	const event = value;
-	if (!(typeof event === "object" && event !== null && (event.status === "started" || event.status === "cleaned") && typeof event.branchId === "string" && event.branchId.length > 0 && typeof event.candidateId === "string" && event.candidateId.length > 0 && typeof event.candidateRef === "string" && event.candidateRef.length > 0 && typeof event.sequenceId === "string" && event.sequenceId.length > 0 && Number.isSafeInteger(event.rep) && Number.isSafeInteger(event.seed) && typeof event.cleanupBranches === "boolean" && typeof event.externalCostUsdPerSequence === "number" && Number.isFinite(event.externalCostUsdPerSequence) && event.externalCostUsdPerSequence >= 0 && typeof event.externalRecoveryCostUsdPerAttempt === "number" && Number.isFinite(event.externalRecoveryCostUsdPerAttempt) && event.externalRecoveryCostUsdPerAttempt >= 0 && typeof event.recordedAt === "string" && !Number.isNaN(Date.parse(event.recordedAt)) && typeof event.recovery === "boolean")) throw new Error(`invalid memory attempt event in '${path}' line ${line}`);
+	if (!(typeof event === "object" && event !== null && (event.status === "started" || event.status === "cleaned") && typeof event.branchId === "string" && event.branchId.length > 0 && typeof event.candidateId === "string" && event.candidateId.length > 0 && typeof event.candidateRef === "string" && event.candidateRef.length > 0 && typeof event.sequenceId === "string" && event.sequenceId.length > 0 && typeof event.sequenceRef === "string" && /^sha256:[a-f0-9]{64}$/.test(event.sequenceRef) && Number.isSafeInteger(event.rep) && Number.isSafeInteger(event.seed) && typeof event.cleanupBranches === "boolean" && typeof event.externalCostUsdPerSequence === "number" && Number.isFinite(event.externalCostUsdPerSequence) && event.externalCostUsdPerSequence >= 0 && typeof event.externalRecoveryCostUsdPerAttempt === "number" && Number.isFinite(event.externalRecoveryCostUsdPerAttempt) && event.externalRecoveryCostUsdPerAttempt >= 0 && typeof event.recordedAt === "string" && !Number.isNaN(Date.parse(event.recordedAt)) && typeof event.recovery === "boolean")) throw new Error(`invalid memory attempt event in '${path}' line ${line}`);
 	return value;
 }
 function sameMemoryAttempt(left, right) {
-	return left.branchId === right.branchId && left.candidateId === right.candidateId && left.candidateRef === right.candidateRef && left.sequenceId === right.sequenceId && left.rep === right.rep && left.seed === right.seed && left.cleanupBranches === right.cleanupBranches && left.externalCostUsdPerSequence === right.externalCostUsdPerSequence && left.externalRecoveryCostUsdPerAttempt === right.externalRecoveryCostUsdPerAttempt;
+	return left.branchId === right.branchId && left.candidateId === right.candidateId && left.candidateRef === right.candidateRef && left.sequenceId === right.sequenceId && left.sequenceRef === right.sequenceRef && left.rep === right.rep && left.seed === right.seed && left.cleanupBranches === right.cleanupBranches && left.externalCostUsdPerSequence === right.externalCostUsdPerSequence && left.externalRecoveryCostUsdPerAttempt === right.externalRecoveryCostUsdPerAttempt;
+}
+function assertMemoryAttemptSequenceMatches(attempt, sequence) {
+	if (canonicalDigest(sequence) !== attempt.sequenceRef) throw new Error(`cannot recover memory branch '${attempt.branchId}': sequence '${attempt.sequenceId}' changed; restore the recorded sequence before cleanup`);
 }
 function assertMemoryAttemptCandidateMatches(attempt, candidate) {
 	if (candidate.ref !== attempt.candidateRef) throw new Error(`cannot recover memory branch '${attempt.branchId}': candidate ref changed from '${attempt.candidateRef}' to '${candidate.ref}'`);
@@ -1775,8 +2520,11 @@ function assertMemoryAttemptCandidateMatches(attempt, candidate) {
 }
 //#endregion
 //#region src/memory/experiment/cell.ts
+var AgentMemoryAdapterCapabilityError = class extends Error {
+	name = "AgentMemoryAdapterCapabilityError";
+};
 async function runSequenceCell(input) {
-	const { options, candidate, scenario, context, runIdentity, storage, attemptLogPath, lease } = input;
+	const { options, candidate, scenario, context, runIdentity, storage, attemptLogPath, lease, memoryMode, comparisonRef } = input;
 	const cleanupBranches = options.cleanupBranches ?? true;
 	const costUsd = candidate.externalCostUsdPerSequence ?? 0;
 	if (!Number.isFinite(costUsd) || costUsd < 0) throw new Error(`${candidate.id}: externalCostUsdPerSequence must be a non-negative finite number`);
@@ -1797,6 +2545,7 @@ async function runSequenceCell(input) {
 		cleanupBranches,
 		now: options.now
 	});
+	await lease.assertOwned();
 	appendMemoryAttemptEvent(storage, attemptLogPath, attempt);
 	let externalCallAttempted = false;
 	const costRecorder = createAgentMemoryCostRecorder({
@@ -1826,18 +2575,27 @@ async function runSequenceCell(input) {
 		let finalClearStarted = false;
 		let finalClearCompleted = false;
 		try {
-			const created = await candidate.createAdapter({
-				branchId,
-				purpose: "execute",
+			const created = await createBoundedMemoryAdapter({
+				operation: `${candidate.id}: execution adapter creation`,
+				timeoutMs: cleanupTimeoutMs,
 				signal: context.signal,
-				maximumCostUsd: costUsd,
-				markExternalCall: () => {
-					externalCallAttempted = true;
-				},
-				recordExternalCost: (actualCostUsd) => {
+				create: (signal) => candidate.createAdapter({
+					branchId,
+					purpose: "execute",
+					signal,
+					maximumCostUsd: costUsd,
+					markExternalCall: () => {
+						externalCallAttempted = true;
+					},
+					recordExternalCost: (actualCostUsd) => {
+						externalCallAttempted = true;
+						costRecorder.record(actualCostUsd);
+					}
+				}),
+				dispose: candidate.disposeAdapter ? async (lateAdapter) => {
 					externalCallAttempted = true;
-					costRecorder.record(actualCostUsd);
-				}
+					await candidate.disposeAdapter?.(lateAdapter);
+				} : void 0
 			});
 			if (!created) throw new Error(`${candidate.id}: createAdapter returned no execution adapter`);
 			rawAdapter = created;
@@ -1846,6 +2604,7 @@ async function runSequenceCell(input) {
 			});
 			await lease.assertOwned();
 			context.signal.throwIfAborted();
+			if (memoryMode === "stateless" && !adapter.clear) throw new AgentMemoryAdapterCapabilityError(`${candidate.id}: stateless memoryMode requires scoped clear support`);
 			if (cleanupBranches && !adapter.clear) throw new Error(`${candidate.id}: cleanupBranches requires an adapter with scoped clear support`);
 			memory = createAgentMemoryBranch({
 				adapter,
@@ -1853,40 +2612,67 @@ async function runSequenceCell(input) {
 				lifetime: "attempt",
 				policy: candidate.policy,
 				allowedWriteScopes: sequenceCleanupScopes(scenario.sequence),
-				baseScope: memoryExperimentBaseScope(options, candidate, scenario.sequenceId)
+				baseScope: memoryExperimentBaseScope(candidate)
+			});
+			const runProviderOperation = (operation, run) => runBoundedMemoryLifecycle({
+				operation,
+				timeoutMs: cleanupTimeoutMs,
+				resource: adapter,
+				signal: context.signal,
+				cancellationTimeoutMs: MEMORY_OPERATION_CANCELLATION_TIMEOUT_MS,
+				run
 			});
 			const probes = [];
 			for (const [ordinal, step] of scenario.sequence.steps.entries()) {
 				context.signal.throwIfAborted();
 				await lease.assertOwned();
-				await writeStep(memory, step);
+				if (memoryMode === "stateless" && ordinal > 0) {
+					await runBoundedMemoryLifecycle({
+						operation: `${candidate.id}: stateless reset before step ${step.id}`,
+						timeoutMs: cleanupTimeoutMs,
+						resource: adapter,
+						run: () => clearSequenceScopes(memory, scenario.sequence)
+					});
+					context.signal.throwIfAborted();
+					await lease.assertOwned();
+				}
+				await runProviderOperation(`${candidate.id}: writes for step ${step.id}`, () => writeStep(memory, step));
 				await lease.assertOwned();
 				if (options.executeStep) {
 					const execution = createAgentMemoryExecutionContext(context, scenario.sequence);
 					try {
-						await options.executeStep({
+						await runProviderOperation(`${candidate.id}: execution for step ${step.id}`, () => options.executeStep({
 							memory,
 							candidateId: candidate.id,
 							step: executionStep(step, ordinal),
 							context: execution.context
-						});
+						}));
+					} catch (error) {
+						execution.abort();
+						throw error;
 					} finally {
 						execution.dispose();
 					}
 				}
 				context.signal.throwIfAborted();
 				await lease.assertOwned();
-				const stepProbes = await probeStep(memory, scenario.sequence, step);
+				const stepProbes = await runProviderOperation(`${candidate.id}: probes for step ${step.id}`, () => probeStep(memory, scenario.sequence, step, ordinal, context));
 				await lease.assertOwned();
 				probes.push(...stepProbes);
 			}
-			const snapshot = await memory.snapshot();
+			const snapshot = await runProviderOperation(`${candidate.id}: branch snapshot`, () => memory.snapshot());
 			await lease.assertOwned();
-			await options.onBranchSnapshot?.({
-				candidateId: candidate.id,
-				sequenceId: scenario.sequenceId,
-				cellId: context.cellId,
-				snapshot
+			if (options.onBranchSnapshot) await runBoundedMemoryLifecycle({
+				operation: `${candidate.id}: branch snapshot callback`,
+				timeoutMs: cleanupTimeoutMs,
+				signal: context.signal,
+				cancellationTimeoutMs: MEMORY_OPERATION_CANCELLATION_TIMEOUT_MS,
+				run: () => options.onBranchSnapshot({
+					candidateId: candidate.id,
+					sequenceId: scenario.sequenceId,
+					cellId: context.cellId,
+					snapshot
+				})
 			});
 			await lease.assertOwned();
 			const dimensions = meanDimensions(probes.map((probe) => probe.dimensions));
@@ -1894,6 +2680,8 @@ async function runSequenceCell(input) {
 			const artifact = {
 				candidateId: candidate.id,
 				sequenceId: scenario.sequenceId,
+				memoryMode,
+				comparisonRef,
 				score: mean$1(probes.map((probe) => probe.score)),
 				passed: probes.length > 0 && probes.every((probe) => probe.passed),
 				dimensions,
@@ -1969,6 +2757,12 @@ async function runSequenceCell(input) {
 				cleanupErrors.push(error);
 			}
 		} else cleanupErrors.push(/* @__PURE__ */ new Error(`${candidate.id}: adapter creation failed before cleanup could be confirmed`));
+		if (cleanupOwned && cleanupErrors.length === 0) try {
+			await lease.assertOwned();
+		} catch (error) {
+			cleanupOwned = false;
+			ownershipError = error;
+		}
 		if (cleanupOwned && cleanupErrors.length === 0) appendCleanedAttempt(primaryError);
 		if (!cleanupOwned && cleanupErrors.length === 0) {
 			if (primaryError) throw primaryError;
@@ -2028,46 +2822,38 @@ async function writeStep(memory, step) {
 	}
 	for (const write of writes) await memory.write(write);
 }
-async function probeStep(memory, sequence, step) {
+async function probeStep(memory, sequence, step, stepOrdinal, dispatch) {
 	const run = async (probe) => {
 		const scope = mergeScopes$2(step.scope, probe.scope);
 		const context = await memory.getContext(probe.query, {
 			scope,
 			limit: probe.limit
 		});
-		const artifact = {
+		const scoringEvidence = {
 			answer: context.text,
 			rememberedFacts: context.hits.map((hit) => hit.text),
 			citedEventIds: uniqueStrings$1([...context.hits.map((hit) => hit.metadata?.eventId), ...context.hits.flatMap((hit) => stringArray$1(hit.metadata?.eventIds))]),
 			usedMemoryIds: context.hits.map((hit) => hit.id),
 			actorIds: uniqueStrings$1([...context.hits.map((hit) => hit.metadata?.actorId), ...context.hits.flatMap((hit) => stringArray$1(hit.metadata?.actorIds))])
 		};
-		const evaluation = scoreMemoryBenchmarkArtifact({
-			id: `${sequence.id}:${step.id}:${probe.id}`,
-			family: sequence.family,
-			taskKind: probe.taskKind ?? "memory-recall",
-			split: sequence.split,
-			events: [],
-			prompt: probe.query,
-			requiredFacts: probe.requiredFacts && probe.requiredFacts.length > 0 ? probe.requiredFacts : probe.referenceAnswer ? [{
-				id: `${probe.id}:reference`,
-				anyOf: [probe.referenceAnswer]
-			}] : void 0,
-			forbiddenFacts: probe.forbiddenFacts,
-			expectedEventIds: probe.expectedEventIds,
-			expectedActorIds: probe.expectedActorIds,
-			referenceAnswer: probe.referenceAnswer
-		}, artifact);
+		const evidenceRef = canonicalDigest(scoringEvidence);
+		const evidencePath = await dispatch.artifacts.writeJson(`memory-evidence/${evidenceRef.slice(7)}.json`, scoringEvidence);
+		const evaluation = scoreAgentMemoryProbe(sequence, step, probe, scoringEvidence);
 		return {
 			id: probe.id,
 			stepId: step.id,
+			stepOrdinal,
+			...probe.retentionKey !== void 0 ? { retentionKey: probe.retentionKey } : {},
+			...probe.transferKey !== void 0 ? { transferKey: probe.transferKey } : {},
 			query: probe.query,
 			score: evaluation.score,
 			passed: evaluation.passed,
 			dimensions: evaluation.dimensions,
 			applicableDimensions: evaluation.applicableDimensions ?? Object.keys(evaluation.dimensions),
 			notes: evaluation.notes,
-			hitIds: context.hits.map((hit) => hit.id)
+			hitIds: context.hits.map((hit) => hit.id),
+			evidenceRef,
+			evidencePath
 		};
 	};
 	if (step.parallelProbes === false) {
@@ -2079,12 +2865,13 @@ async function probeStep(memory, sequence, step) {
 }
 //#endregion
 //#region src/memory/experiment/run.ts
-const MEMORY_EXPERIMENT_IMPLEMENTATION_REF = "agent-knowledge:memory-experiment:v6";
 /** Runs ordered, branch-isolated memory histories across candidate systems. */
 async function runAgentMemoryExperiment(options) {
+	options.signal?.throwIfAborted();
 	assertNonEmptyString(options.experimentId, "memory experiment experimentId");
 	assertNonEmptyString(options.runDir, "memory experiment runDir");
 	if (options.experimentRunId !== void 0) assertNonEmptyString(options.experimentRunId, "memory experiment experimentRunId");
+	resolveAgentMemoryMode(options.memoryMode);
 	if (options.sequences.length === 0) throw new Error("memory experiment requires sequences");
 	if (options.candidates.length === 0) throw new Error("memory experiment requires candidates");
 	if (options.executeStep && !options.executeStepRef) throw new Error("memory experiment executeStepRef is required when executeStep is configured");
@@ -2139,9 +2926,12 @@ async function runAgentMemoryExperiment(options) {
 	return result;
 }
 async function runOwnedAgentMemoryExperiment(options, storage, runDir, lease) {
+	const memoryMode = resolveAgentMemoryMode(options.memoryMode);
+	const comparisonRef = memoryExperimentComparisonRef(options, runDir);
 	const runIdentity = stableId("memory_run", canonicalJson({
 		experimentId: options.experimentId,
-		experimentRunId: options.experimentRunId ?? runDir
+		experimentRunId: options.experimentRunId ?? runDir,
+		memoryMode
 	}));
 	const maxConcurrency = options.maxConcurrency ?? 2;
 	if (!Number.isSafeInteger(maxConcurrency) || maxConcurrency <= 0) throw new Error("memory experiment maxConcurrency must be a positive safe integer");
@@ -2175,6 +2965,7 @@ async function runOwnedAgentMemoryExperiment(options, storage, runDir, lease) {
 		recoveryLogPath,
 		maxRecoveryRetriesPerAttempt: options.maxRecoveryRetriesPerAttempt ?? 3
 	});
+	options.signal?.throwIfAborted();
 	await lease.assertOwned();
 	let campaign;
 	let campaignError;
@@ -2182,6 +2973,7 @@ async function runOwnedAgentMemoryExperiment(options, storage, runDir, lease) {
 	try {
 		campaign = await runCampaign({
 			scenarios,
+			signal: options.signal,
 			dispatch: (scenario, context) => {
 				const candidate = candidateById.get(scenario.candidateId);
 				if (!candidate) throw new Error(`unknown memory candidate ${scenario.candidateId}`);
@@ -2193,12 +2985,14 @@ async function runOwnedAgentMemoryExperiment(options, storage, runDir, lease) {
 					runIdentity,
 					storage,
 					attemptLogPath,
-					lease
+					lease,
+					memoryMode,
+					comparisonRef
 				}));
 				dispatchedExecutions.push(operation);
 				return operation;
 			},
-			dispatchRef: memoryExperimentDispatchRef(options),
+			dispatchRef: memoryExperimentDispatchRef(memoryMode, comparisonRef),
 			judges: [agentMemorySequenceJudge()],
 			runDir,
 			storage,
@@ -2210,6 +3004,7 @@ async function runOwnedAgentMemoryExperiment(options, storage, runDir, lease) {
 			costPhase: options.costPhase,
 			maxConcurrency,
 			dispatchTimeoutMs: options.dispatchTimeoutMs,
+			dispatchShutdownTimeoutMs: MEMORY_CAMPAIGN_DISPATCH_SHUTDOWN_TIMEOUT_MS,
 			expectUsage: "off",
 			now: options.now
 		});
@@ -2219,9 +3014,14 @@ async function runOwnedAgentMemoryExperiment(options, storage, runDir, lease) {
 		settledExecutions = await Promise.allSettled(dispatchedExecutions);
 	}
 	const cleanupFailures = settledExecutions.flatMap((settled) => settled.status === "rejected" && settled.reason instanceof AgentMemoryCleanupError ? [settled.reason] : []);
-	if (campaignError && cleanupFailures.length > 0) throw new AggregateError([campaignError, ...cleanupFailures], "memory experiment failed and provider cleanup also failed");
+	const capabilityFailures = settledExecutions.flatMap((settled) => settled.status === "rejected" && settled.reason instanceof AgentMemoryAdapterCapabilityError ? [settled.reason] : []);
+	const terminalFailures = [...cleanupFailures, ...capabilityFailures];
+	if (campaignError && terminalFailures.length > 0) throw new AggregateError([campaignError, ...terminalFailures], "memory experiment failed with terminal dispatch errors");
 	if (campaignError) throw campaignError;
+	if (cleanupFailures.length > 0 && capabilityFailures.length > 0) throw new AggregateError(terminalFailures, "memory experiment adapter requirements and provider cleanup failed");
 	if (cleanupFailures.length > 0) throw new AggregateError(cleanupFailures, "memory experiment cleanup failed after dispatch");
+	if (capabilityFailures.length === 1) throw capabilityFailures[0];
+	if (capabilityFailures.length > 1) throw new AggregateError(capabilityFailures, "memory experiment adapter requirements failed");
 	if (!campaign) throw new Error("memory experiment produced no campaign result");
 	await lease.assertOwned();
 	const costByCandidate = memoryExperimentCostByCandidate(costLedger, campaign.runDir, scenarios, [...options.candidates, ...options.recoveryCandidates ?? []].map((candidate) => candidate.id));
@@ -2232,12 +3032,26 @@ async function runOwnedAgentMemoryExperiment(options, storage, runDir, lease) {
 	const rankingMarkdownPath = join(campaign.runDir, "memory-experiment-ranking.md");
 	storage.write(rankingJsonPath, `${JSON.stringify({
 		experimentId: options.experimentId,
+		memoryMode,
+		comparisonRef,
+		candidateRefs: options.candidates.map(({ id, ref }) => ({
+			id,
+			ref
+		})),
+		executionRef: options.executeStepRef ?? "fixtures",
 		totalCostUsd,
 		unrankedRecoveryCostUsd,
 		rows
 	}, null, 2)}\n`);
 	storage.write(rankingMarkdownPath, renderAgentMemoryExperimentRanking(rows, totalCostUsd, unrankedRecoveryCostUsd));
 	return {
+		memoryMode,
+		comparisonRef,
+		candidateRefs: options.candidates.map(({ id, ref }) => ({
+			id,
+			ref
+		})),
+		executionRef: options.executeStepRef ?? "fixtures",
 		campaign,
 		rows,
 		totalCostUsd,
@@ -2249,25 +3063,98 @@ async function runOwnedAgentMemoryExperiment(options, storage, runDir, lease) {
 		recoveryLogPath
 	};
 }
-function memoryExperimentDispatchRef(options) {
+function memoryExperimentDispatchRef(memoryMode, comparisonRef) {
 	return stableId("memory_experiment", canonicalJson({
 		implementationRef: MEMORY_EXPERIMENT_IMPLEMENTATION_REF,
-		experimentId: options.experimentId,
-		experimentRunId: options.experimentRunId ?? null,
-		executeStepRef: options.executeStepRef ?? "fixtures",
-		cleanupBranches: options.cleanupBranches ?? true,
-		candidates: options.candidates.map((candidate) => ({
-			id: candidate.id,
-			ref: candidate.ref,
-			policy: candidate.policy ?? null,
-			baseScope: candidate.baseScope ?? null,
-			externalCostUsdPerSequence: candidate.externalCostUsdPerSequence ?? 0,
-			externalRecoveryCostUsdPerAttempt: candidate.externalRecoveryCostUsdPerAttempt ?? 0,
-			externalCostAccounting: candidate.externalCostAccounting ?? "exact"
-		})).sort((a, b) => a.id.localeCompare(b.id))
+		memoryMode,
+		comparisonRef
 	}));
 }
 //#endregion
+//#region src/memory/experiment/learning.ts
+/** Compare exact matched stateful and stateless memory runs. */
+function compareAgentMemoryLearning(options) {
+	return measureAgentMemoryLearning(pairAgentMemoryLearningRuns(options), options.stateful, options.stateless);
+}
+/** Run a matched stateful-versus-stateless memory experiment under one cost limit. */
+async function runAgentMemoryLearningExperiment(options) {
+	assertNonEmptyString(options.runDir, "memory learning experiment runDir");
+	options.signal?.throwIfAborted();
+	assertMemoryLearningSequences(options.sequences);
+	for (const candidate of [...options.candidates, ...options.recoveryCandidates ?? []]) assertImmutableRef(candidate.ref, `${candidate.id}: memory learning candidate ref`);
+	if (options.executeStep) assertImmutableRef(options.executeStepRef, "memory learning experiment executeStepRef");
+	const storage = options.storage ?? fsCampaignStorage();
+	const runDir = resolveRunDir(options.runDir, options.repo);
+	storage.ensureDir(runDir);
+	const costCeiling = options.costCeiling ?? options.costLedger?.costCeilingUsd ?? 0;
+	const costLedger = options.costLedger ?? createRunCostLedger({
+		storage,
+		runDir,
+		costCeilingUsd: costCeiling
+	});
+	if (costLedger.costCeilingUsd !== costCeiling) throw new Error("memory learning experiment costCeiling must match the shared cost ledger ceiling");
+	const armOrder = options.armOrder ?? "stateful-first";
+	if (armOrder !== "stateful-first" && armOrder !== "stateless-first") throw new Error("memory learning experiment armOrder must be 'stateful-first' or 'stateless-first'");
+	const { armOrder: _armOrder, ...experimentOptions } = options;
+	const shared = {
+		...experimentOptions,
+		experimentRunId: options.experimentRunId ?? runDir,
+		costCeiling,
+		costLedger
+	};
+	const runArm = async (memoryMode) => {
+		const result = await runAgentMemoryExperiment({
+			...shared,
+			memoryMode,
+			runDir: armRunDir(runDir, memoryMode)
+		});
+		assertStoredAgentMemoryEvidence(storage, result, options.sequences);
+		return result;
+	};
+	const firstMode = armOrder === "stateful-first" ? "stateful" : "stateless";
+	const secondMode = firstMode === "stateful" ? "stateless" : "stateful";
+	const first = await runArm(firstMode);
+	const second = await runArm(secondMode);
+	const stateful = firstMode === "stateful" ? first : second;
+	const stateless = firstMode === "stateless" ? first : second;
+	const comparison = compareAgentMemoryLearning({
+		stateful,
+		stateless
+	});
+	const ledgerSummary = costLedger.summary();
+	const cost = {
+		experimentUsd: normalizeUsd(stateful.totalCostUsd + stateless.totalCostUsd),
+		ledgerUsd: normalizeUsd(ledgerSummary.totalCostUsd),
+		ceilingUsd: costLedger.costCeilingUsd,
+		accountingComplete: ledgerSummary.accountingComplete
+	};
+	const report = {
+		armOrder,
+		comparison,
+		cost
+	};
+	const evidenceRef = canonicalDigest(report);
+	const comparisonDir = armRunDir(runDir, "comparisons");
+	storage.ensureDir(comparisonDir);
+	const comparisonPath = armRunDir(comparisonDir, `${evidenceRef.slice(7)}.json`);
+	storage.write(comparisonPath, `${JSON.stringify({
+		evidenceRef,
+		...report
+	}, null, 2)}\n`);
+	return {
+		armOrder,
+		stateful,
+		stateless,
+		comparison,
+		evidenceRef,
+		comparisonPath,
+		cost
+	};
+}
+function armRunDir(runDir, child) {
+	return runDir.startsWith("mem://") ? `${runDir.replace(/\/+$/, "")}/${child}` : join(runDir, child);
+}
+//#endregion
 //#region src/memory/graphiti.ts
 const DEFAULT_GRAPHITI_INGESTION_TIMEOUT_MS = 12e4;
 /** Connects the official Graphiti MCP server without coupling to its Python internals. */
@@ -2949,7 +3836,8 @@ async function evaluateMemoryCandidate(input) {
 				reps: 1,
 				maxConcurrency: 1,
 				costCeiling: evaluationCostLimit,
-				costPhase: `memory.config.${input.surfaceHash}`
+				costPhase: `memory.config.${input.surfaceHash}`,
+				signal: input.signal
 			});
 			const cell = experiment.campaign.cells[0];
 			if (!cell || cell.error || cell.artifact.candidateId !== input.candidate.id) throw new Error(`${input.surfaceHash}/${input.scenario.sequenceId}: memory config evaluation did not complete`);
@@ -3083,9 +3971,20 @@ function storedMemoryArtifactRecord(input, artifact) {
 function parseMemoryArtifact(value, candidateId, sequenceId, path) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`memory config artifact '${path}' has no artifact`);
 	const artifact = value;
-	if (artifact.candidateId !== candidateId || artifact.sequenceId !== sequenceId || typeof artifact.score !== "number" || !Number.isFinite(artifact.score) || artifact.score < 0 || artifact.score > 1 || typeof artifact.passed !== "boolean" || !isFiniteNumberRecord(artifact.dimensions) || !isNonnegativeIntegerRecord(artifact.dimensionSampleCounts) || !Array.isArray(artifact.probes) || typeof artifact.branchDigest !== "string" || !artifact.branchDigest || typeof artifact.journalEntries !== "number" || !Number.isSafeInteger(artifact.journalEntries) || artifact.journalEntries < 0 || typeof artifact.durationMs !== "number" || !Number.isFinite(artifact.durationMs) || artifact.durationMs < 0) throw new Error(`memory config artifact '${path}' is malformed`);
+	try {
+		assertAgentMemoryExperimentComparisonRef(artifact.comparisonRef, `memory config artifact '${path}' comparisonRef`);
+	} catch {
+		throw new Error(`memory config artifact '${path}' is malformed`);
+	}
+	if (artifact.candidateId !== candidateId || artifact.sequenceId !== sequenceId || artifact.memoryMode !== "stateful" || typeof artifact.score !== "number" || !Number.isFinite(artifact.score) || artifact.score < 0 || artifact.score > 1 || typeof artifact.passed !== "boolean" || !isFiniteNumberRecord(artifact.dimensions) || !isNonnegativeIntegerRecord(artifact.dimensionSampleCounts) || !Array.isArray(artifact.probes) || !artifact.probes.every(isMemoryProbeResult) || typeof artifact.branchDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(artifact.branchDigest) || typeof artifact.journalEntries !== "number" || !Number.isSafeInteger(artifact.journalEntries) || artifact.journalEntries < 0 || typeof artifact.durationMs !== "number" || !Number.isFinite(artifact.durationMs) || artifact.durationMs < 0) throw new Error(`memory config artifact '${path}' is malformed`);
 	return artifact;
 }
+function isMemoryProbeResult(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const probe = value;
+	if (typeof probe.id !== "string" || !probe.id || typeof probe.stepId !== "string" || !probe.stepId || !Number.isSafeInteger(probe.stepOrdinal) || probe.stepOrdinal < 0 || typeof probe.query !== "string" || !probe.query || typeof probe.score !== "number" || !Number.isFinite(probe.score) || probe.score < 0 || probe.score > 1 || typeof probe.passed !== "boolean" || !isFiniteNumberRecord(probe.dimensions) || !Array.isArray(probe.applicableDimensions) || !probe.applicableDimensions.every((entry) => typeof entry === "string" && entry.length > 0) || typeof probe.notes !== "string" || !Array.isArray(probe.hitIds) || !probe.hitIds.every((entry) => typeof entry === "string") || typeof probe.evidenceRef !== "string" || !/^sha256:[a-f0-9]{64}$/.test(probe.evidenceRef) || typeof probe.evidencePath !== "string" || !probe.evidencePath.endsWith(`/memory-evidence/${probe.evidenceRef.slice(7)}.json`)) return false;
+	return (probe.retentionKey === void 0 || typeof probe.retentionKey === "string" && probe.retentionKey.length > 0) && (probe.transferKey === void 0 || typeof probe.transferKey === "string" && probe.transferKey.length > 0);
+}
 function isFiniteNumberRecord(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
 	return Object.values(value).every((entry) => typeof entry === "number" && Number.isFinite(entry));
@@ -4489,6 +5388,6 @@ const AgentMemoryWriteInputSchema = z.object({
 	metadata: z.record(z.string(), z.unknown()).optional()
 });
 //#endregion
-export { assertImmutableRef as A, resetRetrievalHoldoutRegistry as C, jsonObjectCandidateCodec as D, jsonCandidateCodec as E, runSerializedKnowledgeOptimization as O, emitRetrievalHoldoutBypass as S, toOffPolicyTrajectory as T, defaultGetMemoryContext as _, createNeo4jAgentMemoryAdapter as a, applySessionStickyRetrievalHoldout as b, runAgentMemoryImprovement as c, runAgentMemoryExperiment as d, agentMemorySequenceJudge as f, forkAgentMemoryBranchSnapshot as g, createAgentMemoryBranch as h, AgentMemoryWriteInputSchema as i, scenarioContentFingerprint as k, createGraphitiMemoryAdapter as l, buildAgentMemorySequencesFromBenchmarkCases as m, AgentMemoryKindSchema as n, createMem0MemoryAdapter as o, buildAgentMemorySequenceScenarios as p, AgentMemoryScopeSchema as r, mem0MemoryAdapterIdentity as s, AgentMemoryHitSchema as t, graphitiMemoryAdapterIdentity as u, renderMemoryContext as v, retrievalHoldoutConfigHash as w, deterministicRng as x, applyRetrievalHoldout as y };
+export { runSerializedKnowledgeOptimization as A, deterministicRng as C, toOffPolicyTrajectory as D, retrievalHoldoutConfigHash as E, assertImmutableRef as M, jsonCandidateCodec as O, applySessionStickyRetrievalHoldout as S, resetRetrievalHoldoutRegistry as T, createAgentMemoryBranch as _, createNeo4jAgentMemoryAdapter as a, renderMemoryContext as b, runAgentMemoryImprovement as c, compareAgentMemoryLearning as d, runAgentMemoryLearningExperiment as f, buildAgentMemorySequencesFromBenchmarkCases as g, buildAgentMemorySequenceScenarios as h, AgentMemoryWriteInputSchema as i, scenarioContentFingerprint as j, jsonObjectCandidateCodec as k, createGraphitiMemoryAdapter as l, agentMemorySequenceJudge as m, AgentMemoryKindSchema as n, createMem0MemoryAdapter as o, runAgentMemoryExperiment as p, AgentMemoryScopeSchema as r, mem0MemoryAdapterIdentity as s, AgentMemoryHitSchema as t, graphitiMemoryAdapterIdentity as u, forkAgentMemoryBranchSnapshot as v, emitRetrievalHoldoutBypass as w, applyRetrievalHoldout as x, defaultGetMemoryContext as y };
 
-//# sourceMappingURL=memory-CIYRB_Q8.js.map
+//# sourceMappingURL=memory-DAFfGTJH.js.map