@snoai/memory 0.0.0-stage → 1.0.1

package/dist/internal/engine/extraction/b-profile-section-rekey.js

@@ -0,0 +1,730 @@
+import { MAX_LIST_LIMIT } from "../../config/index.js";
+import { a as buildInsightMetadata, c as stringifyInsightMetadata, h as deriveFactKey, s as parseInsightMetadata } from "../../../memory-metadata-codec-DL1sbJiN.js";
+import { boundSectionContent, buildIndexedText } from "./extraction-text-sanitizer.js";
+import { i as getActiveSectionRegistry, o as normalizeTopicToSectionName, s as restoreCachedSectionDictionary } from "../../../b-profile-section-dictionary-provider-BHkoNqgk.js";
+import { o as canonicalizeProfileSectionName, r as recordTokenCounter } from "../../../memory-store-write-validation-B_hDG2zf.js";
+import { createLogger } from "@snoai/utils/logger";
+//#region src/engine/extraction/b-profile-section-rekey.ts
+/** @file b-profile-section-rekey.ts
+* @purpose Re-keys fall-through B-profile rows after a section dictionary upgrade.
+* @boundary Deterministic store mutations only; no LLM or network calls.
+*/
+const log = createLogger("sno-station-mem:b-profile-section-rekey");
+const GENERAL_SECTION = "preferences.general";
+const MISSING_TOPIC_FLAG = "profile.preference.missing_topic";
+const B_PROFILE_CANONICAL_FORM_REPAIR_VERSION = 1;
+async function runBProfileSectionRekey(args) {
+	const registry = getActiveSectionRegistry();
+	let cached;
+	try {
+		cached = await args.cache.read();
+	} catch (error) {
+		log.warn("section dictionary cache rejected during re-key; treating it as absent", { error }, {
+			event_name: "sno_station_mem.b-profile-section-rekey.section.dictionary.cache.rejected.during.re.key.treating.it.as.absent",
+			file: "packages/memory/src/engine/extraction/b-profile-section-rekey.ts",
+			function: "runBProfileSectionRekey",
+			site_id: "b-profile-section-rekey.runBProfileSectionRekey.b452a7657e"
+		});
+		cached = void 0;
+	}
+	const registryRepairPending = cached?.appliedSchemaVersion !== registry.schema_version;
+	const canonicalRepairPending = cached?.canonicalFormRepairVersion !== 1;
+	if (!registryRepairPending && !canonicalRepairPending) {
+		const empty = emptyReport();
+		return {
+			dryRun: empty,
+			applied: empty,
+			skippedByVersion: true
+		};
+	}
+	let dryRun = emptyReport();
+	let applied = emptyReport();
+	if (canonicalRepairPending) {
+		const plan = await buildCanonicalRepairPlan(args.store, args.projectIdFilter);
+		log.info("B-profile canonical-form repair dry run", plan.report, {
+			event_name: "sno_station_mem.b-profile-section-rekey.b.profile.canonical.form.repair.dry.run",
+			file: "packages/memory/src/engine/extraction/b-profile-section-rekey.ts",
+			function: "runBProfileSectionRekey",
+			site_id: "b-profile-section-rekey.runBProfileSectionRekey.4494531e35"
+		});
+		assertCanonicalPlanReconciles(plan);
+		const canonicalApplied = await applyCanonicalRepairPlan(args.store, plan);
+		if (!reportsEqual(plan.report, canonicalApplied)) {
+			log.error("B-profile canonical-form repair reconciliation failed", {
+				dryRun: plan.report,
+				applied: canonicalApplied
+			}, {
+				event_name: "sno_station_mem.b-profile-section-rekey.b.profile.canonical.form.repair.reconciliation.failed",
+				file: "packages/memory/src/engine/extraction/b-profile-section-rekey.ts",
+				function: "runBProfileSectionRekey",
+				site_id: "b-profile-section-rekey.runBProfileSectionRekey.5276d7dfea"
+			});
+			throw new Error("B-profile canonical-form repair applied counts diverged from dry run");
+		}
+		dryRun = combineReports(dryRun, plan.report);
+		applied = combineReports(applied, canonicalApplied);
+	}
+	if (registryRepairPending || canonicalRepairPending) {
+		const plan = await buildRekeyPlan(args.store, args.projectIdFilter);
+		log.info("B-profile section re-key dry run", plan.report, {
+			event_name: "sno_station_mem.b-profile-section-rekey.b.profile.section.re.key.dry.run",
+			file: "packages/memory/src/engine/extraction/b-profile-section-rekey.ts",
+			function: "runBProfileSectionRekey",
+			site_id: "b-profile-section-rekey.runBProfileSectionRekey.1acb6c65f8"
+		});
+		assertPlanReconciles(plan.report);
+		const registryApplied = await applyRekeyPlan(args.store, plan);
+		if (!reportsEqual(plan.report, registryApplied)) {
+			log.error("B-profile section re-key reconciliation failed", {
+				dryRun: plan.report,
+				applied: registryApplied
+			}, {
+				event_name: "sno_station_mem.b-profile-section-rekey.b.profile.section.re.key.reconciliation.failed",
+				file: "packages/memory/src/engine/extraction/b-profile-section-rekey.ts",
+				function: "runBProfileSectionRekey",
+				site_id: "b-profile-section-rekey.runBProfileSectionRekey.d8bb76de51"
+			});
+			throw new Error("B-profile section re-key applied counts diverged from dry run");
+		}
+		dryRun = combineReports(dryRun, plan.report);
+		applied = combineReports(applied, registryApplied);
+	}
+	if (args.projectIdFilter === void 0) await args.cache.write({
+		activeRegistry: registry,
+		...cached?.fetchedForPluginVersion === void 0 ? {} : { fetchedForPluginVersion: cached.fetchedForPluginVersion },
+		appliedSchemaVersion: registry.schema_version,
+		canonicalFormRepairVersion: 1
+	});
+	log.info("B-profile section re-key applied", applied, {
+		event_name: "sno_station_mem.b-profile-section-rekey.b.profile.section.re.key.applied",
+		file: "packages/memory/src/engine/extraction/b-profile-section-rekey.ts",
+		function: "runBProfileSectionRekey",
+		site_id: "b-profile-section-rekey.runBProfileSectionRekey.ce06a215a3"
+	});
+	return {
+		dryRun,
+		applied,
+		skippedByVersion: false
+	};
+}
+function scheduleBProfileSectionRekey(args) {
+	(async () => {
+		await restoreCachedSectionDictionary({
+			mode: args.mode,
+			cache: args.cache
+		});
+		await runBProfileSectionRekey({
+			store: args.store,
+			cache: args.cache
+		});
+	})().catch((error) => {
+		log.error("detached B-profile section re-key failed", { error }, {
+			event_name: "sno_station_mem.b-profile-section-rekey.detached.b.profile.section.re.key.failed",
+			file: "packages/memory/src/engine/extraction/b-profile-section-rekey.ts",
+			function: "<anonymous callback>",
+			site_id: "b-profile-section-rekey.<anonymous callback>.9cc8218e54"
+		});
+	});
+}
+async function buildCanonicalRepairPlan(store, projectIdFilter) {
+	const activeRows = (await listAllProfileRows(store, projectIdFilter)).map((row) => parseRow(row)).filter((row) => row !== void 0).sort(compareRows).filter((row) => row.metadata.invalidated_at === void 0 && isCanonicalRepairEligible(row.metadata));
+	const report = emptyReport();
+	report.sourceRows = activeRows.length;
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of activeRows) {
+		const sectionName = canonicalRepairTargetSection(row);
+		const groupKey = `${row.entry.projectId}\u0000${sectionName}`;
+		const group = groups.get(groupKey);
+		if (group) group.rows.push(row);
+		else groups.set(groupKey, {
+			sectionName,
+			rows: [row]
+		});
+	}
+	Object.assign(report, measureSplitGroups(activeRows));
+	const actions = [];
+	let finalCount = activeRows.length;
+	for (const group of groups.values()) {
+		const actionRows = group.rows.length === 1 ? group.rows : group.rows.filter((row) => {
+			if (canonicalizeProfileSectionName(row.sectionName) === GENERAL_SECTION && group.sectionName !== GENERAL_SECTION && !hasMergeablePreferenceClause(row.metadata.l2_content)) {
+				report.unchanged += 1;
+				return false;
+			}
+			return true;
+		});
+		if (actionRows.length === 1) {
+			const source = actionRows[0];
+			if (!source) continue;
+			if (source.sectionName === group.sectionName) {
+				report.unchanged += 1;
+				continue;
+			}
+			actions.push({
+				kind: "migrate",
+				sources: [source.entry],
+				newSection: group.sectionName
+			});
+			report.migrated += 1;
+			report.targetKeys += 1;
+			continue;
+		}
+		if (actionRows.length === 0) continue;
+		actions.push({
+			kind: "merge",
+			sources: actionRows.map((row) => row.entry),
+			newSection: group.sectionName
+		});
+		report.collisions += 1;
+		report.merged += 1;
+		report.targetKeys += 1;
+		finalCount -= actionRows.length - 1;
+	}
+	report.finalCount = finalCount;
+	return {
+		report,
+		actions,
+		projectIdFilter
+	};
+}
+async function applyCanonicalRepairPlan(store, plan) {
+	if (plan.actions.length === 0) return plan.report;
+	for (const action of plan.actions) {
+		const sources = action.sources.map((planned) => {
+			const current = store.getById(planned.id);
+			if (!current || current.contentHash !== planned.contentHash || current.metadata !== planned.metadata) throw new Error("B-profile canonical-form repair source changed after dry run");
+			const metadata = parseInsightMetadata(current.metadata, current);
+			if (typeof metadata.section_name !== "string" || metadata.invalidated_at !== void 0 || !isCanonicalRepairEligible(metadata) || canonicalRepairTargetSection({
+				metadata,
+				sectionName: metadata.section_name
+			}) !== action.newSection) throw new Error("B-profile canonical-form repair source no longer matches its plan");
+			return current;
+		});
+		if (action.kind === "migrate") {
+			const source = sources[0];
+			if (!source) throw new Error("B-profile canonical-form repair migration source missing");
+			await rekeyInPlace(store, source, action.newSection, action.newSection !== GENERAL_SECTION);
+		} else await mergeCanonicalCollision(store, sources, action.newSection);
+	}
+	const finalCount = (await listAllProfileRows(store, plan.projectIdFilter)).filter((row) => {
+		const parsed = parseRow(row);
+		if (!parsed) return false;
+		return parsed.metadata.invalidated_at === void 0 && isCanonicalRepairEligible(parsed.metadata);
+	}).length;
+	return {
+		...plan.report,
+		finalCount
+	};
+}
+function canonicalRepairTargetSection(row) {
+	const canonicalSection = canonicalizeProfileSectionName(row.sectionName);
+	if (canonicalSection !== GENERAL_SECTION) return canonicalSection;
+	const rawTopicPhrase = row.metadata.rawTopicPhrase;
+	if (typeof rawTopicPhrase !== "string" || rawTopicPhrase.trim().length === 0) return canonicalSection;
+	return normalizeTopicToSectionName(rawTopicPhrase);
+}
+function isCanonicalRepairEligible(metadata) {
+	return metadata.active_task_kind !== "task" && metadata.active_task_kind !== "projection";
+}
+function measureSplitGroups(laneActiveRows) {
+	const rawSections = new Set(laneActiveRows.map((row) => row.sectionName));
+	const sectionsByForm = /* @__PURE__ */ new Map();
+	const sectionsByTopic = /* @__PURE__ */ new Map();
+	for (const section of rawSections) {
+		const form = normalizeSplitMeasurementKey(section);
+		const matchingForms = sectionsByForm.get(form) ?? /* @__PURE__ */ new Set();
+		matchingForms.add(section);
+		sectionsByForm.set(form, matchingForms);
+		const separator = section.indexOf(".");
+		if (separator < 0) continue;
+		const topic = normalizeSplitMeasurementKey(section.slice(separator + 1));
+		const matchingTopics = sectionsByTopic.get(topic) ?? /* @__PURE__ */ new Set();
+		matchingTopics.add(section);
+		sectionsByTopic.set(topic, matchingTopics);
+	}
+	const separatorSplitGroups = Array.from(sectionsByForm.values()).filter((sections) => sections.size > 1).length;
+	const domainPrefixSplitGroups = Array.from(sectionsByTopic.values()).filter((sections) => {
+		return new Set(Array.from(sections, (section) => section.slice(0, section.indexOf(".")))).size > 1;
+	}).length;
+	const canonicalSections = new Set(laneActiveRows.map((row) => canonicalizeProfileSectionName(row.sectionName)));
+	const crossPathPairs = /* @__PURE__ */ new Set();
+	for (const row of laneActiveRows) {
+		const section = canonicalizeProfileSectionName(row.sectionName);
+		if (!section.startsWith("preferences.")) continue;
+		const candidates = [section.slice(12), ...typeof row.metadata.rawTopicPhrase === "string" ? [row.metadata.rawTopicPhrase] : []];
+		for (const candidate of candidates) {
+			const registrySection = normalizeTopicToSectionName(candidate);
+			if (registrySection === GENERAL_SECTION || registrySection === section || !canonicalSections.has(registrySection)) continue;
+			crossPathPairs.add([section, registrySection].sort().join("\0"));
+		}
+	}
+	return {
+		separatorSplitGroups,
+		domainPrefixSplitGroups,
+		crossPathSplitGroups: crossPathPairs.size
+	};
+}
+function normalizeSplitMeasurementKey(value) {
+	return value.normalize("NFKC").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+async function mergeCanonicalCollision(store, sources, newSection) {
+	const sourceMetadata = sources.map((source) => parseInsightMetadata(source.metadata, source));
+	const targetFactKey = deriveFactKey({
+		kind: "profile",
+		section_name: newSection
+	});
+	if (!targetFactKey) throw new Error(`B-profile canonical-form repair target '${newSection}' is invalid`);
+	const activeFactGuard = {
+		factKey: targetFactKey,
+		expectedIds: sources.filter((_, index) => sourceMetadata[index]?.fact_key === targetFactKey).map((source) => source.id)
+	};
+	const mergedContent = combineUniquePreferenceClauses(...sourceMetadata.map((metadata) => metadata.l2_content));
+	const at = Math.max(Date.now(), ...sources.map((source) => source.timestamp));
+	const mergedClauseKeys = new Set(splitPreferenceClauses(mergedContent).map(normalizeClause).filter(Boolean));
+	let exactTargetIndex = -1;
+	let exactAliasTargetIndex = -1;
+	for (let index = sourceMetadata.length - 1; index >= 0; index -= 1) {
+		const metadata = sourceMetadata[index];
+		if (!metadata) continue;
+		const targetClauseKeys = new Set(splitPreferenceClauses(metadata.l2_content).map(normalizeClause).filter(Boolean));
+		if (!(targetClauseKeys.size === mergedClauseKeys.size && Array.from(targetClauseKeys).every((clause) => mergedClauseKeys.has(clause)))) continue;
+		if (metadata.section_name === newSection) {
+			exactTargetIndex = index;
+			break;
+		}
+		if (exactAliasTargetIndex < 0) exactAliasTargetIndex = index;
+	}
+	if (exactTargetIndex < 0) exactTargetIndex = exactAliasTargetIndex;
+	if (exactTargetIndex >= 0) {
+		const target = sources[exactTargetIndex];
+		if (!target) throw new Error("B-profile canonical-form repair exact target disappeared");
+		const targetMetadata = sourceMetadata[exactTargetIndex];
+		if (!targetMetadata) throw new Error("B-profile canonical-form repair exact target metadata disappeared");
+		const finalTargetMetadata = targetMetadata.section_name === newSection ? target.metadata : metadataForSection(target, newSection);
+		if ((await store.supersede({
+			create: {
+				text: target.text,
+				category: target.category,
+				projectId: target.projectId,
+				importance: target.importance,
+				timestamp: target.timestamp,
+				metadata: finalTargetMetadata,
+				trusted: true
+			},
+			activeFactGuard,
+			preserveExisting: {
+				id: target.id,
+				expectedContentHash: target.contentHash,
+				expectedMetadata: target.metadata
+			},
+			closes: sources.filter((source) => source.id !== target.id).map((source) => ({
+				id: source.id,
+				expectedContentHash: source.contentHash,
+				expectedMetadata: source.metadata,
+				buildMetadata: (createdId) => closedMetadata(source, createdId, at, newSection, true)
+			}))
+		})).id !== target.id) throw new Error("B-profile canonical-form repair exact target was not preserved");
+		return;
+	}
+	const target = sources[0];
+	if (!target) throw new Error("B-profile canonical-form repair collision has no rows");
+	const targetMetadata = sourceMetadata[0];
+	if (!targetMetadata) throw new Error("B-profile canonical-form repair target metadata missing");
+	const abstract = firstSentence(mergedContent);
+	const boundedContent = boundSectionContent(mergedContent, abstract, await recordTokenCounter(store.embedder));
+	const replacementMetadata = buildInsightMetadata({
+		text: boundedContent,
+		category: "profile",
+		timestamp: at
+	}, {
+		...metadataForMergeProduct(targetMetadata),
+		l0_abstract: abstract,
+		l1_overview: boundedContent,
+		l2_content: boundedContent,
+		section_name: newSection,
+		supersedes: target.id,
+		valid_from: at,
+		asserted_at: at
+	});
+	await store.supersede({
+		create: {
+			text: buildIndexedText(abstract, boundedContent),
+			category: "profile",
+			projectId: target.projectId,
+			importance: Math.max(...sources.map((source) => source.importance)),
+			timestamp: at,
+			metadata: stringifyInsightMetadata(replacementMetadata),
+			trusted: true
+		},
+		activeFactGuard,
+		closes: sources.map((source) => ({
+			id: source.id,
+			expectedContentHash: source.contentHash,
+			expectedMetadata: source.metadata,
+			buildMetadata: (createdId) => closedMetadata(source, createdId, at, newSection, true)
+		}))
+	});
+}
+async function buildRekeyPlan(store, projectIdFilter) {
+	const activeRows = (await listAllProfileRows(store, projectIdFilter)).map((row) => parseRow(row)).filter((row) => row !== void 0).filter((row) => row.metadata.invalidated_at === void 0);
+	const sources = activeRows.filter((row) => row.metadata.section_name === GENERAL_SECTION).sort(compareRows).map((row) => row.entry);
+	const report = emptyReport();
+	report.sourceRows = sources.length;
+	const actions = [];
+	const plannedTargets = /* @__PURE__ */ new Set();
+	const targetKeys = /* @__PURE__ */ new Set();
+	for (const source of sources) {
+		const metadata = parseInsightMetadata(source.metadata, source);
+		const rawTopicPhrase = metadata.rawTopicPhrase;
+		if (typeof rawTopicPhrase !== "string" || !rawTopicPhrase.trim()) {
+			report.missingRawPhrase += 1;
+			continue;
+		}
+		const newSection = normalizeTopicToSectionName(rawTopicPhrase);
+		if (newSection === GENERAL_SECTION || newSection === metadata.section_name) {
+			report.unchanged += 1;
+			continue;
+		}
+		const targetFactKey = deriveFactKey({
+			kind: "profile",
+			section_name: newSection
+		});
+		if (!targetFactKey) {
+			report.rejected += 1;
+			continue;
+		}
+		const planKey = `${source.projectId}\u0000${targetFactKey}`;
+		targetKeys.add(planKey);
+		const existingTarget = store.getByFactKey(source.projectId, targetFactKey);
+		if (existingTarget) try {
+			parseInsightMetadata(existingTarget.metadata, existingTarget);
+		} catch {
+			report.rejected += 1;
+			continue;
+		}
+		const kind = existingTarget || plannedTargets.has(planKey) ? "merge" : "migrate";
+		if (kind === "merge" && !hasMergeablePreferenceClause(metadata.l2_content)) {
+			report.rejected += 1;
+			continue;
+		}
+		actions.push({
+			kind,
+			source,
+			targetFactKey,
+			newSection
+		});
+		plannedTargets.add(planKey);
+		if (kind === "merge") {
+			report.collisions += 1;
+			report.merged += 1;
+		} else report.migrated += 1;
+	}
+	report.targetKeys = targetKeys.size;
+	report.finalCount = activeRows.length - report.merged;
+	return {
+		report,
+		actions,
+		projectIdFilter
+	};
+}
+async function applyRekeyPlan(store, plan) {
+	if (plan.actions.length === 0) return plan.report;
+	let migrated = 0;
+	let merged = 0;
+	for (const action of plan.actions) {
+		const source = store.getById(action.source.id);
+		if (!source || source.contentHash !== action.source.contentHash || source.metadata !== action.source.metadata || !sourceStillMatchesPlan(source, action.newSection)) throwReconciliationError("source row changed after dry run", action);
+		const target = store.getByFactKey(source.projectId, action.targetFactKey);
+		if (action.kind === "migrate") {
+			if (target) throwReconciliationError("unexpected target appeared after dry run", action);
+			await rekeyInPlace(store, source, action.newSection);
+			migrated += 1;
+			continue;
+		}
+		if (!target) throwReconciliationError("expected collision target disappeared", action);
+		await mergeCollision(store, source, target, action.newSection);
+		merged += 1;
+	}
+	const finalCount = (await listAllProfileRows(store, plan.projectIdFilter)).filter((row) => {
+		return parseRow(row)?.metadata.invalidated_at === void 0;
+	}).length;
+	return {
+		...plan.report,
+		migrated,
+		merged,
+		collisions: merged,
+		finalCount
+	};
+}
+async function rekeyInPlace(store, source, newSection, expectTargetAbsent = true) {
+	const targetFactKey = deriveFactKey({
+		kind: "profile",
+		section_name: newSection
+	});
+	if (!targetFactKey) throw new Error(`B-profile section re-key target '${newSection}' is invalid`);
+	if (!await store.update(source.id, {
+		writerAuthority: "profile-writer",
+		metadata: metadataForSection(source, newSection),
+		expectedContentHash: source.contentHash,
+		expectedMetadata: source.metadata,
+		...expectTargetAbsent ? { expectedAbsentFactKey: targetFactKey } : {}
+	})) throw new Error(`B-profile section re-key source '${source.id}' disappeared`);
+}
+function metadataForSection(source, newSection) {
+	const nextMetadata = { ...buildInsightMetadata(source, {
+		...parseInsightMetadata(source.metadata, source),
+		section_name: newSection
+	}) };
+	delete nextMetadata[MISSING_TOPIC_FLAG];
+	return stringifyInsightMetadata(nextMetadata);
+}
+async function mergeCollision(store, source, target, newSection) {
+	const sourceMetadata = parseInsightMetadata(source.metadata, source);
+	const targetMetadata = parseInsightMetadata(target.metadata, target);
+	const sourceContent = sourceMetadata.l2_content;
+	const targetContent = targetMetadata.l2_content;
+	const normalizedTargetContent = combineUniquePreferenceClauses(targetContent);
+	const mergedContent = combineUniquePreferenceClauses(targetContent, sourceContent);
+	const at = Math.max(Date.now(), source.timestamp, target.timestamp);
+	if (mergedContent === normalizedTargetContent) {
+		const targetFactKey = deriveFactKey({
+			kind: "profile",
+			section_name: newSection
+		});
+		if (!targetFactKey) throw new Error(`B-profile section re-key target '${newSection}' is invalid`);
+		if ((await store.supersede({
+			create: {
+				text: target.text,
+				category: target.category,
+				projectId: target.projectId,
+				importance: target.importance,
+				timestamp: target.timestamp,
+				metadata: target.metadata,
+				trusted: true
+			},
+			closes: [closeSource(source, newSection, at)],
+			activeFactGuard: {
+				factKey: targetFactKey,
+				expectedId: target.id
+			},
+			preserveExisting: {
+				id: target.id,
+				expectedContentHash: target.contentHash,
+				expectedMetadata: target.metadata
+			}
+		})).id !== target.id) throw new Error("B-profile section re-key exact target was not preserved");
+		return;
+	}
+	const abstract = firstSentence(mergedContent);
+	const boundedContent = boundSectionContent(mergedContent, abstract, await recordTokenCounter(store.embedder));
+	const replacementMetadata = buildInsightMetadata({
+		text: boundedContent,
+		category: "profile",
+		timestamp: at
+	}, {
+		...metadataForMergeProduct(targetMetadata),
+		l0_abstract: abstract,
+		l1_overview: boundedContent,
+		l2_content: boundedContent,
+		section_name: newSection,
+		supersedes: target.id,
+		valid_from: at,
+		asserted_at: at
+	});
+	await store.supersede({
+		create: {
+			text: buildIndexedText(abstract, boundedContent),
+			category: "profile",
+			projectId: target.projectId,
+			importance: Math.max(source.importance, target.importance),
+			timestamp: at,
+			metadata: stringifyInsightMetadata(replacementMetadata),
+			trusted: true
+		},
+		closes: [closeTarget(target, at), closeSource(source, newSection, at)]
+	});
+}
+function metadataForMergeProduct(metadata) {
+	const product = { ...metadata };
+	delete product.idempotency_key;
+	delete product.merge_lineage;
+	delete product.mappedKind;
+	if (product.source === "agent_end") for (const key of [
+		"source",
+		"role",
+		"session_key",
+		"session_id",
+		"chunk_index",
+		"chunk_count",
+		"chunking_version",
+		"content_type"
+	]) delete product[key];
+	return product;
+}
+function closeSource(source, newSection, at) {
+	return {
+		id: source.id,
+		expectedContentHash: source.contentHash,
+		expectedMetadata: source.metadata,
+		buildMetadata: (createdId) => closedMetadata(source, createdId, at, newSection, true)
+	};
+}
+function closeTarget(target, at) {
+	return {
+		id: target.id,
+		expectedContentHash: target.contentHash,
+		expectedMetadata: target.metadata,
+		buildMetadata: (createdId) => closedMetadata(target, createdId, at, void 0, false)
+	};
+}
+function closedMetadata(row, createdId, at, sectionName, dropMissingTopicFlag) {
+	const current = parseInsightMetadata(row.metadata, row);
+	const nextMetadata = { ...buildInsightMetadata(row, {
+		...current,
+		...sectionName ? { section_name: sectionName } : {},
+		invalidated_at: current.valid_from === void 0 ? at : Math.max(at, current.valid_from),
+		superseded_by: createdId
+	}) };
+	if (dropMissingTopicFlag) delete nextMetadata[MISSING_TOPIC_FLAG];
+	return stringifyInsightMetadata(nextMetadata);
+}
+function parseRow(entry) {
+	try {
+		const metadata = parseInsightMetadata(entry.metadata, entry);
+		if (typeof metadata.section_name !== "string") return void 0;
+		return {
+			entry,
+			metadata,
+			sectionName: metadata.section_name
+		};
+	} catch {
+		return;
+	}
+}
+async function listAllProfileRows(store, projectIdFilter) {
+	const rows = [];
+	for (let offset = 0;; offset += MAX_LIST_LIMIT) {
+		const page = await store.list({
+			category: "profile",
+			limit: MAX_LIST_LIMIT,
+			offset,
+			...projectIdFilter === void 0 ? {} : { projectIdFilter }
+		});
+		if (page.length === 0) return rows;
+		rows.push(...page);
+	}
+}
+function sourceStillMatchesPlan(source, newSection) {
+	const metadata = parseInsightMetadata(source.metadata, source);
+	const rawTopicPhrase = metadata.rawTopicPhrase;
+	return metadata.invalidated_at === void 0 && metadata.section_name === GENERAL_SECTION && typeof rawTopicPhrase === "string" && normalizeTopicToSectionName(rawTopicPhrase) === newSection;
+}
+function assertPlanReconciles(report) {
+	if (report.migrated + report.merged + report.rejected + report.missingRawPhrase + report.unchanged === report.sourceRows) return;
+	log.error("B-profile section re-key dry-run counts do not reconcile", report, {
+		event_name: "sno_station_mem.b-profile-section-rekey.b.profile.section.re.key.dry.run.counts.do.not.reconcile",
+		file: "packages/memory/src/engine/extraction/b-profile-section-rekey.ts",
+		function: "assertPlanReconciles",
+		site_id: "b-profile-section-rekey.assertPlanReconciles.03748b5c20"
+	});
+	throw new Error("B-profile section re-key dry-run counts do not reconcile");
+}
+function assertCanonicalPlanReconciles(plan) {
+	if (plan.actions.reduce((count, action) => count + action.sources.length, 0) + plan.report.unchanged === plan.report.sourceRows) return;
+	log.error("B-profile canonical-form repair dry-run counts do not reconcile", plan.report, {
+		event_name: "sno_station_mem.b-profile-section-rekey.b.profile.canonical.form.repair.dry.run.counts.do.not.reconcile",
+		file: "packages/memory/src/engine/extraction/b-profile-section-rekey.ts",
+		function: "assertCanonicalPlanReconciles",
+		site_id: "b-profile-section-rekey.assertCanonicalPlanReconciles.2ad72089d1"
+	});
+	throw new Error("B-profile canonical-form repair dry-run counts do not reconcile");
+}
+function throwReconciliationError(reason, action) {
+	log.error("B-profile section re-key aborted after dry-run divergence", {
+		reason_code: reason.replace(/[^a-z0-9]+/gi, "_").toLowerCase(),
+		memory_id: action.source.id,
+		projectId: action.source.projectId,
+		targetFactKey: action.targetFactKey
+	}, {
+		event_name: "sno_station_mem.b-profile-section-rekey.b.profile.section.re.key.aborted.after.dry.run.divergence",
+		file: "packages/memory/src/engine/extraction/b-profile-section-rekey.ts",
+		function: "throwReconciliationError",
+		site_id: "b-profile-section-rekey.throwReconciliationError.b59b599311"
+	});
+	throw new Error(`B-profile section re-key aborted: ${reason}`);
+}
+function reportsEqual(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+function combineReports(left, right) {
+	return {
+		sourceRows: Math.max(left.sourceRows, right.sourceRows),
+		targetKeys: left.targetKeys + right.targetKeys,
+		collisions: left.collisions + right.collisions,
+		migrated: left.migrated + right.migrated,
+		merged: left.merged + right.merged,
+		rejected: left.rejected + right.rejected,
+		missingRawPhrase: left.missingRawPhrase + right.missingRawPhrase,
+		unchanged: left.unchanged + right.unchanged,
+		finalCount: right.finalCount,
+		separatorSplitGroups: left.separatorSplitGroups + right.separatorSplitGroups,
+		domainPrefixSplitGroups: left.domainPrefixSplitGroups + right.domainPrefixSplitGroups,
+		crossPathSplitGroups: left.crossPathSplitGroups + right.crossPathSplitGroups
+	};
+}
+function emptyReport() {
+	return {
+		sourceRows: 0,
+		targetKeys: 0,
+		collisions: 0,
+		migrated: 0,
+		merged: 0,
+		rejected: 0,
+		missingRawPhrase: 0,
+		unchanged: 0,
+		finalCount: 0,
+		separatorSplitGroups: 0,
+		domainPrefixSplitGroups: 0,
+		crossPathSplitGroups: 0
+	};
+}
+function compareRows(left, right) {
+	return left.entry.projectId.localeCompare(right.entry.projectId) || left.entry.timestamp - right.entry.timestamp || left.entry.id.localeCompare(right.entry.id);
+}
+function combineUniquePreferenceClauses(...texts) {
+	const seen = /* @__PURE__ */ new Set();
+	const clauses = [];
+	for (const text of texts) for (const clause of splitPreferenceClauses(text)) {
+		const key = normalizeClause(clause);
+		if (!key || seen.has(key)) continue;
+		seen.add(key);
+		clauses.push(clause);
+	}
+	return clauses.join("\n");
+}
+function hasMergeablePreferenceClause(text) {
+	return splitPreferenceClauses(text).some((clause) => normalizeClause(clause).length > 0);
+}
+function splitPreferenceClauses(text) {
+	return text.split(/\n+|(?<=[.!?])\s+/).map((item) => item.trim()).filter(Boolean);
+}
+/**
+* Clause identity for dedup and for the exact-match check that decides which row survives a
+* merge. Case, Unicode form and whitespace do not change what a clause says, so they are
+* normalized away — and nothing else is.
+*
+* This used to delete every non-alphanumeric character, which merged clauses stating different
+* facts: "I use C." and "I use C++." both became "i use c", so one of the two preferences was
+* closed as a duplicate of the other and the count check still passed. Every symbol that
+* distinguishes a name — `+`, `#`, `/`, `.` inside a word — is meaning, not formatting.
+* A trailing sentence terminator is not, so the same clause with and without its full stop
+* stays one clause.
+*/
+function normalizeClause(text) {
+	const normalized = text.normalize("NFKC").toLowerCase().replace(/\s+/g, " ").trim().replace(/[.!?]+$/u, "").trim();
+	return /[\p{L}\p{N}]/u.test(normalized) ? normalized : "";
+}
+function firstSentence(text) {
+	return text.split(/(?<=[.!?])\s+/)[0]?.trim() || text;
+}
+//#endregion
+export { B_PROFILE_CANONICAL_FORM_REPAIR_VERSION, applyRekeyPlan, runBProfileSectionRekey, scheduleBProfileSectionRekey };