@snoai/memory 0.0.0-stage → 1.0.1

package/dist/profile-section-writer-BhGKPBjw.js

@@ -0,0 +1,2149 @@
+import { MAX_LIST_LIMIT } from "./internal/config/index.js";
+import { SnoStationMemError, StorageError } from "./internal/engine/shared/errors.js";
+import { a as buildInsightMetadata, c as stringifyInsightMetadata, h as deriveFactKey, s as parseInsightMetadata } from "./memory-metadata-codec-DL1sbJiN.js";
+import { n as LlmClientTerminalError } from "./llm-client-BSYUAcUb.js";
+import { resolveLlmRoute } from "./internal/model/llm-mode-routing.js";
+import { boundSectionContent, buildIndexedText } from "./internal/engine/extraction/extraction-text-sanitizer.js";
+import { d as runWithMutationAttempt, i as currentMutationAttemptId } from "./runtime-audit-log-BCeujlEp.js";
+import { adapterAViewFromRecord, orderAdapterAPair, parseAdapterAChatVerdict, prospectiveProfileView, renderAdapterAChatPrompt, renderAdapterAPrompt } from "./internal/engine/rem/index.js";
+import { C as TaskLifecycleStaleResolutionError, a as resolveTaskLifecycle, c as buildTaskLifecycleCommandClaim, i as findUniqueActiveTaskByDescription, l as resolveTaskLifecycleEffectiveTime, n as acceptsTaskLifecycleJudgment, o as taskLifecycleCandidateSetVersion, r as buildTaskLifecycleCandidateSet, s as admitTaskLifecycleAssertion, x as StaleSupersedeTargetError } from "./store-nPql26YM.js";
+import { o as canonicalizeProfileSectionName, r as recordTokenCounter } from "./memory-store-write-validation-B_hDG2zf.js";
+import { canExtractorWrite } from "./internal/engine/shared/memory-kind-policy.js";
+import { resolveHookAgentId } from "./internal/engine/bindings/sno-station-mem-runtime-mode.js";
+import { z } from "zod";
+import { createLogger, privateLogReference } from "@snoai/utils/logger";
+import path, { dirname } from "node:path";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/engine/extraction/retired-position-judgment-skill.ts
+/** @file retired-position-judgment-skill.ts
+* @purpose Loads the model-readable retired-position judgment method shipped with the plugin.
+* @boundary Package-relative read of one trusted bundled skill.
+*/
+const SKILL_PATH = path.join("skills", "judge-retired-position", "SKILL.md");
+function resolveSkillPath$1() {
+	const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+	for (const root of [
+		path.resolve(moduleDir, ".."),
+		path.resolve(moduleDir, "../.."),
+		path.resolve(moduleDir, "../../..")
+	]) {
+		const candidate = path.join(root, SKILL_PATH);
+		if (existsSync(candidate)) return candidate;
+	}
+	throw new Error(`sno-station-mem retired-position judgment skill is missing: ${SKILL_PATH}`);
+}
+const skillText = readFileSync(resolveSkillPath$1(), "utf8");
+function readSection$1(heading) {
+	const marker = `## ${heading}\n`;
+	const start = skillText.indexOf(marker);
+	if (start === -1) throw new Error(`retired-position judgment skill is missing section: ${heading}`);
+	const bodyStart = start + marker.length;
+	const nextSection = skillText.indexOf("\n## ", bodyStart);
+	return skillText.slice(bodyStart, nextSection === -1 ? void 0 : nextSection).trim();
+}
+const RETIRED_POSITION_JUDGMENT_SKILL = {
+	currentPositionMatch: readSection$1("Current Position Match"),
+	retirementRecheck: readSection$1("Retirement Recheck")
+};
+//#endregion
+//#region src/engine/extraction/retire-by-name.ts
+/** @file retire-by-name.ts
+* @purpose Extends one profile-owned retirement to model-named current-position rows.
+* @boundary Extraction-triggered shortlist, judgment, and metadata-only invalidation writes.
+*/
+const SHORTLIST_LIMIT = 8;
+const RETIRE_BY_NAME_MAX_DURATION_MS = 3e4;
+const SEARCH_LIMIT = 64;
+const JUDGMENT_MAX_TOKENS = 64;
+const RETIRE_BY_NAME_SAMPLING = {
+	temperature: "provider-default",
+	enableThinking: false,
+	maxTokens: JUDGMENT_MAX_TOKENS
+};
+const RETIRE_BY_NAME_PROMPT_TEMPLATE = [
+	RETIRED_POSITION_JUDGMENT_SKILL.currentPositionMatch,
+	"Return JSON only: {\"retire\":true} or {\"retire\":false}.",
+	"Use exactly one boolean field named retire."
+].join("\n\n");
+const RETIRE_BY_NAME_PROMPT_SHA256 = createHash("sha256").update(RETIRE_BY_NAME_PROMPT_TEMPLATE).digest("hex");
+function words(text) {
+	return new Set(text.toLocaleLowerCase().match(/[\p{L}\p{N}]+/gu) ?? []);
+}
+function shortlistRetireByNameCandidates(retiredPosition, candidates) {
+	const retiredWords = words(retiredPosition);
+	return candidates.map((entry) => {
+		const candidateWords = words(entry.text);
+		const overlap = [...candidateWords].filter((word) => retiredWords.has(word)).length;
+		return {
+			entry,
+			score: candidateWords.size === 0 ? 0 : overlap / candidateWords.size
+		};
+	}).filter((candidate) => candidate.score > 0).sort((left, right) => right.score - left.score || left.entry.id.localeCompare(right.entry.id)).slice(0, SHORTLIST_LIMIT).map((candidate) => candidate.entry);
+}
+function parseRetireVerdict(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const record = value;
+	if (Object.keys(record).length !== 1 || typeof record["retire"] !== "boolean") return;
+	return record["retire"];
+}
+function judgmentPrompt(retiredPosition, candidate) {
+	return [
+		RETIRE_BY_NAME_PROMPT_TEMPLATE,
+		`Retired position: ${JSON.stringify(retiredPosition)}`,
+		`Candidate row: ${JSON.stringify(candidate.text)}`
+	].join("\n\n");
+}
+async function retireRowsByName(params) {
+	const llm = params.llm;
+	if (!params.retiredPosition.trim()) return {
+		retiredIds: [],
+		completed: true
+	};
+	if (!llm) return {
+		retiredIds: [],
+		completed: false
+	};
+	const excludedIds = /* @__PURE__ */ new Set([params.currentPositionId, ...params.excludedRowIds ?? []]);
+	const matches = await params.store.searchKeyword(params.retiredPosition, {
+		limit: SEARCH_LIMIT,
+		projectIdFilter: [params.scope],
+		includeRefused: true,
+		excludeInvalidatedBefore: Number.MAX_SAFE_INTEGER,
+		excludeMemoryIds: [...excludedIds]
+	});
+	const searchCapped = matches.length >= SEARCH_LIMIT;
+	const eligible = matches.flatMap(({ entry }) => {
+		if (excludedIds.has(entry.id)) return [];
+		if (entry.category === "profile" || !canExtractorWrite(entry.category)) {
+			params.judgedCandidateIds.add(entry.id);
+			return [];
+		}
+		const metadata = parseInsightMetadata(entry.metadata, entry);
+		const writtenByTriggeringEvent = metadata.source_message_id === params.triggeringEventIdentity || params.triggeringSessionIdentity !== void 0 && metadata.source_session === params.triggeringSessionIdentity && metadata.asserted_at >= params.eventTime;
+		if (metadata.invalidated_at !== void 0) return [];
+		if (writtenByTriggeringEvent) {
+			params.judgedCandidateIds.add(entry.id);
+			return [];
+		}
+		return [entry];
+	});
+	const shortlist = shortlistRetireByNameCandidates(params.retiredPosition, eligible);
+	if (shortlist.length === 0) {
+		if (searchCapped) for (const entry of eligible) params.judgedCandidateIds.add(entry.id);
+		return {
+			retiredIds: [],
+			completed: !searchCapped
+		};
+	}
+	if (params.judgmentBudget && shortlist.length > params.judgmentBudget.remaining) return {
+		retiredIds: [],
+		completed: false
+	};
+	let resolved;
+	try {
+		resolved = await llm.getResolvedConfig();
+	} catch {
+		return {
+			retiredIds: [],
+			completed: false
+		};
+	}
+	const route = params.routing ? resolveLlmRoute({
+		callId: "P6",
+		config: params.routing
+	}) : null;
+	const destination = route === null ? "host" : "off" in route ? "off" : route.destination;
+	if (params.judgmentBudget) params.judgmentBudget.remaining -= shortlist.length;
+	const judgments = [];
+	let completed = !searchCapped && eligible.length === shortlist.length;
+	for (let offset = 0; offset < shortlist.length; offset += 4) {
+		if (params.deadlineMs !== void 0 && Date.now() >= params.deadlineMs) {
+			completed = false;
+			break;
+		}
+		const batch = shortlist.slice(offset, offset + 4);
+		judgments.push(...await Promise.all(batch.map(async (candidate) => {
+			try {
+				const remainingMs = params.deadlineMs === void 0 ? void 0 : Math.max(1, params.deadlineMs - Date.now());
+				return {
+					candidate,
+					verdict: parseRetireVerdict(await llm.completeJson({
+						prompt: judgmentPrompt(params.retiredPosition, candidate),
+						callId: "P6",
+						maxTokens: JUDGMENT_MAX_TOKENS,
+						enableThinking: false,
+						...remainingMs === void 0 && params.timeoutMs === void 0 ? {} : { timeoutMs: remainingMs === void 0 ? params.timeoutMs : Math.min(params.timeoutMs ?? remainingMs, remainingMs) },
+						...params.signal === void 0 ? {} : { signal: params.signal },
+						accept: (value) => parseRetireVerdict(value) !== void 0
+					}))
+				};
+			} catch {
+				return {
+					candidate,
+					verdict: void 0
+				};
+			}
+		})));
+	}
+	const retiredIds = [];
+	for (const { candidate, verdict } of judgments) {
+		if (verdict === void 0) {
+			completed = false;
+			continue;
+		}
+		if (!verdict) {
+			params.judgedCandidateIds.add(candidate.id);
+			continue;
+		}
+		const receiptPatch = {
+			invalidated_at: params.eventTime,
+			superseded_by: params.currentPositionId,
+			retire_by_name_receipt: {
+				call_id: "P6",
+				destination,
+				prompt_sha256: RETIRE_BY_NAME_PROMPT_SHA256,
+				model: destination === "host" ? "host" : resolved.model,
+				preset: destination === "host" ? "host" : resolved.preset,
+				sampling: RETIRE_BY_NAME_SAMPLING,
+				triggering_event_identity: params.triggeringEventIdentity
+			}
+		};
+		const candidateMetadata = parseInsightMetadata(candidate.metadata, candidate);
+		let wroteRetirement = false;
+		let contentChangedUnderneath = false;
+		try {
+			await params.store.applyMetadataDeltas([{
+				memoryId: candidate.id,
+				deltaFn: (current) => {
+					if (current.invalidated_at !== void 0 || typeof current.valid_from === "number" && current.valid_from > params.eventTime) return;
+					if (current.l2_content !== candidateMetadata.l2_content) {
+						contentChangedUnderneath = true;
+						return;
+					}
+					wroteRetirement = true;
+					return receiptPatch;
+				}
+			}]);
+		} catch {
+			completed = false;
+			continue;
+		}
+		if (contentChangedUnderneath) {
+			completed = false;
+			continue;
+		}
+		params.judgedCandidateIds.add(candidate.id);
+		if (!wroteRetirement) continue;
+		retiredIds.push(candidate.id);
+	}
+	return {
+		retiredIds,
+		completed
+	};
+}
+//#endregion
+//#region src/engine/extraction/task-lifecycle-judgment-skill.ts
+/** @file task-lifecycle-judgment-skill.ts
+* @purpose Loads the model-readable active-task judgment method shipped with the plugin.
+* @boundary Package-relative read of one trusted bundled skill.
+*/
+const TASK_SKILL_PATH = path.join("skills", "judge-task-lifecycle", "SKILL.md");
+const ATOMIC_SKILL_PATH = path.join("skills", "extract-atomic-memory", "SKILL.md");
+function resolveSkillPath(skillPath) {
+	const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+	for (const root of [
+		path.resolve(moduleDir, ".."),
+		path.resolve(moduleDir, "../.."),
+		path.resolve(moduleDir, "../../..")
+	]) {
+		const candidate = path.join(root, skillPath);
+		if (existsSync(candidate)) return candidate;
+	}
+	throw new Error(`sno-station-mem judgment skill is missing: ${skillPath}`);
+}
+const taskSkillText = readFileSync(resolveSkillPath(TASK_SKILL_PATH), "utf8");
+const atomicSkillText = readFileSync(resolveSkillPath(ATOMIC_SKILL_PATH), "utf8");
+function readSection(skillText, heading) {
+	const marker = `## ${heading}\n`;
+	const start = skillText.indexOf(marker);
+	if (start === -1) throw new Error(`task lifecycle judgment skill is missing section: ${heading}`);
+	const bodyStart = start + marker.length;
+	const nextSection = skillText.indexOf("\n## ", bodyStart);
+	return skillText.slice(bodyStart, nextSection === -1 ? void 0 : nextSection).trim();
+}
+const TASK_LIFECYCLE_JUDGMENT_SKILL = {
+	activeTaskState: [readSection(atomicSkillText, "To-do Boundary"), readSection(taskSkillText, "Active Task State")].join("\n\n"),
+	existingTaskRelation: readSection(taskSkillText, "Existing Task Relation")
+};
+//#endregion
+//#region src/engine/extraction/task-lifecycle-route.ts
+/** @file task-lifecycle-route.ts
+* @purpose Routes one typed task assertion through admission, bounded judgment, and atomic storage.
+* @boundary The only production task mutation ingress; models may select only an admitted identifier.
+*/
+var TaskLifecycleJudgmentUnavailableError = class extends SnoStationMemError {
+	constructor(message) {
+		super("task_lifecycle_judgment_unavailable", message);
+		this.name = "TaskLifecycleJudgmentUnavailableError";
+	}
+};
+function prepareDeterministicTaskLifecycleWrite(input) {
+	const commandClaim = buildTaskLifecycleCommandClaim({
+		assertion: input.assertion,
+		source: input.source
+	});
+	const admission = admitTaskLifecycleAssertion(input.store, {
+		assertion: input.assertion,
+		source: input.source,
+		commandClaim,
+		firstResolutionNowMs: input.firstResolutionNowMs
+	});
+	const instances = input.store.readTaskLifecycleInstances(admission.assertion.projectId);
+	const candidates = buildTaskLifecycleCandidateSet(admission.assertion, instances);
+	const exact = findUniqueActiveTaskByDescription(admission.assertion.description, instances);
+	const judgment = exact === void 0 ? admission.assertion.action === "open_or_refine" ? {
+		status: "completed",
+		value: { result: "distinct_instance" },
+		candidateSetVersion: taskLifecycleCandidateSetVersion(candidates)
+	} : {
+		status: "completed",
+		value: { result: "none" },
+		candidateSetVersion: taskLifecycleCandidateSetVersion(candidates)
+	} : {
+		status: "completed",
+		value: {
+			result: "same_instance",
+			activeTaskId: exact.activeTaskId
+		},
+		candidateSetVersion: taskLifecycleCandidateSetVersion(candidates)
+	};
+	return {
+		admission,
+		commandClaim,
+		resolution: resolveTaskLifecycle({
+			assertion: admission.assertion,
+			instances,
+			judgment
+		}),
+		todoProvenance: input.todoProvenance
+	};
+}
+const TASK_LIFECYCLE_MODEL_ACTIONS = [
+	"open_or_refine",
+	"complete",
+	"remove",
+	"none"
+];
+const taskLifecycleModelVerdictSchema = z.object({
+	action: z.enum(TASK_LIFECYCLE_MODEL_ACTIONS),
+	taskId: z.string().min(1).nullable()
+}).strict();
+async function requestTaskLifecycleJson(input) {
+	return input.llm.completeJson({
+		prompt: input.prompt,
+		callId: "T1",
+		...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs },
+		...input.signal === void 0 ? {} : { signal: input.signal },
+		accept: input.accept
+	});
+}
+async function requestModelJudgment(input) {
+	if (!input.llm) throw new TaskLifecycleJudgmentUnavailableError("task lifecycle judgment requires an available model route");
+	let value;
+	try {
+		value = await requestTaskLifecycleJson({
+			llm: input.llm,
+			accept: (value) => taskLifecycleModelVerdictSchema.safeParse(value).success,
+			prompt: [
+				TASK_LIFECYCLE_JUDGMENT_SKILL.activeTaskState,
+				"Return exactly one JSON object: {\"action\":\"open_or_refine|complete|remove|none\",\"taskId\":\"presented-id-or-null\"}.",
+				"For complete or remove, taskId must be one identifier from Active tasks.",
+				"For open_or_refine, taskId is an existing task to refine or null for a distinct task.",
+				"For none, taskId must be null.",
+				`Allowed actions: ${JSON.stringify(input.allowedActions)}`,
+				`Candidate: ${JSON.stringify(input.candidateText)}`,
+				`Active tasks: ${JSON.stringify(input.candidates)}`
+			].join("\n"),
+			...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs },
+			...input.signal === void 0 ? {} : { signal: input.signal }
+		});
+	} catch (error) {
+		if (error instanceof LlmClientTerminalError && error.category === "cancelled" && !error.requestTimedOut) throw error;
+		throw new TaskLifecycleJudgmentUnavailableError(`task lifecycle judgment failed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const parsed = taskLifecycleModelVerdictSchema.safeParse(value);
+	if (!parsed.success) throw new TaskLifecycleJudgmentUnavailableError("task lifecycle judgment returned an invalid shape");
+	const verdict = parsed.data;
+	if (!input.allowedActions.includes(verdict.action)) throw new TaskLifecycleJudgmentUnavailableError("task lifecycle judgment returned an action outside the admitted enum");
+	if (verdict.action === "none") {
+		if (verdict.taskId !== null) throw new TaskLifecycleJudgmentUnavailableError("task lifecycle none verdict returned an active task identifier");
+		return verdict;
+	}
+	if (verdict.action !== "open_or_refine" && verdict.taskId === null) throw new TaskLifecycleJudgmentUnavailableError("task lifecycle terminal verdict omitted the active task identifier");
+	if (verdict.taskId !== null && !input.candidates.some((candidate) => candidate.activeTaskId === verdict.taskId)) throw new TaskLifecycleJudgmentUnavailableError("task lifecycle judgment selected an identifier outside the presented set");
+	return verdict;
+}
+function provisionalAssertion(input) {
+	const effectiveTime = resolveTaskLifecycleEffectiveTime(input);
+	return {
+		kind: "task_lifecycle",
+		action: "open_or_refine",
+		commandId: "0".repeat(64),
+		projectId: input.projectId,
+		subject: "user",
+		description: input.candidateText,
+		effectiveAtMs: effectiveTime.effectiveAtMs,
+		timeSource: effectiveTime.timeSource,
+		occurrenceAnchors: input.occurrenceAnchors ?? {},
+		revisionDetails: input.revisionDetails ?? {},
+		...input.evidenceMemoryId === void 0 ? {} : { evidenceMemoryId: input.evidenceMemoryId }
+	};
+}
+function readCurrentOpenTaskInstances(store, projectId) {
+	return store.readTaskLifecycleInstances(projectId).filter((instance) => instance.terminalAtMs === void 0);
+}
+async function routeTaskLifecycleCandidateOnce(input) {
+	const candidateText = input.candidateText.trim();
+	if (!candidateText) throw new TaskLifecycleJudgmentUnavailableError("task lifecycle judgment requires non-empty candidate text");
+	const provisional = provisionalAssertion({
+		...input,
+		candidateText
+	});
+	let candidateInstances = readCurrentOpenTaskInstances(input.store, input.projectId);
+	let candidates = buildTaskLifecycleCandidateSet(provisional, candidateInstances);
+	if (!input.confirmedTaskCandidate && candidates.length === 0) return { status: "none" };
+	const allowedActions = input.confirmedTaskCandidate ? TASK_LIFECYCLE_MODEL_ACTIONS : [
+		"complete",
+		"remove",
+		"none"
+	];
+	let conflictRetries = 0;
+	for (let attempt = 0; attempt < 3; attempt += 1) {
+		const judgedCandidateSetVersion = taskLifecycleCandidateSetVersion(candidates);
+		let verdict;
+		let modelUnavailable = false;
+		try {
+			verdict = await requestModelJudgment({
+				candidateText,
+				allowedActions,
+				candidates,
+				...input.llm === void 0 ? {} : { llm: input.llm },
+				...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs },
+				...input.signal === void 0 ? {} : { signal: input.signal }
+			});
+		} catch (error) {
+			if (error instanceof LlmClientTerminalError && error.category === "cancelled" && !error.requestTimedOut) throw error;
+			modelUnavailable = true;
+			verdict = {
+				action: input.confirmedTaskCandidate ? "open_or_refine" : "none",
+				taskId: null
+			};
+		}
+		const currentInstances = readCurrentOpenTaskInstances(input.store, input.projectId);
+		const currentCandidates = buildTaskLifecycleCandidateSet(provisional, currentInstances);
+		if (taskLifecycleCandidateSetVersion(currentCandidates) !== judgedCandidateSetVersion) {
+			conflictRetries += 1;
+			candidateInstances = currentInstances;
+			candidates = currentCandidates;
+			continue;
+		}
+		if (verdict.action === "none") return { status: "none" };
+		const selected = verdict.taskId === null ? void 0 : candidates.find((candidate) => candidate.activeTaskId === verdict.taskId);
+		const assertion = {
+			kind: "task_lifecycle",
+			action: verdict.action,
+			projectId: input.projectId,
+			subject: "user",
+			description: verdict.action === "open_or_refine" ? candidateText : selected?.currentDescription ?? candidateText,
+			occurrenceAnchors: input.occurrenceAnchors ?? {},
+			revisionDetails: input.revisionDetails ?? {},
+			...input.evidenceMemoryId === void 0 ? {} : { evidenceMemoryId: input.evidenceMemoryId }
+		};
+		const finalCandidateSetVersion = taskLifecycleCandidateSetVersion(buildTaskLifecycleCandidateSet({
+			...provisional,
+			action: verdict.action,
+			description: assertion.description
+		}, candidateInstances));
+		const precomputedJudgment = verdict.taskId === null ? {
+			status: "completed",
+			value: { result: "distinct_instance" },
+			candidateSetVersion: finalCandidateSetVersion
+		} : {
+			status: "completed",
+			value: {
+				result: "same_instance",
+				activeTaskId: verdict.taskId
+			},
+			candidateSetVersion: finalCandidateSetVersion
+		};
+		try {
+			return {
+				status: "routed",
+				result: {
+					...await routeTaskLifecycleAssertion({
+						assertion,
+						source: input.source,
+						eventAt: input.eventAt,
+						sessionTime: input.sessionTime,
+						firstResolutionNowMs: input.firstResolutionNowMs,
+						store: input.store,
+						...modelUnavailable || input.llm === void 0 ? {} : { llm: input.llm },
+						...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs },
+						...input.signal === void 0 ? {} : { signal: input.signal },
+						...modelUnavailable ? {} : { precomputedJudgment },
+						precomputedInstances: candidateInstances
+					}),
+					conflictRetries
+				}
+			};
+		} catch (error) {
+			if (!(error instanceof TaskLifecycleStaleResolutionError)) throw error;
+			conflictRetries += 1;
+			candidateInstances = readCurrentOpenTaskInstances(input.store, input.projectId);
+			candidates = buildTaskLifecycleCandidateSet(provisional, candidateInstances);
+		}
+	}
+	throw new TaskLifecycleJudgmentUnavailableError("task lifecycle open-task set remained stale after three fresh judgments");
+}
+function taskLifecycleMutationOutcome(result) {
+	if (result.status === "none" || result.result.write.replayed) return { outcome: "no-mutation" };
+	if (result.result.write.result === "uncertain") return {
+		outcome: "preserved-without-adjudication",
+		refusalReason: "task_lifecycle_judgment_uncertain"
+	};
+	if (result.result.write.result === "none") return { outcome: "no-mutation" };
+	return { outcome: "committed" };
+}
+async function routeTaskLifecycleCandidate(input) {
+	return runWithMutationAttempt({
+		stateDir: dirname(input.store.dbPath),
+		event: "memory_updated",
+		operation: "task-lifecycle-update",
+		writer: "task-lifecycle",
+		subject: "active_tasks",
+		run: () => routeTaskLifecycleCandidateOnce(input),
+		completedOutcome: taskLifecycleMutationOutcome,
+		failedOutcome: (error) => error instanceof TaskLifecycleJudgmentUnavailableError ? {
+			outcome: "preserved-without-adjudication",
+			refusalReason: error.message
+		} : { outcome: "failed" }
+	});
+}
+async function requestJudgment(input, assertion) {
+	if (!input.llm) return { status: "absent" };
+	const candidates = buildTaskLifecycleCandidateSet(assertion, readCurrentOpenTaskInstances(input.store, assertion.projectId));
+	if (candidates.length === 0) return { status: "absent" };
+	try {
+		const value = await requestTaskLifecycleJson({
+			llm: input.llm,
+			accept: acceptsTaskLifecycleJudgment,
+			prompt: [
+				TASK_LIFECYCLE_JUDGMENT_SKILL.existingTaskRelation,
+				"Return exactly one JSON object: {\"result\":\"same_instance\",\"activeTaskId\":\"...\"} or {\"result\":\"distinct_instance\"} or {\"result\":\"none\"} or {\"result\":\"uncertain\"}.",
+				"Select same_instance only with an activeTaskId from candidates.",
+				`Assertion: ${JSON.stringify(assertion)}`,
+				`Candidates: ${JSON.stringify(candidates)}`
+			].join("\n"),
+			...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs },
+			...input.signal === void 0 ? {} : { signal: input.signal }
+		});
+		return value === null ? { status: "absent" } : {
+			status: "completed",
+			value,
+			candidateSetVersion: taskLifecycleCandidateSetVersion(candidates)
+		};
+	} catch {
+		return { status: "absent" };
+	}
+}
+async function routeTaskLifecycleAssertion(input) {
+	const commandClaim = buildTaskLifecycleCommandClaim({
+		assertion: input.assertion,
+		source: input.source
+	});
+	const admission = admitTaskLifecycleAssertion(input.store, {
+		assertion: input.assertion,
+		source: input.source,
+		commandClaim,
+		...input.eventAt === void 0 ? {} : { eventAt: input.eventAt },
+		...input.sessionTime === void 0 ? {} : { sessionTime: input.sessionTime },
+		firstResolutionNowMs: input.firstResolutionNowMs
+	});
+	const replay = input.store.findTaskLifecycleCommandReplay({
+		admission,
+		commandClaim
+	});
+	if (replay) return {
+		resolution: null,
+		write: replay,
+		effectiveAtMs: admission.assertion.effectiveAtMs,
+		timeSource: admission.assertion.timeSource,
+		conflictRetries: 0
+	};
+	const instances = input.precomputedInstances ?? input.store.readTaskLifecycleInstances(admission.assertion.projectId);
+	const deterministic = resolveTaskLifecycle({
+		assertion: admission.assertion,
+		instances,
+		judgment: { status: "absent" }
+	});
+	const resolution = input.precomputedJudgment !== void 0 ? resolveTaskLifecycle({
+		assertion: admission.assertion,
+		instances,
+		judgment: input.precomputedJudgment
+	}) : deterministic.result !== "uncertain" ? deterministic : resolveTaskLifecycle({
+		assertion: admission.assertion,
+		instances,
+		judgment: await requestJudgment(input, admission.assertion)
+	});
+	return {
+		resolution,
+		write: await input.store.applyTaskLifecycleResolution({
+			admission,
+			commandClaim,
+			resolution
+		}),
+		effectiveAtMs: admission.assertion.effectiveAtMs,
+		timeSource: admission.assertion.timeSource,
+		conflictRetries: 0
+	};
+}
+//#endregion
+//#region src/engine/extraction/profile-section-writer.ts
+/** @file profile-section-writer.ts
+* @purpose Mutation-native profile section writer for current-state memory.
+* @boundary Owns profile rows only; no retrieval injection or conflict scan.
+*/
+function createRetireByNameRunBudget(timeoutMs) {
+	const durationMs = Math.min(timeoutMs ?? 3e4, RETIRE_BY_NAME_MAX_DURATION_MS);
+	return {
+		remaining: 8,
+		deadlineMs: Date.now() + durationMs
+	};
+}
+const PROFILE_IDENTITY_SECTION = "identity";
+const retiredProfileSectionMarker = (canonicalSection) => `${canonicalSection}: none`;
+const PROFILE_CONFLICT_TOP_K = 5;
+const CLEAR_RETIRE_BY_NAME_PENDING_ATTEMPTS = 3;
+const ADVANCE_PROFILE_CONFIRMATION_ATTEMPTS = 3;
+/** Work items one profile row's pending marker may hold. Past this the oldest is dropped. */
+const RETIRE_BY_NAME_MAX_PENDING_WORK_ITEMS = 16;
+const log = createLogger("sno-station-mem:profile-section-writer");
+function adapterAViewFromEntry(entry) {
+	const metadata = parseInsightMetadata(entry.metadata, entry);
+	return adapterAViewFromRecord({
+		text: metadata.l2_content ?? entry.text,
+		kind: entry.category,
+		validFrom: metadata.valid_from ?? entry.timestamp,
+		assertedAt: metadata.asserted_at ?? entry.timestamp,
+		contentHash: entry.contentHash
+	});
+}
+const profileJudgmentResponseSchema = z.object({
+	verdict: z.enum([
+		"merge",
+		"tombstone",
+		"no-op"
+	]),
+	retired_clause_indices: z.array(z.number().int().nonnegative())
+}).strict();
+const profileTextResponseSchema = z.object({
+	abstract: z.string().trim().min(1),
+	overview: z.string().trim().min(1),
+	content: z.string()
+}).strict();
+const lifecycleRetirementResponseSchema = z.object({ lifecycle_retired_clause_indices: z.array(z.number().int().nonnegative()) }).strict();
+const PROFILE_SECTION_JUDGMENT_INSTRUCTIONS = [
+	"Judge one current-state profile update.",
+	"Return JSON only: {\"verdict\":\"merge|tombstone|no-op\",\"retired_clause_indices\":[0]}.",
+	"Do not return content, summaries, explanations, or any generated prose.",
+	"Indices are zero-based positions into the supplied array. Use each index at most once.",
+	"For merge, retire only clauses that the incoming assertion replaces, removes, or makes historical.",
+	"For tombstone, retire the whole section and return an empty index array.",
+	"Choose tombstone when the incoming clause explicitly asks to delete, remove, forget, or stop tracking the entire saved section or preference. A changed or negated preference that still states current user information is merge, not tombstone.",
+	"For no-op, return an empty index array and use it only when the stored state already covers every incoming clause.",
+	"Choose no-op when stored and incoming clauses state the same fact or preference with synonymous wording; a paraphrase is not a replacement.",
+	"Never retire every incoming clause.",
+	"For preferences.general, ownership is an independent retirement reason and does not require the incoming clause to contradict or replace the stored clause. Each listed sibling suffix names the topic it owns. Retire a stored general clause when its meaning belongs to that topic; for example, when preferences.films is listed, retire a stored general clause saying the user likes James Stewart movies. Keep a general clause when no listed sibling owns its topic. One fact family has one owner."
+];
+function renderProfileSectionJudgmentPrompt(input) {
+	return [
+		...PROFILE_SECTION_JUDGMENT_INSTRUCTIONS,
+		`Section: ${input.sectionName}`,
+		input.topic ? `Topic: ${input.topic}` : "Topic: <missing>",
+		`Eligible clauses: ${JSON.stringify(input.clauses)}`,
+		`Live specific sibling sections: ${JSON.stringify(input.liveSiblingSectionNames ?? [])}`,
+		input.evidence ? `Evidence:\n${input.evidence}` : ""
+	].join("\n\n");
+}
+function renderProfileSectionTextPrompt(input) {
+	return [
+		"Write one current-state profile section after a separate judgment has already finished.",
+		"Return JSON only: {\"abstract\":\"...\",\"overview\":\"...\",\"content\":\"...\"}.",
+		"Do not decide or name superseded clauses. Do not return a verdict or clause indices.",
+		"The content must contain every retained clause below verbatim as a whole clause. Do not add connective text or any other clause. Do not reword or omit a retained clause.",
+		`Section: ${input.sectionName}`,
+		input.topic ? `Topic: ${input.topic}` : "Topic: <missing>",
+		`Retained clauses: ${JSON.stringify(input.retainedClauses)}`,
+		`Already retired clauses: ${JSON.stringify(input.retiredClauses)}`,
+		input.evidence ? `Evidence:\n${input.evidence}` : ""
+	].join("\n\n");
+}
+function parseProfileSectionJudgment(response, clauses) {
+	const parsed = profileJudgmentResponseSchema.safeParse(response);
+	if (!parsed.success) return void 0;
+	const indices = parsed.data.retired_clause_indices;
+	if (new Set(indices).size !== indices.length) return void 0;
+	if (indices.some((index) => index >= clauses.length)) return void 0;
+	if (parsed.data.verdict !== "merge" && indices.length > 0) return void 0;
+	const incomingIndices = clauses.flatMap((clause, index) => clause.origin === "incoming" ? [index] : []);
+	if (incomingIndices.length > 0 && incomingIndices.every((index) => indices.includes(index))) return;
+	return {
+		verdict: parsed.data.verdict,
+		retiredClauseIndices: indices,
+		retiredClauses: indices.map((index) => clauses[index]?.value ?? "")
+	};
+}
+/**
+* Deferrals a single lifecycle work item may collect before it is dropped. A route that is ON
+* but keeps answering unusably (transport error, malformed reply) would otherwise re-queue the
+* same positions on every write for the life of the store.
+*/
+const LIFECYCLE_RETIREMENT_MAX_DEFERRALS = 3;
+/**
+* Only an ANSWER can exhaust the bound. A transport error or timeout says nothing about whether
+* the route can ever answer, and three timeouts is an ordinary afternoon on a busy GPU — counting
+* them would throw away a retirement and leave the stale row it named live for good. A malformed
+* or empty answer from a route that resolved ON is the failure that repeats, so it is the one
+* that counts.
+*/
+function deferLifecycleRetirement(retiredClauses, incomingAssertion, liveSiblingSectionNames, attempts = 0, failure = "malformed-answer") {
+	const nextAttempts = failure === "transport" ? attempts : attempts + 1;
+	if (nextAttempts >= LIFECYCLE_RETIREMENT_MAX_DEFERRALS) {
+		log.warn("lifecycle retirement dropped after repeated unusable answers", {
+			positions: retiredClauses.length,
+			attempts: nextAttempts,
+			failure
+		}, {
+			event_name: "sno_station_mem.profile-section-writer.lifecycle.retirement.dropped.after.repeated.unusable.answers",
+			file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+			function: "deferLifecycleRetirement",
+			site_id: "profile-section-writer.deferLifecycleRetirement.f94b354ff4"
+		});
+		return {
+			kind: "classified",
+			positions: []
+		};
+	}
+	return {
+		kind: "deferred",
+		work: {
+			positions: [...retiredClauses],
+			context: {
+				incomingAssertion,
+				liveSiblingSectionNames: [...liveSiblingSectionNames],
+				attempts: nextAttempts,
+				lastFailure: failure
+			}
+		}
+	};
+}
+async function lifecycleRetireByNamePositions(params, liveSiblingSectionNames, retiredClauses, incomingAssertion = params.newAssertion, attempts = 0) {
+	if (params.sectionName !== "preferences.general" || liveSiblingSectionNames.length === 0 || retiredClauses.length === 0) return {
+		kind: "classified",
+		positions: [...retiredClauses]
+	};
+	if (profileMergeCallHasNoModel(params, "P2")) return {
+		kind: "classified",
+		positions: []
+	};
+	let response;
+	try {
+		response = await params.llm?.completeJson({
+			prompt: [
+				"Separate lifecycle retirement from profile ownership cleanup.",
+				"Return JSON only: {\"lifecycle_retired_clause_indices\":[0]}.",
+				"Indices are zero-based positions into Removed clauses.",
+				"Include a clause only when the incoming assertion replaces it, removes it, or makes it historical.",
+				"Exclude a clause removed only because a live specific sibling section owns its topic.",
+				`Incoming assertion: ${JSON.stringify(incomingAssertion)}`,
+				`Removed clauses: ${JSON.stringify(retiredClauses)}`,
+				`Live specific sibling sections: ${JSON.stringify(liveSiblingSectionNames)}`
+			].join("\n\n"),
+			callId: "P2",
+			...params.timeoutMs ? { timeoutMs: params.timeoutMs } : {},
+			...params.signal ? { signal: params.signal } : {}
+		});
+	} catch (error) {
+		rethrowCallerCancellation(error);
+		return deferLifecycleRetirement(retiredClauses, incomingAssertion, liveSiblingSectionNames, attempts, "transport");
+	}
+	const parsed = lifecycleRetirementResponseSchema.safeParse(response);
+	if (!parsed.success) return deferLifecycleRetirement(retiredClauses, incomingAssertion, liveSiblingSectionNames, attempts);
+	const indices = parsed.data.lifecycle_retired_clause_indices;
+	if (new Set(indices).size !== indices.length || indices.some((index) => index >= retiredClauses.length)) return deferLifecycleRetirement(retiredClauses, incomingAssertion, liveSiblingSectionNames, attempts);
+	return {
+		kind: "classified",
+		positions: indices.map((index) => retiredClauses[index] ?? "").filter(Boolean)
+	};
+}
+/** The caller cancelled the whole operation; a model failure or a request timeout still degrades. */
+function rethrowCallerCancellation(error) {
+	if (error instanceof LlmClientTerminalError && error.category === "cancelled" && !error.requestTimedOut) throw error;
+}
+async function runProfileSectionUpdate(params) {
+	const started = performance.now();
+	try {
+		const trimmedSectionName = params.sectionName.trim();
+		if (!trimmedSectionName) throw new Error("profile-section-writer: sectionName is required");
+		if (!params.scope.trim()) throw new Error("profile-section-writer: scope is required");
+		const sectionName = canonicalizeProfileSectionName(trimmedSectionName);
+		const normalizedParams = sectionName === params.sectionName ? params : {
+			...params,
+			sectionName
+		};
+		if (sectionName === "active_tasks") {
+			const result = await runTypedActiveTaskUpdate(normalizedParams);
+			log.info("Profile task update completed", {
+				outcome: result.outcome,
+				memory_id: result.rowId,
+				duration_ms: performance.now() - started,
+				committed_count: "unavailable",
+				committed_count_reason: "task_route_returns_outcome_not_count"
+			}, {
+				event_name: "memory.profile.completed",
+				file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+				function: "runProfileSectionUpdate",
+				site_id: "memory.profile.task.completed"
+			});
+			return result;
+		}
+		const result = await runWithMutationAttempt({
+			stateDir: dirname(params.store.dbPath),
+			event: "memory_superseded",
+			operation: "profile-section-update",
+			writer: "profile-section",
+			subject: sectionName,
+			run: async () => {
+				try {
+					return await runProfileSectionUpdateOnce(normalizedParams);
+				} catch (error) {
+					if (!(error instanceof StaleSupersedeTargetError)) throw error;
+					return runProfileSectionUpdateOnce(normalizedParams);
+				}
+			},
+			completedOutcome: (completed) => ({
+				outcome: completed.mutationOutcome,
+				...completed.refusalReason === void 0 ? {} : { refusalReason: completed.refusalReason }
+			})
+		});
+		log.info("Profile section update completed", {
+			outcome: result.outcome,
+			mutation_outcome: result.mutationOutcome,
+			memory_id: result.rowId,
+			duration_ms: performance.now() - started,
+			reason_code: result.refusalReason ?? "not_refused",
+			committed_count: "unavailable",
+			committed_count_reason: "writer_returns_outcome_not_count"
+		}, {
+			event_name: "memory.profile.completed",
+			file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+			function: "runProfileSectionUpdate",
+			site_id: "memory.profile.section.completed"
+		});
+		return {
+			outcome: result.outcome,
+			rowId: result.rowId
+		};
+	} catch (error) {
+		log.warn("Profile section update failed", {
+			outcome: "failed",
+			error,
+			duration_ms: performance.now() - started,
+			committed_count: "unavailable",
+			committed_count_reason: "multi_step_write_failed"
+		}, {
+			event_name: "memory.profile.failed",
+			file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+			function: "runProfileSectionUpdate",
+			site_id: "memory.profile.failed"
+		});
+		throw error;
+	}
+}
+async function runTypedActiveTaskUpdate(params) {
+	const sessionKey = params.source.sessionKey ?? params.source.messageId;
+	const replayIdentity = params.source.messageId;
+	if (!sessionKey || !replayIdentity) throw new Error("profile-section-writer: active task updates require an authorized replay identity");
+	const route = await routeTaskLifecycleCandidate({
+		projectId: params.scope,
+		candidateText: params.newAssertion,
+		confirmedTaskCandidate: params.confirmedTaskCandidate !== false,
+		source: {
+			kind: "authorized_untraced",
+			sessionKey,
+			replayIdentity,
+			assertionOrdinal: 0
+		},
+		firstResolutionNowMs: params.at,
+		store: params.store,
+		...params.llm === void 0 ? {} : { llm: params.llm },
+		...params.timeoutMs === void 0 ? {} : { timeoutMs: params.timeoutMs },
+		...params.signal === void 0 ? {} : { signal: params.signal }
+	});
+	if (route.status === "none") {
+		const safetyNet = await writeEpisodicSafetyNet(params, "task_lifecycle_none");
+		return {
+			outcome: safetyNet.replayed ? "no-op" : "appended",
+			rowId: safetyNet.rowId
+		};
+	}
+	const { result } = route;
+	return {
+		outcome: result.write.replayed || result.write.result === "none" || result.write.result === "uncertain" ? "no-op" : result.write.result === "created_instance" || result.write.result === "created_unresolved_instance" ? "appended" : "merged",
+		rowId: result.write.activeTaskId ?? ""
+	};
+}
+async function runProfileSectionUpdateOnce(params) {
+	const sectionName = params.sectionName;
+	const factKey = profileFactKey(sectionName);
+	const countRecordTokens = await recordTokenCounter(params.store.embedder);
+	const existing = params.store.getByFactKey(params.scope, factKey);
+	if (!existing) {
+		const content = params.newAssertion;
+		const written = await writeProfileRow({
+			params,
+			content,
+			input: profileStoreInput({
+				countRecordTokens,
+				scope: params.scope,
+				sectionName,
+				topic: params.topic,
+				content,
+				evidence: params.evidence,
+				metadataPatch: params.metadataPatch,
+				source: params.source,
+				at: params.at,
+				supersedes: void 0
+			}),
+			outcome: "appended"
+		});
+		return {
+			...written,
+			mutationOutcome: written.outcome === "no-op" ? "no-mutation" : "committed"
+		};
+	}
+	const existingValidFrom = parseInsightMetadata(existing.metadata, existing).valid_from;
+	if (typeof existingValidFrom === "number" && params.at < existingValidFrom) {
+		await resumeRetireByNamePending(existing, params);
+		return {
+			outcome: "no-op",
+			rowId: existing.id,
+			mutationOutcome: "no-mutation"
+		};
+	}
+	const existingContent = parseInsightMetadata(existing.metadata, existing).l2_content;
+	const existingIsRetiredMarker = typeof existingContent === "string" && normalizeExactAssertionText(existingContent) === normalizeExactAssertionText(retiredProfileSectionMarker(sectionName));
+	if (typeof existingContent === "string" && normalizeExactAssertionText(existingContent) === normalizeExactAssertionText(params.newAssertion)) {
+		await resumeRetireByNamePending(await advanceProfileConfirmation(existing, existingValidFrom, params), params);
+		return {
+			outcome: "no-op",
+			rowId: existing.id,
+			mutationOutcome: "no-mutation"
+		};
+	}
+	const tombstoneReplay = await tombstoneReplayResult(params, factKey);
+	if (tombstoneReplay) return {
+		...tombstoneReplay,
+		mutationOutcome: "no-mutation"
+	};
+	const merged = await mergeProfileSection(existing, params);
+	if (merged.kind === "preserved-without-adjudication") {
+		if (typeof existingContent === "string" && normalizeExactAssertionText(merged.content) === normalizeExactAssertionText(existingContent)) {
+			await resumeRetireByNamePending(existing, params);
+			return {
+				outcome: "no-op",
+				rowId: existing.id,
+				mutationOutcome: "no-mutation"
+			};
+		}
+		const written = await writeProfileRow({
+			params,
+			content: merged.content,
+			input: profileStoreInput({
+				countRecordTokens,
+				scope: params.scope,
+				sectionName,
+				topic: params.topic,
+				content: merged.content,
+				evidence: params.evidence,
+				metadataPatch: {
+					...params.metadataPatch,
+					merged_without_adjudication: true,
+					adjudication_failure_reason: merged.reason
+				},
+				source: params.source,
+				at: params.at,
+				supersedes: existing.id
+			}),
+			existing,
+			outcome: "merged"
+		});
+		return {
+			...written,
+			mutationOutcome: written.outcome === "no-op" ? "no-mutation" : "preserved-without-adjudication"
+		};
+	}
+	if (merged.kind === "no-op") {
+		await resumeRetireByNamePending(await advanceProfileConfirmation(existing, existingValidFrom, params), params);
+		return {
+			outcome: "no-op",
+			rowId: existing.id,
+			mutationOutcome: "no-mutation"
+		};
+	}
+	if (merged.kind === "tombstone") {
+		if (existingIsRetiredMarker) {
+			await resumeRetireByNamePending(existing, params);
+			let event;
+			try {
+				event = await params.store.supersede({
+					create: tombstoneEventStoreInput(params, existing.id),
+					closes: [],
+					activeFactGuard: {
+						factKey,
+						expectedId: existing.id
+					}
+				});
+			} catch (error) {
+				const replay = await tombstoneReplayResult(params, factKey);
+				if (replay) return {
+					...replay,
+					mutationOutcome: "no-mutation"
+				};
+				throw error;
+			}
+			log.warn("retired profile section tombstone reaffirmed", {
+				eventRowId: event.id,
+				markerRowId: existing.id,
+				section: sectionName,
+				verdict: merged.kind
+			}, {
+				event_name: "sno_station_mem.profile-section-writer.retired.profile.section.tombstone.reaffirmed",
+				file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+				function: "runProfileSectionUpdateOnce",
+				site_id: "profile-section-writer.runProfileSectionUpdateOnce.28936dcd3c"
+			});
+			return {
+				outcome: "tombstoned",
+				rowId: existing.id,
+				mutationOutcome: "committed"
+			};
+		}
+		const tombstonePending = appendRetireByNameWork(readRetireByNamePending(existing), profileMergeCallHasNoModel(params, "P6") ? [] : splitExactClauses(existingContent ?? existing.text), params, [existing.id], "profile-tombstone");
+		const markerInput = profileStoreInput({
+			countRecordTokens,
+			scope: params.scope,
+			sectionName,
+			topic: params.topic,
+			content: retiredProfileSectionMarker(sectionName),
+			metadataPatch: {
+				idempotency_key: tombstoneMarkerIdempotencyKey(params),
+				content_identity_key: tombstoneMarkerIdempotencyKey(params)
+			},
+			source: params.source,
+			at: params.at,
+			supersedes: existing.id
+		});
+		const replacement = tombstonePending === void 0 ? markerInput : {
+			...markerInput,
+			metadata: addRetireByNamePending(markerInput.metadata, tombstonePending)
+		};
+		let created;
+		try {
+			created = await params.store.createEventAndSupersede({
+				event: tombstoneEventStoreInput(params, existing.id),
+				replacement,
+				closeExisting: [{
+					id: existing.id,
+					buildMetadata: ({ replacementId }) => closeProfileMetadata(existing, replacementId, params.at)
+				}],
+				profileRecovery: {
+					mutationAttemptId: currentMutationAttemptId(),
+					sectionName,
+					removedAtMs: params.at
+				}
+			});
+		} catch (error) {
+			const replay = await tombstoneReplayResult(params, factKey);
+			if (replay) return {
+				...replay,
+				mutationOutcome: "no-mutation"
+			};
+			throw error;
+		}
+		if (tombstonePending) await completeRetireByNamePending(created.replacement, params, tombstonePending);
+		log.warn("profile section tombstoned; incoming assertion preserved", {
+			closedRowId: existing.id,
+			eventRowId: created.event.id,
+			markerRowId: created.replacement.id,
+			section: sectionName,
+			verdict: merged.kind
+		}, {
+			event_name: "sno_station_mem.profile-section-writer.profile.section.tombstoned.incoming.assertion.preserved",
+			file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+			function: "runProfileSectionUpdateOnce",
+			site_id: "profile-section-writer.runProfileSectionUpdateOnce.e3afdfb6d8"
+		});
+		return {
+			outcome: "tombstoned",
+			rowId: created.replacement.id,
+			mutationOutcome: "committed"
+		};
+	}
+	if (typeof existingContent === "string" && normalizeExactAssertionText(merged.content) === normalizeExactAssertionText(existingContent)) {
+		await resumeRetireByNamePending(existing, params);
+		return {
+			outcome: "no-op",
+			rowId: existing.id,
+			mutationOutcome: "no-mutation"
+		};
+	}
+	const written = await writeProfileRow({
+		params,
+		content: merged.content,
+		input: profileStoreInput({
+			countRecordTokens,
+			scope: params.scope,
+			sectionName,
+			topic: params.topic,
+			content: merged.content,
+			evidence: params.evidence,
+			metadataPatch: {
+				...params.metadataPatch,
+				...merged.retirementRecheck ? { profile_retirement_recheck: merged.retirementRecheck } : {}
+			},
+			source: params.source,
+			at: params.at,
+			supersedes: existing.id,
+			abstract: sectionName === "identity" ? void 0 : merged.abstract,
+			overview: sectionName === "identity" ? void 0 : merged.overview
+		}),
+		existing,
+		retiredPositions: merged.retireByNamePositions,
+		...merged.deferredLifecycleRetirement ? { deferredLifecycleRetirement: merged.deferredLifecycleRetirement } : {},
+		outcome: "merged"
+	});
+	if (merged.textRepair !== void 0) log.warn("profile text step not used; row written from the judged clauses", {
+		memory_id: existing.id,
+		section: sectionName,
+		reason_code: "text_repair_required",
+		reason_detail: merged.textRepair.reason
+	}, {
+		event_name: "sno_station_mem.profile-section-writer.profile.text.step.not.used.row.written.from.the.judged.clauses",
+		file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+		function: "runProfileSectionUpdateOnce",
+		site_id: "profile-section-writer.runProfileSectionUpdateOnce.80241da6d8"
+	});
+	return {
+		...written,
+		mutationOutcome: written.outcome === "no-op" ? "no-mutation" : merged.textRepair !== void 0 ? "repaired-merge-text" : "committed"
+	};
+}
+function profileFactKey(sectionName) {
+	const factKey = deriveFactKey({
+		kind: "profile",
+		section_name: sectionName
+	});
+	if (!factKey) throw new Error("profile-section-writer: unable to derive profile fact_key");
+	return factKey;
+}
+const PROFILE_RETIREMENT_RECHECK_CONCURRENCY = 4;
+const PROFILE_RETIREMENT_RECHECK_MAX_TOKENS = 64;
+const PROFILE_RETIREMENT_RECHECK_SIBLING_CHARS = 600;
+const PROFILE_RETIREMENT_RECHECK_PROMPT_TEMPLATE = [RETIRED_POSITION_JUDGMENT_SKILL.retirementRecheck, "Return JSON only, exactly one boolean field named retire: {\"retire\":true} or {\"retire\":false}."].join("\n\n");
+const PROFILE_RETIREMENT_RECHECK_PROMPT_SHA256 = createHash("sha256").update(PROFILE_RETIREMENT_RECHECK_PROMPT_TEMPLATE).digest("hex");
+const PROFILE_RETIREMENT_RECHECK_SAMPLING = {
+	temperature: "provider-default",
+	enableThinking: false,
+	maxTokens: PROFILE_RETIREMENT_RECHECK_MAX_TOKENS
+};
+function parseRecheckVerdict(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const record = value;
+	if (Object.keys(record).length !== 1 || typeof record["retire"] !== "boolean") return;
+	return record["retire"];
+}
+function renderRetirementRecheckPrompt(input) {
+	const siblings = {};
+	if (input.sectionName === "preferences.general") for (const [name, content] of input.siblingContents) siblings[name] = content.slice(0, PROFILE_RETIREMENT_RECHECK_SIBLING_CHARS);
+	return [
+		PROFILE_RETIREMENT_RECHECK_PROMPT_TEMPLATE,
+		`Section: ${input.sectionName}`,
+		`Stored clause (retired): ${JSON.stringify(input.storedClause)}`,
+		`Incoming assertion: ${JSON.stringify(input.incomingAssertion)}`,
+		`Live sibling sections and their content: ${JSON.stringify(siblings)}`
+	].join("\n\n");
+}
+/**
+* The second key on every clause the profile judgement retired from `preferences.general`.
+* Measured 2026-09-01 on the Memora store: 753 clauses were retired across 1,149
+* rewrites, 317 of them shared no content word with the incoming assertion, and 238 of those in
+* the general section had no live sibling carrying them; replayed one by one, 39 of 40 such
+* retirements were judged wrong, while 14 of 20 genuine replacements were still retired. A
+* retirement stands only when this focused question also answers yes; an unusable answer keeps
+* the clause.
+*/
+async function recheckProfileRetirements(input) {
+	const llm = input.params.llm;
+	if (!llm || input.retiredClauseIndices.length === 0) return { retiredClauseIndices: [...input.retiredClauseIndices] };
+	const durationMs = Math.min(input.params.timeoutMs ?? 3e4, RETIRE_BY_NAME_MAX_DURATION_MS);
+	const deadlineMs = Date.now() + durationMs;
+	const candidates = input.retiredClauseIndices.slice(0, 16);
+	const checked = [];
+	const verdicts = [];
+	for (let offset = 0; offset < candidates.length;) {
+		if (Date.now() >= deadlineMs) break;
+		const batchSize = Math.min(PROFILE_RETIREMENT_RECHECK_CONCURRENCY, candidates.length - offset);
+		const batch = candidates.slice(offset, offset + batchSize);
+		const remainingMs = Math.max(1, deadlineMs - Date.now());
+		checked.push(...batch);
+		verdicts.push(...await Promise.all(batch.map(async (index) => {
+			const clause = input.clauses[index];
+			if (!clause) return void 0;
+			try {
+				return parseRecheckVerdict(await llm.completeJson({
+					prompt: renderRetirementRecheckPrompt({
+						sectionName: input.params.sectionName,
+						storedClause: clause.value,
+						incomingAssertion: input.params.newAssertion,
+						siblingContents: input.siblingContents
+					}),
+					callId: "P3",
+					maxTokens: PROFILE_RETIREMENT_RECHECK_MAX_TOKENS,
+					enableThinking: false,
+					timeoutMs: Math.min(input.params.timeoutMs ?? remainingMs, remainingMs),
+					...input.params.signal ? { signal: input.params.signal } : {}
+				}));
+			} catch (error) {
+				rethrowCallerCancellation(error);
+				return;
+			}
+		})));
+		offset += batch.length;
+	}
+	let resolved;
+	try {
+		resolved = await llm.getResolvedConfig();
+	} catch (error) {
+		log.warn("profile retirement recheck could not resolve the model for its receipt", {
+			section: input.params.sectionName,
+			error
+		}, {
+			event_name: "sno_station_mem.profile-section-writer.profile.retirement.recheck.could.not.resolve.the.model.for.its.receipt",
+			file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+			function: "recheckProfileRetirements",
+			site_id: "profile-section-writer.recheckProfileRetirements.613c569527"
+		});
+		resolved = {
+			model: "unresolved",
+			preset: "unresolved"
+		};
+	}
+	const retiredClauseIndices = [];
+	const retired = [];
+	const kept = [];
+	checked.forEach((index, position) => {
+		const value = input.clauses[index]?.value ?? "";
+		if (verdicts[position] === true) {
+			retiredClauseIndices.push(index);
+			retired.push(value);
+		} else kept.push(value);
+	});
+	const unchecked = input.retiredClauseIndices.length - checked.length;
+	const route = input.params.routing ? resolveLlmRoute({
+		callId: "P3",
+		config: input.params.routing
+	}) : null;
+	const destination = route === null ? "host" : "off" in route ? "off" : route.destination;
+	return {
+		retiredClauseIndices,
+		receipt: {
+			call_id: "P3",
+			destination,
+			prompt_sha256: PROFILE_RETIREMENT_RECHECK_PROMPT_SHA256,
+			model: destination === "host" ? "host" : resolved.model,
+			preset: destination === "host" ? "host" : resolved.preset,
+			sampling: PROFILE_RETIREMENT_RECHECK_SAMPLING,
+			retired,
+			kept,
+			unchecked
+		}
+	};
+}
+async function mergeProfileSection(existing, params) {
+	const existingContent = parseInsightMetadata(existing.metadata, existing).l2_content;
+	const mergeBase = typeof existingContent === "string" && normalizeExactAssertionText(existingContent) === normalizeExactAssertionText(retiredProfileSectionMarker(params.sectionName)) ? "" : typeof existingContent === "string" ? existingContent : existing.text;
+	const clausesByValue = /* @__PURE__ */ new Map();
+	for (const value of splitExactClauses(mergeBase)) clausesByValue.set(value, {
+		origin: "stored",
+		value
+	});
+	for (const value of splitExactClauses(params.newAssertion)) clausesByValue.set(value, {
+		origin: "incoming",
+		value
+	});
+	const clauses = [...clausesByValue.values()];
+	const liveSiblings = await listLiveSpecificSiblings(params);
+	const liveSiblingSectionNames = liveSiblings.map((sibling) => sibling.name);
+	const judgmentPrompt = renderProfileSectionJudgmentPrompt({
+		sectionName: params.sectionName,
+		topic: params.topic,
+		clauses,
+		evidence: params.evidence,
+		liveSiblingSectionNames
+	});
+	let response;
+	let transportFailure;
+	if (params.llm) try {
+		response = await params.llm.completeJson({
+			prompt: judgmentPrompt,
+			callId: "P4",
+			...params.timeoutMs ? { timeoutMs: params.timeoutMs } : {},
+			...params.signal ? { signal: params.signal } : {},
+			accept: (value) => parseProfileSectionJudgment(value, clauses) !== void 0
+		});
+	} catch (error) {
+		rethrowCallerCancellation(error);
+		transportFailure = error instanceof LlmClientTerminalError ? error.category : "unknown";
+	}
+	const judgment = parseProfileSectionJudgment(response, clauses);
+	const noOpWouldDrop = judgment?.verdict === "no-op" && !sectionAlreadyCovers(mergeBase, params.newAssertion);
+	if (!judgment || noOpWouldDrop) {
+		const reason = noOpWouldDrop ? "no-op-would-drop-incoming" : transportFailure !== void 0 ? `transport-${transportFailure}` : response == null ? "null-or-absent-judgment" : "malformed-judgment";
+		log.warn("profile judgment unusable; deterministic preservation selected", {
+			section: params.sectionName,
+			reason
+		}, {
+			event_name: "sno_station_mem.profile-section-writer.profile.judgment.unusable.deterministic.preservation.selected",
+			file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+			function: "mergeProfileSection",
+			site_id: "profile-section-writer.mergeProfileSection.c707285ef3"
+		});
+		return {
+			kind: "preserved-without-adjudication",
+			content: fallbackProfileMerge(mergeBase, params.newAssertion),
+			reason
+		};
+	}
+	if (judgment.verdict === "no-op") return { kind: "no-op" };
+	if (judgment.verdict === "tombstone") return { kind: "tombstone" };
+	const recheck = params.sectionName === "preferences.general" ? await recheckProfileRetirements({
+		params,
+		clauses,
+		retiredClauseIndices: judgment.retiredClauseIndices,
+		siblingContents: judgment.retiredClauseIndices.length > 0 ? new Map(liveSiblings.map((sibling) => [sibling.name, sibling.content])) : /* @__PURE__ */ new Map()
+	}) : { retiredClauseIndices: [...judgment.retiredClauseIndices] };
+	const retiredClauses = recheck.retiredClauseIndices.map((index) => clauses[index]?.value ?? "");
+	const lifecycleRetirement = await lifecycleRetireByNamePositions(params, liveSiblingSectionNames, retiredClauses);
+	const retireByNamePositions = lifecycleRetirement.kind === "classified" ? lifecycleRetirement.positions : [];
+	const deferredLifecycleRetirement = lifecycleRetirement.kind === "deferred" ? lifecycleRetirement.work : void 0;
+	const retiredIndices = new Set(recheck.retiredClauseIndices);
+	const retainedClauses = clauses.flatMap((clause, index) => retiredIndices.has(index) ? [] : [clause.value]);
+	let textResponse;
+	try {
+		textResponse = await params.llm?.completeJson({
+			prompt: renderProfileSectionTextPrompt({
+				sectionName: params.sectionName,
+				topic: params.topic,
+				retainedClauses,
+				retiredClauses,
+				evidence: params.evidence
+			}),
+			callId: "P5",
+			...params.timeoutMs ? { timeoutMs: params.timeoutMs } : {},
+			...params.signal ? { signal: params.signal } : {}
+		});
+	} catch (error) {
+		rethrowCallerCancellation(error);
+		return judgedClauseMerge(retainedClauses, retireByNamePositions, `text-step-${error instanceof LlmClientTerminalError ? error.category : "unknown"}`, deferredLifecycleRetirement, recheck.receipt);
+	}
+	if (textResponse == null || typeof textResponse === "object" && textResponse !== null && "content" in textResponse && typeof textResponse.content === "string" && textResponse.content.trim() === "") return judgedClauseMerge(retainedClauses, retireByNamePositions, "text-step-returned-empty", deferredLifecycleRetirement, recheck.receipt);
+	const parsedText = profileTextResponseSchema.safeParse(textResponse);
+	if (!parsedText.success) return judgedClauseMerge(retainedClauses, retireByNamePositions, "text-step-malformed-response", deferredLifecycleRetirement, recheck.receipt);
+	const content = parsedText.data.content.trim();
+	if (!content) return judgedClauseMerge(retainedClauses, retireByNamePositions, "text-step-returned-empty", deferredLifecycleRetirement, recheck.receipt);
+	const contentClauses = splitExactClauses(content);
+	const sortedRetainedClauses = [...retainedClauses].sort();
+	const sortedContentClauses = [...contentClauses].sort();
+	if (sortedContentClauses.length === sortedRetainedClauses.length && sortedContentClauses.every((clause, index) => clause === sortedRetainedClauses[index])) return {
+		kind: "merge",
+		content,
+		abstract: parsedText.data.abstract,
+		overview: parsedText.data.overview,
+		retireByNamePositions,
+		...deferredLifecycleRetirement ? { deferredLifecycleRetirement } : {},
+		retainedClauses,
+		...recheck.receipt ? { retirementRecheck: recheck.receipt } : {}
+	};
+	return judgedClauseMerge(retainedClauses, retireByNamePositions, "text-step-changed-the-clause-set", deferredLifecycleRetirement, recheck.receipt);
+}
+/**
+* The merge the judgment itself already decided: exactly the clauses it kept, one per line.
+*
+* Used whenever the text step cannot be trusted to produce them — it failed, it returned nothing
+* usable, or it returned a different clause set. This never refuses. A refusal here used to leave
+* the row stale AND file the incoming fact as an episodic row, so an ordinary dependency failure
+* silently cost the profile its update while the caller was told a row had been written.
+*/
+function judgedClauseMerge(retainedClauses, retireByNamePositions, reason, deferredLifecycleRetirement, retirementRecheck) {
+	return {
+		kind: "merge",
+		content: retainedClauses.join("\n"),
+		retireByNamePositions,
+		...deferredLifecycleRetirement ? { deferredLifecycleRetirement } : {},
+		retainedClauses,
+		textRepair: { reason },
+		...retirementRecheck ? { retirementRecheck } : {}
+	};
+}
+function splitExactClauses(text) {
+	const rawClauses = [];
+	const separators = [];
+	let cursor = 0;
+	for (const boundary of text.matchAll(/\n+|(?<=[.!?;])\s+/gu)) {
+		rawClauses.push(text.slice(cursor, boundary.index));
+		separators.push(boundary[0]);
+		cursor = boundary.index + boundary[0].length;
+	}
+	rawClauses.push(text.slice(cursor));
+	if (rawClauses.map((clause, index) => `${clause}${separators[index] ?? ""}`).join("") !== text) throw new Error("profile-section-writer: exact clause segmentation was not lossless");
+	return rawClauses.map((clause) => clause.trim()).filter((clause) => clause.length > 0);
+}
+function profileStoreInput(args) {
+	const writerAgentId = resolveHookAgentId(args.source.agentId, args.source.sessionKey).agentId;
+	const rawText = args.content.trim();
+	const abstract = args.abstract?.trim() || firstSentence(rawText);
+	const text = boundSectionContent(rawText, abstract, args.countRecordTokens);
+	const overview = args.overview?.trim() || `- ${text}`;
+	const metadata = buildInsightMetadata({
+		text,
+		category: "profile",
+		timestamp: args.at
+	}, {
+		l0_abstract: abstract,
+		l1_overview: overview,
+		l2_content: text,
+		tier: "core",
+		access_count: 0,
+		confidence: .85,
+		last_accessed_at: args.at,
+		asserted_at: args.at,
+		valid_from: args.at,
+		source_session: args.source.sessionKey,
+		state: "confirmed",
+		source: args.source.source ?? "ambient-learning",
+		injected_count: 0,
+		bad_recall_count: 0,
+		suppressed_until_turn: 0,
+		...args.metadataPatch,
+		...writerAgentId ? { writer_agent_id: writerAgentId } : {},
+		section_name: args.sectionName,
+		...args.supersedes ? { supersedes: args.supersedes } : {},
+		...args.topic ? { topic: args.topic } : {},
+		...args.evidence ? { evidence: args.evidence } : {},
+		...args.sectionName === "preferences.general" && !args.topic ? { "profile.preference.missing_topic": true } : {}
+	});
+	return {
+		text: buildIndexedText(abstract, text),
+		category: "profile",
+		projectId: args.scope,
+		importance: .85,
+		timestamp: args.at,
+		metadata: stringifyInsightMetadata(metadata),
+		trusted: true
+	};
+}
+async function writeEpisodicSafetyNet(params, reason) {
+	const writerAgentId = resolveHookAgentId(params.source.agentId, params.source.sessionKey).agentId;
+	const assertion = params.newAssertion.trim();
+	const idempotencyKey = profileSafetyNetIdempotencyKey(params);
+	const metadata = buildInsightMetadata({
+		text: assertion,
+		category: "episodic",
+		timestamp: params.at
+	}, {
+		l0_abstract: assertion,
+		l1_overview: params.evidence?.trim() || `- ${assertion}`,
+		l2_content: assertion,
+		tier: "working",
+		access_count: 0,
+		confidence: .7,
+		last_accessed_at: params.at,
+		asserted_at: params.at,
+		valid_from: params.at,
+		...params.source.sessionKey ? { source_session: params.source.sessionKey } : {},
+		...writerAgentId ? { writer_agent_id: writerAgentId } : {},
+		...params.source.messageId ? { source_message_id: params.source.messageId } : {},
+		state: "confirmed",
+		source: params.source.source ?? "ambient-learning",
+		injected_count: 0,
+		bad_recall_count: 0,
+		suppressed_until_turn: 0,
+		idempotency_key: idempotencyKey
+	});
+	const stored = await params.store.store({
+		text: assertion,
+		category: "episodic",
+		projectId: params.scope,
+		importance: .7,
+		timestamp: params.at,
+		metadata: stringifyInsightMetadata(metadata)
+	});
+	log.warn("profile candidate routed to episodic safety net", {
+		reason,
+		rowId: stored.id
+	}, {
+		event_name: "sno_station_mem.profile-section-writer.profile.candidate.routed.to.episodic.safety.net",
+		file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+		function: "writeEpisodicSafetyNet",
+		site_id: "profile-section-writer.writeEpisodicSafetyNet.ae69446388"
+	});
+	return {
+		rowId: stored.id,
+		replayed: stored.storeWriteOutcome === "existing"
+	};
+}
+function profileSafetyNetIdempotencyKey(params) {
+	return `profile_safety_net_${stableShortHash(JSON.stringify([
+		tombstoneReplayIdentity(params),
+		canonicalizeProfileSectionName(params.sectionName),
+		normalizeExactAssertionText(params.newAssertion)
+	]))}`;
+}
+function tombstoneEventStoreInput(params, closedProfileRowId) {
+	const writerAgentId = resolveHookAgentId(params.source.agentId, params.source.sessionKey).agentId;
+	const assertion = params.newAssertion.trim();
+	const metadata = buildInsightMetadata({
+		text: assertion,
+		category: "episodic",
+		timestamp: params.at
+	}, {
+		l0_abstract: assertion,
+		l1_overview: `- ${assertion}`,
+		l2_content: assertion,
+		tier: "working",
+		access_count: 0,
+		confidence: .8,
+		last_accessed_at: params.at,
+		asserted_at: params.at,
+		valid_from: params.at,
+		...params.source.sessionKey ? { source_session: params.source.sessionKey } : {},
+		...writerAgentId ? { writer_agent_id: writerAgentId } : {},
+		...params.source.messageId ? { source_message_id: params.source.messageId } : {},
+		state: "confirmed",
+		source: params.source.source ?? "ambient-learning",
+		injected_count: 0,
+		bad_recall_count: 0,
+		suppressed_until_turn: 0,
+		section_name: params.sectionName,
+		closed_profile_row_id: closedProfileRowId,
+		profile_tombstone_verdict: "tombstone",
+		idempotency_key: tombstoneEventIdempotencyKey(params),
+		content_identity_key: tombstoneEventIdempotencyKey(params)
+	});
+	return {
+		text: assertion,
+		category: "episodic",
+		projectId: params.scope,
+		importance: .7,
+		timestamp: params.at,
+		metadata: stringifyInsightMetadata(metadata)
+	};
+}
+function tombstoneMarkerIdempotencyKey(params) {
+	return `profile_tombstone_marker_${stableShortHash([
+		params.scope,
+		params.sectionName,
+		tombstoneReplayIdentity(params)
+	].join("\0"))}`;
+}
+function tombstoneEventIdempotencyKey(params) {
+	return `profile_tombstone_event_${stableShortHash([
+		params.scope,
+		params.sectionName,
+		tombstoneReplayIdentity(params)
+	].join("\0"))}`;
+}
+async function tombstoneReplayResult(params, factKey) {
+	if (!params.store.findByExtractionIdempotencyKey(params.scope, tombstoneEventIdempotencyKey(params))) return;
+	const current = params.store.getByFactKey(params.scope, factKey);
+	if (!current) return void 0;
+	await resumeRetireByNamePending(current, params);
+	return {
+		outcome: "no-op",
+		rowId: current.id
+	};
+}
+function tombstoneReplayIdentity(params) {
+	const messageId = params.source.messageId?.trim();
+	if (messageId) return `message:${messageId}`;
+	return [
+		"fallback",
+		params.source.sessionKey?.trim() ?? "",
+		String(params.at),
+		normalizeExactAssertionText(params.newAssertion)
+	].join("\0");
+}
+function closeProfileMetadata(row, supersededBy, at) {
+	const metadata = parseInsightMetadata(row.metadata, row);
+	const invalidatedAt = Math.max(at, metadata.valid_from ?? at);
+	return stringifyInsightMetadata(buildInsightMetadata(row, {
+		...metadata,
+		invalidated_at: invalidatedAt,
+		superseded_by: supersededBy
+	}));
+}
+const retireByNameWorkItemSchema = z.object({
+	positions: z.array(z.string()).min(1),
+	eventTime: z.number(),
+	triggeringEventIdentity: z.string(),
+	triggeringSessionIdentity: z.string().optional(),
+	excludedRowIds: z.array(z.string()),
+	lifecycleClassification: z.object({
+		incomingAssertion: z.string(),
+		liveSiblingSectionNames: z.array(z.string()),
+		attempts: z.number().int().nonnegative().optional(),
+		lastFailure: z.enum(["malformed-answer", "transport"]).optional()
+	}).strict().optional()
+}).strict();
+const retireByNamePendingSchema = z.object({ workItems: z.array(retireByNameWorkItemSchema).min(1) }).strict();
+/**
+* Collect the pending queues of every row this write is folding into one. A conflict scan can
+* close a live row that carries unfinished retirement work, and only the current row is ever
+* resumed, so anything left behind on the closed row is unreachable for good.
+*/
+function mergeRetireByNamePending(sources) {
+	const workItems = sources.flatMap((source) => source?.workItems ?? []);
+	return workItems.length === 0 ? void 0 : { workItems };
+}
+function appendRetireByNameWork(pending, positions, params, excludedRowIds, fallbackTriggeringEventIdentity, lifecycleClassification) {
+	const workItems = pending?.workItems ?? [];
+	const triggeringEventIdentity = params.source.messageId ?? params.source.sessionKey ?? fallbackTriggeringEventIdentity;
+	const carriedPositions = new Set(workItems.filter((item) => item.eventTime === params.at && item.triggeringEventIdentity === triggeringEventIdentity && item.triggeringSessionIdentity === params.source.sessionKey).flatMap((item) => item.positions.map(normalizeExactAssertionText)));
+	const newPositions = [...new Set(positions)].filter((position) => !carriedPositions.has(normalizeExactAssertionText(position)));
+	if (newPositions.length === 0) return workItems.length === 0 ? void 0 : { workItems: capRetireByNameWorkItems(workItems, params) };
+	return { workItems: capRetireByNameWorkItems([...workItems, {
+		positions: newPositions,
+		eventTime: params.at,
+		triggeringEventIdentity,
+		...params.source.sessionKey ? { triggeringSessionIdentity: params.source.sessionKey } : {},
+		excludedRowIds,
+		...lifecycleClassification ? { lifecycleClassification } : {}
+	}], params) };
+}
+/**
+* The last stop against an unbounded marker. Only an ANSWER exhausts the per-item bound, so a
+* route that is ON and only ever times out defers each item forever while new ones keep arriving
+* per event. Past the cap the OLDEST item goes, and it goes LOUDLY: a permanently broken route
+* then costs one warning per event instead of a metadata blob that grows until writes crawl.
+* 16 is the recheck cap, and the largest general rewrite observed on the 2026-09-01 store retired
+* 9 clauses, so an ordinary day never reaches it. Owner ruling via CTS, 2026-09-02.
+*/
+function capRetireByNameWorkItems(workItems, params) {
+	if (workItems.length <= RETIRE_BY_NAME_MAX_PENDING_WORK_ITEMS) return [...workItems];
+	const dropped = workItems.slice(0, workItems.length - RETIRE_BY_NAME_MAX_PENDING_WORK_ITEMS);
+	for (const item of dropped) log.warn("retire-by-name work dropped at the pending cap", {
+		scope: params.scope,
+		section: params.sectionName,
+		factKey: profileFactKey(params.sectionName),
+		position: item.positions[0],
+		positions: item.positions.length,
+		failure: item.lifecycleClassification?.lastFailure,
+		attempts: item.lifecycleClassification?.attempts
+	}, {
+		event_name: "sno_station_mem.profile-section-writer.retire.by.name.work.dropped.at.the.pending.cap",
+		file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+		function: "capRetireByNameWorkItems",
+		site_id: "profile-section-writer.capRetireByNameWorkItems.3c47653418"
+	});
+	return workItems.slice(dropped.length);
+}
+async function writeProfileRow(args) {
+	const plan = await planProfileConflicts(args.params, args.content, [args.existing?.id].filter((id) => id !== void 0));
+	if (plan.blockedBy) {
+		const safetyNet = await writeEpisodicSafetyNet(args.params, "superseded-by-existing");
+		const blockingSection = parseInsightMetadata(plan.blockedBy.metadata, plan.blockedBy).section_name;
+		log.warn("profile conflict blocked candidate routed to episodic", {
+			candidateRowId: safetyNet.rowId,
+			blockingRowId: plan.blockedBy.id,
+			incomingSection: args.params.sectionName,
+			blockingSection,
+			verdict: "replacement"
+		}, {
+			event_name: "sno_station_mem.profile-section-writer.profile.conflict.blocked.candidate.routed.to.episodic",
+			file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+			function: "writeProfileRow",
+			site_id: "profile-section-writer.writeProfileRow.3e3e26a255"
+		});
+		return {
+			outcome: safetyNet.replayed ? "no-op" : "appended",
+			rowId: safetyNet.rowId
+		};
+	}
+	const closeRows = uniqueRows([args.existing, ...plan.closes].filter((row) => row !== void 0));
+	const retainedClauses = new Set(splitExactClauses(args.content).map(normalizeExactAssertionText));
+	const conflictRetiredPositions = plan.closes.flatMap((row) => {
+		return splitExactClauses(parseInsightMetadata(row.metadata, row).l2_content ?? row.text).filter((clause) => !retainedClauses.has(normalizeExactAssertionText(clause)));
+	});
+	const conflictLifecycleRetirement = conflictRetiredPositions.length === 0 ? {
+		kind: "classified",
+		positions: []
+	} : await lifecycleRetireByNamePositions(args.params, await listLiveSpecificSiblingSections(args.params), conflictRetiredPositions);
+	const judgmentHasNoModel = profileMergeCallHasNoModel(args.params, "P6");
+	const lifecycleHasNoModel = profileMergeCallHasNoModel(args.params, "P2");
+	const modelOnlyPositions = judgmentHasNoModel ? [] : [...args.retiredPositions ?? [], ...conflictLifecycleRetirement.kind === "classified" ? conflictLifecycleRetirement.positions : []];
+	let pending = mergeRetireByNamePending([...args.existing ? [args.existing] : [], ...closeRows].filter((row, index, rows) => rows.findIndex((other) => other.id === row.id) === index).map(readRetireByNamePending));
+	pending = appendRetireByNameWork(pending, modelOnlyPositions, args.params, closeRows.map((row) => row.id), "profile-update");
+	const deferredRetirements = (judgmentHasNoModel || lifecycleHasNoModel ? [] : [args.deferredLifecycleRetirement, conflictLifecycleRetirement.kind === "deferred" ? conflictLifecycleRetirement.work : void 0]).filter((work) => work !== void 0);
+	for (const deferred of deferredRetirements) pending = appendRetireByNameWork(pending, deferred.positions, args.params, closeRows.map((row) => row.id), "profile-update", deferred.context);
+	const createInput = pending === void 0 ? args.input : {
+		...args.input,
+		metadata: addRetireByNamePending(args.input.metadata, pending)
+	};
+	const created = await args.params.store.supersede({
+		create: createInput,
+		closes: closeRows.map((row) => ({
+			id: row.id,
+			buildMetadata: (createdId) => closeProfileMetadata(row, createdId, args.params.at)
+		})),
+		activeFactGuard: {
+			factKey: profileFactKey(args.params.sectionName),
+			expectedId: args.existing?.id ?? null
+		},
+		reviveInvalidatedExisting: true,
+		...closeRows.length === 0 ? {} : { profileRecovery: {
+			mutationAttemptId: currentMutationAttemptId(),
+			sectionName: args.params.sectionName,
+			removedAtMs: args.params.at
+		} }
+	});
+	if (pending) await completeRetireByNamePending(created, args.params, pending);
+	return {
+		outcome: args.outcome,
+		rowId: created.id
+	};
+}
+function addRetireByNamePending(metadata, pending) {
+	const parsed = JSON.parse(metadata ?? "{}");
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("profile-section-writer: profile metadata must be an object");
+	return JSON.stringify({
+		...parsed,
+		retire_by_name_pending: pending
+	});
+}
+function readRetireByNamePending(entry) {
+	const value = parseInsightMetadata(entry.metadata, entry).retire_by_name_pending;
+	const parsed = retireByNamePendingSchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+}
+function classifiedRetireByNameWorkItem(workItem, positions) {
+	return {
+		positions,
+		eventTime: workItem.eventTime,
+		triggeringEventIdentity: workItem.triggeringEventIdentity,
+		...workItem.triggeringSessionIdentity ? { triggeringSessionIdentity: workItem.triggeringSessionIdentity } : {},
+		excludedRowIds: workItem.excludedRowIds
+	};
+}
+async function completeRetireByNamePending(current, params, pending) {
+	if (profileMergeCallHasNoModel(params, "P6")) return;
+	const lifecycleHasNoModel = profileMergeCallHasNoModel(params, "P2");
+	const judgmentBudget = params.retireByNameBudget ?? createRetireByNameRunBudget(params.timeoutMs);
+	const deadlineMs = judgmentBudget.deadlineMs;
+	let remainingWorkItems = [];
+	workLoop: for (let workIndex = 0; workIndex < pending.workItems.length; workIndex += 1) {
+		const workItem = pending.workItems[workIndex];
+		if (!workItem) continue;
+		let activeWorkItem = workItem;
+		if (workItem.lifecycleClassification) {
+			if (lifecycleHasNoModel) {
+				remainingWorkItems.push(workItem);
+				continue;
+			}
+			if (Date.now() >= deadlineMs) {
+				remainingWorkItems = [...remainingWorkItems, ...pending.workItems.slice(workIndex)];
+				break;
+			}
+			const remainingMs = Math.max(1, deadlineMs - Date.now());
+			const classification = await lifecycleRetireByNamePositions({
+				...params,
+				timeoutMs: Math.min(params.timeoutMs ?? remainingMs, remainingMs)
+			}, workItem.lifecycleClassification.liveSiblingSectionNames, workItem.positions, workItem.lifecycleClassification.incomingAssertion, workItem.lifecycleClassification.attempts ?? 0);
+			if (classification.kind === "deferred") {
+				remainingWorkItems = [
+					...remainingWorkItems,
+					{
+						...workItem,
+						lifecycleClassification: classification.work.context
+					},
+					...pending.workItems.slice(workIndex + 1)
+				];
+				break;
+			}
+			if (classification.positions.length === 0) continue;
+			activeWorkItem = classifiedRetireByNameWorkItem(workItem, classification.positions);
+		}
+		for (let positionIndex = 0; positionIndex < activeWorkItem.positions.length; positionIndex += 1) {
+			const retiredPosition = activeWorkItem.positions[positionIndex];
+			if (retiredPosition === void 0 || judgmentBudget.remaining <= 0 || Date.now() >= deadlineMs) {
+				remainingWorkItems = [
+					...remainingWorkItems,
+					{
+						...activeWorkItem,
+						positions: activeWorkItem.positions.slice(positionIndex)
+					},
+					...pending.workItems.slice(workIndex + 1)
+				];
+				break workLoop;
+			}
+			const judgedCandidateIds = /* @__PURE__ */ new Set();
+			if (!(await retireRowsByName({
+				store: params.store,
+				llm: params.llm,
+				routing: params.routing,
+				scope: params.scope,
+				retiredPosition,
+				currentPositionId: current.id,
+				triggeringEventIdentity: activeWorkItem.triggeringEventIdentity,
+				...activeWorkItem.triggeringSessionIdentity ? { triggeringSessionIdentity: activeWorkItem.triggeringSessionIdentity } : {},
+				eventTime: activeWorkItem.eventTime,
+				excludedRowIds: activeWorkItem.excludedRowIds,
+				...params.timeoutMs === void 0 ? {} : { timeoutMs: params.timeoutMs },
+				...params.signal === void 0 ? {} : { signal: params.signal },
+				judgmentBudget,
+				judgedCandidateIds,
+				deadlineMs
+			})).completed) {
+				const laterPositions = activeWorkItem.positions.slice(positionIndex + 1);
+				remainingWorkItems = [
+					...remainingWorkItems,
+					{
+						...activeWorkItem,
+						positions: [retiredPosition],
+						excludedRowIds: [.../* @__PURE__ */ new Set([...activeWorkItem.excludedRowIds, ...judgedCandidateIds])]
+					},
+					...laterPositions.length === 0 ? [] : [{
+						...activeWorkItem,
+						positions: laterPositions
+					}],
+					...pending.workItems.slice(workIndex + 1)
+				];
+				break workLoop;
+			}
+		}
+	}
+	await writeRetireByNamePending(current, params.store, remainingWorkItems.length === 0 ? void 0 : { workItems: remainingWorkItems });
+}
+async function writeRetireByNamePending(current, store, pending) {
+	let latest = current;
+	for (let attempt = 0; attempt < CLEAR_RETIRE_BY_NAME_PENDING_ATTEMPTS; attempt += 1) {
+		const parsed = JSON.parse(latest.metadata);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("profile-section-writer: profile metadata must be an object");
+		const next = { ...parsed };
+		if (pending) next["retire_by_name_pending"] = pending;
+		else delete next["retire_by_name_pending"];
+		try {
+			if (!await store.update(latest.id, {
+				writerAuthority: "profile-writer",
+				metadata: JSON.stringify(next),
+				expectedContentHash: latest.contentHash,
+				expectedMetadata: latest.metadata
+			})) throw new Error("profile-section-writer: pending profile row is missing");
+			return;
+		} catch (error) {
+			if (!(error instanceof StorageError) || error.message !== `Cannot update changed memory '${latest.id}'`) throw error;
+		}
+		const refreshed = store.getById(latest.id);
+		if (!refreshed) throw new Error("profile-section-writer: pending profile row is missing");
+		if (!readRetireByNamePending(refreshed)) return;
+		latest = refreshed;
+	}
+	throw new Error("profile-section-writer: pending profile row kept changing");
+}
+/**
+* Move a live profile row's `valid_from` forward to a repeat of the assertion it already
+* holds, so the out-of-order guard measures staleness from the LAST confirmation.
+*
+* Only forward, and only for a row that already carries the field: writing one where there
+* was none would arm a guard that has never been armed for that row.
+*
+* Returns the row as this call leaves it, so the caller's next step reads the metadata that is
+* now stored instead of the snapshot it came in with.
+*/
+async function advanceProfileConfirmation(current, currentValidFrom, params) {
+	if (typeof currentValidFrom !== "number" || params.at <= currentValidFrom) return current;
+	let latest = current;
+	for (let attempt = 0; attempt < ADVANCE_PROFILE_CONFIRMATION_ATTEMPTS; attempt += 1) {
+		const parsed = JSON.parse(latest.metadata);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("profile-section-writer: profile metadata must be an object");
+		const next = {
+			...parsed,
+			valid_from: params.at
+		};
+		try {
+			const updated = await params.store.update(latest.id, {
+				writerAuthority: "profile-writer",
+				metadata: JSON.stringify(next),
+				expectedContentHash: latest.contentHash,
+				expectedMetadata: latest.metadata
+			});
+			if (!updated) throw new Error("profile-section-writer: confirmed profile row is missing");
+			return updated;
+		} catch (error) {
+			if (!(error instanceof StorageError) || error.message !== `Cannot update changed memory '${latest.id}'`) throw error;
+		}
+		const refreshed = params.store.getById(latest.id);
+		if (!refreshed) throw new Error("profile-section-writer: confirmed profile row is missing");
+		const refreshedMetadata = parseInsightMetadata(refreshed.metadata, refreshed);
+		if (refreshedMetadata.invalidated_at !== void 0) return refreshed;
+		const refreshedValidFrom = refreshedMetadata.valid_from;
+		if (typeof refreshedValidFrom === "number" && refreshedValidFrom >= params.at) return refreshed;
+		if (refreshed.contentHash !== latest.contentHash) return refreshed;
+		latest = refreshed;
+	}
+	throw new Error("profile-section-writer: confirmed profile row kept changing");
+}
+async function resumeRetireByNamePending(current, params) {
+	const pending = readRetireByNamePending(current);
+	if (pending) await completeRetireByNamePending(current, params, pending);
+}
+async function listLiveSpecificSiblingSections(params) {
+	return (await listLiveSpecificSiblings(params)).map((sibling) => sibling.name);
+}
+async function listLiveSpecificSiblings(params) {
+	if (params.sectionName !== "preferences.general") return [];
+	const sections = /* @__PURE__ */ new Map();
+	for (let offset = 0;; offset += MAX_LIST_LIMIT) {
+		const page = await params.store.list({
+			projectId: params.scope,
+			category: "profile",
+			limit: MAX_LIST_LIMIT,
+			offset
+		});
+		for (const row of page) {
+			const metadata = parseInsightMetadata(row.metadata, row);
+			const section = metadata.section_name;
+			const content = metadata.l2_content ?? row.text;
+			if (metadata.invalidated_at !== void 0 || typeof section !== "string" || normalizeExactAssertionText(content) === normalizeExactAssertionText(retiredProfileSectionMarker(section))) continue;
+			if (section.startsWith("preferences.") && section !== "preferences.general") sections.set(section, content);
+		}
+		if (page.length < 2048) break;
+	}
+	return [...sections].sort(([left], [right]) => left.localeCompare(right)).map(([name, content]) => ({
+		name,
+		content
+	}));
+}
+/**
+* True when a profile-merge call has no model behind it: no client at all, or a route that
+* resolves OFF. Both must be decided BEFORE the call, because an OFF route returns null rather
+* than throwing, which reads downstream as a malformed answer and defers the work forever. That
+* is what the 2026-09-01 run did all night: the lifecycle label was unregistered, so every
+* general-section classification deferred and retire-by-name never had a position to judge.
+*/
+function profileMergeCallHasNoModel(params, callId) {
+	if (!params.llm) return true;
+	if (!params.routing) return false;
+	return "off" in resolveLlmRoute({
+		callId,
+		config: params.routing
+	});
+}
+/**
+* True when conflict adjudication resolves OFF. This is Local First (or an
+* invalid/retired route); live agent and Sno routes adjudicate inline.
+*/
+function conflictAdjudicationRoutedOff(params) {
+	if (!params.routing) return false;
+	return "off" in resolveLlmRoute({
+		callId: "P1",
+		config: params.routing
+	});
+}
+async function planProfileConflicts(params, content, excludedIds) {
+	if (conflictAdjudicationRoutedOff(params)) {
+		log.debug("profile conflict scan routed off; conflicting rows both persist", { mode: params.routing?.mode }, {
+			event_name: "sno_station_mem.profile-section-writer.profile.conflict.scan.routed.off.conflicting.rows.both.persist",
+			file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+			function: "planProfileConflicts",
+			site_id: "profile-section-writer.planProfileConflicts.e5bcea94ce"
+		});
+		return { closes: [] };
+	}
+	try {
+		const vector = await params.store.embedder.embed(content);
+		const matches = await params.store.searchSemantic(vector, {
+			projectIdFilter: [params.scope],
+			category: "profile",
+			excludeInvalidatedBefore: Number.MAX_SAFE_INTEGER,
+			limit: PROFILE_CONFLICT_TOP_K + excludedIds.length
+		});
+		const excluded = new Set(excludedIds);
+		const candidates = matches.map((match) => match.entry).filter((entry) => !excluded.has(entry.id)).slice(0, PROFILE_CONFLICT_TOP_K);
+		const closes = [];
+		for (const existing of candidates) {
+			let existingMetadata;
+			try {
+				existingMetadata = parseInsightMetadata(existing.metadata, existing);
+			} catch (error) {
+				logProfileConflictFenceRejection(params, existing, {
+					existingSection: null,
+					existingFactKey: null,
+					existingSessionKey: null,
+					reason: "metadata-invalid",
+					error
+				});
+				continue;
+			}
+			const existingSection = existingMetadata.kind === "profile" ? existingMetadata.section_name : null;
+			const existingContent = existingMetadata.l2_content ?? existing.text;
+			if (typeof existingSection === "string" && normalizeExactAssertionText(existingContent) === normalizeExactAssertionText(retiredProfileSectionMarker(existingSection))) continue;
+			if (existingSection !== params.sectionName) {
+				logProfileConflictFenceRejection(params, existing, {
+					existingSection,
+					existingFactKey: existingMetadata.fact_key ?? null,
+					existingSessionKey: existingMetadata.source_session ?? null,
+					reason: "section-mismatch"
+				});
+				continue;
+			}
+			const pair = orderAdapterAPair(adapterAViewFromEntry(existing), prospectiveProfileView(content, params.at));
+			const verdict = await adjudicateSafely(pair, params, {
+				purpose: "cross-row-profile-conflict",
+				existingId: existing.id
+			});
+			if (verdict === "uncertain") {
+				log.warn("profile conflict adjudication uncertain; keeping both rows", {
+					memory_id: existing.id,
+					candidate_size: content.length
+				}, {
+					event_name: "sno_station_mem.profile-section-writer.profile.conflict.adjudication.uncertain.keeping.both.rows",
+					file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+					function: "planProfileConflicts",
+					site_id: "profile-section-writer.planProfileConflicts.97b6a2e824"
+				});
+				continue;
+			}
+			if (verdict !== "replacement") continue;
+			if (pair.candidateRole === "older") return {
+				blockedBy: existing,
+				closes: []
+			};
+			closes.push(existing);
+		}
+		return { closes };
+	} catch (error) {
+		rethrowCallerCancellation(error);
+		log.error("profile conflict scan failed; proceeding without adjudication", {
+			error,
+			candidate_size: content.length
+		}, {
+			event_name: "sno_station_mem.profile-section-writer.profile.conflict.scan.failed.proceeding.without.adjudication",
+			file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+			function: "planProfileConflicts",
+			site_id: "profile-section-writer.planProfileConflicts.b4962bc7f0"
+		});
+		return { closes: [] };
+	}
+}
+function logProfileConflictFenceRejection(params, existing, details) {
+	log.warn("profile conflict candidate rejected by section fence", {
+		incomingSection: params.sectionName,
+		existingSection: details.existingSection,
+		row_id: existing.id,
+		incomingFactKey: profileFactKey(params.sectionName),
+		existingFactKey: details.existingFactKey,
+		incomingMessageId: params.source.messageId ?? null,
+		incoming_session_reference: privateLogReference(params.source.sessionKey),
+		existing_session_reference: privateLogReference(details.existingSessionKey ?? void 0),
+		reason: details.reason,
+		...details.error ? { error: details.error } : {}
+	}, {
+		event_name: "sno_station_mem.profile-section-writer.profile.conflict.candidate.rejected.by.section.fence",
+		file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+		function: "logProfileConflictFenceRejection",
+		site_id: "profile-section-writer.logProfileConflictFenceRejection.b0669b40b3"
+	});
+}
+async function adjudicateSafely(pair, params, context) {
+	try {
+		const route = params.routing ? resolveLlmRoute({
+			callId: "P1",
+			config: params.routing
+		}) : void 0;
+		if (!params.llm) return "uncertain";
+		const prompt = route && !("off" in route) && route.tier === "snoRemMem" ? renderAdapterAPrompt(pair.older, pair.newer) : renderAdapterAChatPrompt(pair);
+		const response = await params.llm.completeText({
+			prompt,
+			hostPrompt: renderAdapterAChatPrompt(pair),
+			callId: "P1",
+			...params.timeoutMs ? { timeoutMs: params.timeoutMs } : {},
+			...params.signal ? { signal: params.signal } : {}
+		});
+		return response ? parseAdapterAChatVerdict(response) : "uncertain";
+	} catch (error) {
+		rethrowCallerCancellation(error);
+		log.error("Conflict adjudicator unavailable; keeping both rows", {
+			...context,
+			error
+		}, {
+			event_name: "sno_station_mem.profile-section-writer.conflict.adjudicator.unavailable.keeping.both.rows",
+			file: "packages/memory/src/engine/extraction/profile-section-writer.ts",
+			function: "adjudicateSafely",
+			site_id: "profile-section-writer.adjudicateSafely.d3f7ab0ac5"
+		});
+		return "uncertain";
+	}
+}
+function uniqueRows(rows) {
+	return [...new Map(rows.map((row) => [row.id, row])).values()];
+}
+function stableShortHash(value) {
+	return createHash("sha256").update(value).digest("hex").slice(0, 20);
+}
+function fallbackProfileMerge(existingText, newAssertion) {
+	return combineUniqueLines(existingText, newAssertion);
+}
+function splitPreferenceClauses(text) {
+	return text.split(/\n+|(?<=[.!?])\s+/).map((item) => item.trim()).filter(Boolean);
+}
+function combineUniqueLines(...texts) {
+	const seen = /* @__PURE__ */ new Set();
+	const lines = [];
+	for (const text of texts) for (const line of splitPreferenceClauses(text)) {
+		const key = normalizeExactAssertionText(line);
+		if (!key || seen.has(key)) continue;
+		seen.add(key);
+		lines.push(line);
+	}
+	return lines.join("\n");
+}
+/**
+* Whether the section already states everything the incoming assertion states,
+* measured with the same clause identity the deterministic merge uses: if
+* combining them adds no clause, there is nothing to write. This is the only
+* condition under which skipping the write loses no memory.
+*/
+function sectionAlreadyCovers(existingText, newAssertion) {
+	return combineUniqueLines(existingText, newAssertion) === combineUniqueLines(existingText);
+}
+function normalizeExactAssertionText(text) {
+	return text.trim().replace(/\s+/g, " ");
+}
+function firstSentence(text) {
+	return text.split(/(?<=[.!?])\s+/)[0]?.trim() || text;
+}
+//#endregion
+export { prepareDeterministicTaskLifecycleWrite as i, createRetireByNameRunBudget as n, runProfileSectionUpdate as r, PROFILE_IDENTITY_SECTION as t };