@snoai/memory 0.0.0-stage → 1.0.1

package/dist/internal/engine/rem/index.js

@@ -0,0 +1,2551 @@
+import { REM_ADDITIONAL_TRANSITION_PATTERN_SHA256, REM_AMBIGUOUS_PATTERN_SHA256, REM_CURRENT_PROGRESSIVE_PATTERN_SHA256, REM_HISTORICAL_FACT_PATTERN_SHA256, REM_PURE_NEGATION_PATTERN_SHA256, REM_TRANSITION_GRAMMAR_SHA256, classifyRemRow, runRestateClassifierEntry, runVerdictClassifierEntry } from "./classifier.js";
+import { REM_BUILT_OPERATION_TYPES, REM_JOB_STATES, REM_OPERATION_TYPES, REM_ROW_STATES, assertJobIdentity, parseRemOperationType } from "./types.js";
+import { z } from "zod";
+import { createLogger } from "@snoai/utils/logger";
+import path, { dirname, extname, resolve } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, lstatSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+//#region src/engine/rem/adapter-a-conflict-adjudicator.ts
+/** @file adapter-a-conflict-adjudicator.ts
+* @purpose Renders and parses a fail-safe conflict verdict for an ordered memory pair.
+* @boundary Accepts package-level memory views only; callers adapt their storage records.
+*/
+function adapterAViewFromRecord(record) {
+	if (record.kind !== "profile" && record.kind !== "episodic" && record.kind !== "state") throw new Error(`Adapter A does not accept ${record.kind} memories`);
+	return {
+		text: record.text,
+		...record.subject !== void 0 ? { subject: record.subject } : {},
+		kind: record.kind,
+		validFrom: isoUtcSeconds(record.validFrom),
+		assertedAt: isoUtcSeconds(record.assertedAt),
+		contentHash: record.contentHash
+	};
+}
+function prospectiveProfileView(text, at) {
+	return {
+		text: text.trim(),
+		kind: "profile",
+		validFrom: isoUtcSeconds(at),
+		assertedAt: isoUtcSeconds(at),
+		contentHash: createHash("sha256").update(text.trim()).digest("hex")
+	};
+}
+function orderAdapterAPair(existing, candidate) {
+	if (compareViews(existing, candidate) <= 0) return {
+		older: existing,
+		newer: candidate,
+		candidateRole: "newer"
+	};
+	return {
+		older: candidate,
+		newer: existing,
+		candidateRole: "older"
+	};
+}
+function renderAdapterAPrompt(older, newer) {
+	return [
+		"Judge the relationship of the newer memory to the older memory.",
+		"",
+		"Older:",
+		`kind: ${older.kind}`,
+		`validFrom: ${older.validFrom}`,
+		`assertedAt: ${older.assertedAt}`,
+		`text: ${older.text}`,
+		"",
+		"Newer:",
+		`kind: ${newer.kind}`,
+		`validFrom: ${newer.validFrom}`,
+		`assertedAt: ${newer.assertedAt}`,
+		`text: ${newer.text}`,
+		"",
+		"Verdict:"
+	].join("\n");
+}
+function renderAdapterAChatPrompt(pair) {
+	return [
+		"Adjudicate whether the newer memory replaces the older memory.",
+		"Return either one JSON object, {\"verdict\":\"replacement|keep|uncertain\"}, or exactly one verdict token.",
+		"replacement: the newer memory directly changes or corrects the same fact, state, or preference, so the older memory is no longer true.",
+		"keep: the older memory remains valid, is historical, concerns a different fact, coexists with the newer memory, or is only refined without being erased.",
+		"uncertain: the relationship is unclear or the evidence is insufficient. Prefer uncertain over guessing.",
+		"Apply the same semantics regardless of memory kind.",
+		`Older memory:\n${JSON.stringify(pair.older)}`,
+		`Newer memory:\n${JSON.stringify(pair.newer)}`
+	].join("\n\n");
+}
+function parseAdapterAChatVerdict(raw) {
+	const trimmed = raw.trim();
+	if (trimmed === "replacement" || trimmed === "keep" || trimmed === "uncertain") return trimmed;
+	const json = extractJsonFromResponse(trimmed);
+	if (!json) return "uncertain";
+	try {
+		const parsed = JSON.parse(json);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return "uncertain";
+		const verdict = parsed["verdict"];
+		return verdict === "replacement" || verdict === "keep" || verdict === "uncertain" ? verdict : "uncertain";
+	} catch {
+		return "uncertain";
+	}
+}
+/**
+* Whether a reply is a verdict at all: a bare verdict token, or a JSON object carrying one, read
+* the way `parseAdapterAChatVerdict` reads it (a fenced object counts).
+*/
+function isAdapterAVerdictReply(value) {
+	const trimmed = value.trim();
+	if (trimmed === "replacement" || trimmed === "keep" || trimmed === "uncertain") return true;
+	const json = extractJsonFromResponse(trimmed);
+	if (json === null) return false;
+	try {
+		const parsed = JSON.parse(json);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return false;
+		const verdict = parsed["verdict"];
+		return verdict === "replacement" || verdict === "keep" || verdict === "uncertain";
+	} catch {
+		return false;
+	}
+}
+function compareViews(a, b) {
+	const validFrom = Date.parse(a.validFrom) - Date.parse(b.validFrom);
+	if (validFrom !== 0) return validFrom;
+	return Date.parse(a.assertedAt) - Date.parse(b.assertedAt);
+}
+function isoUtcSeconds(value) {
+	if (!Number.isFinite(value)) throw new Error("Adapter A timestamp must be finite");
+	return new Date(value).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function extractJsonFromResponse(text) {
+	const fenceMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
+	if (fenceMatch) return (fenceMatch[1] ?? "").trim();
+	const firstBrace = text.indexOf("{");
+	if (firstBrace === -1) return null;
+	let depth = 0;
+	let lastBrace = -1;
+	let inString = false;
+	let escaped = false;
+	for (let i = firstBrace; i < text.length; i++) {
+		const ch = text[i];
+		if (ch === void 0) continue;
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (ch === "\\") {
+			escaped = inString;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = !inString;
+			continue;
+		}
+		if (inString) continue;
+		if (ch === "{") depth++;
+		else if (ch === "}") {
+			depth--;
+			if (depth === 0) {
+				lastBrace = i;
+				break;
+			}
+		}
+	}
+	if (lastBrace === -1) return null;
+	return text.substring(firstBrace, lastBrace + 1);
+}
+//#endregion
+//#region src/engine/rem/operational-config.ts
+const sha256Schema = z.string().regex(/^[0-9a-f]{64}$/u);
+const positiveSafeInteger = z.number().int().safe().positive("value must be positive and non-zero");
+const nullablePercentage = z.number().min(0).max(1).nullable();
+const remOperationalConfigurationSchema = z.object({
+	profileId: z.string().min(1),
+	operations: z.object({
+		"rem-update": z.boolean(),
+		"rem-replace": z.boolean(),
+		"rem-distill": z.boolean(),
+		"rem-retire": z.boolean()
+	}).strict(),
+	budgets: z.object({ maxPairs: positiveSafeInteger }).strict(),
+	retrieval: z.object({
+		neighborLimit: positiveSafeInteger,
+		similarityThreshold: z.number().min(0).max(1)
+	}).strict(),
+	coverage: z.object({ accuracyFloor: nullablePercentage }).strict(),
+	retries: z.object({ liveContentionRetries: z.number().int().safe().nonnegative() }).strict(),
+	facetPolicy: z.object({
+		aggregationGrammar: z.string().min(1),
+		historyGrammar: z.string().min(1)
+	}).strict(),
+	calibration: z.object({
+		minimumPublishableScoreEffect: z.number().nonnegative().nullable(),
+		minimumTargetCount: positiveSafeInteger.nullable(),
+		minimumTargetPercent: nullablePercentage
+	}).strict(),
+	enableGateDigests: z.object({
+		"p5-production-config": sha256Schema,
+		"p6-monthly-non-regression": sha256Schema,
+		"p7-detector-gate-verdict": sha256Schema,
+		"population-routing": sha256Schema,
+		"rem-update": sha256Schema,
+		"rem-replace": sha256Schema,
+		"p5-immutable-profile": sha256Schema.optional()
+	}).strict()
+}).strict();
+function parseRemOperationalConfiguration(input) {
+	return remOperationalConfigurationSchema.parse(input);
+}
+function canonicalizeRemConfiguration(input) {
+	const { enableGateDigests: _excluded, ...operational } = parseRemOperationalConfiguration(input);
+	return canonicalJson(operational);
+}
+function deriveRemConfigurationSha256(input) {
+	return createHash("sha256").update(canonicalizeRemConfiguration(input), "utf8").digest("hex");
+}
+function validateRemEnableGateDigestKeys(input) {
+	if (parseRemOperationalConfiguration(input.configuration).enableGateDigests["p5-immutable-profile"] !== void 0 !== (input.p5ReadbackSource === "immutable-profile")) return {
+		decision: "refuse",
+		reasonCode: "enableGateDigests.p5-immutable-profile"
+	};
+	return {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function requireRemCoverageAccuracyFloor(input) {
+	return parseRemOperationalConfiguration(input.configuration).coverage.accuracyFloor === null ? {
+		decision: "refuse",
+		reasonCode: "coverage.accuracyFloor"
+	} : {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function requireRemOwnerDecisions(input) {
+	const configuration = parseRemOperationalConfiguration(input.configuration);
+	if (configuration.coverage.accuracyFloor === null) return {
+		decision: "refuse",
+		reasonCode: "coverage.accuracyFloor"
+	};
+	for (const key of [
+		"minimumPublishableScoreEffect",
+		"minimumTargetCount",
+		"minimumTargetPercent"
+	]) if (configuration.calibration[key] === null) return {
+		decision: "refuse",
+		reasonCode: `calibration.${key}`
+	};
+	return {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function declareRemCalibrationThreshold(input) {
+	const configuration = parseRemOperationalConfiguration(input.configuration);
+	for (const key of [
+		"minimumPublishableScoreEffect",
+		"minimumTargetCount",
+		"minimumTargetPercent"
+	]) if (configuration.calibration[key] === null) return {
+		decision: "refuse",
+		reasonCode: `calibration.${key}`
+	};
+	if (input.derivationStatement?.trim().length === 0 || input.derivationStatement === void 0) return {
+		decision: "refuse",
+		reasonCode: "calibration.derivationStatement"
+	};
+	return {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function validateRemGrammarChange(input) {
+	const before = parseRemOperationalConfiguration(input.before);
+	const after = parseRemOperationalConfiguration(input.after);
+	if (deriveRemConfigurationSha256(before) !== input.beforeConfigurationSha256 || deriveRemConfigurationSha256(after) !== input.afterConfigurationSha256 || !sha256Schema.safeParse(input.beforeCorpusSha256).success) return {
+		decision: "refuse",
+		reasonCode: "configuration_digest_mismatch"
+	};
+	if (!(before.facetPolicy.aggregationGrammar !== after.facetPolicy.aggregationGrammar || before.facetPolicy.historyGrammar !== after.facetPolicy.historyGrammar)) return {
+		decision: "allow",
+		reasonCode: null
+	};
+	const artifact = input.abArtifact;
+	if (artifact === void 0 || artifact.beforeConfigurationSha256 !== input.beforeConfigurationSha256 || artifact.afterConfigurationSha256 !== input.afterConfigurationSha256 || artifact.corpusSha256 !== input.beforeCorpusSha256 || artifact.metricDefinitions.length === 0 || artifact.result !== "pass") return {
+		decision: "refuse",
+		reasonCode: "grammar_ab_missing_or_failed"
+	};
+	return {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function canonicalJson(value) {
+	if (value === null || typeof value === "boolean" || typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error("canonical JSON does not accept non-finite numbers");
+		return JSON.stringify(value);
+	}
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (typeof value !== "object") throw new Error("canonical JSON accepts JSON values only");
+	const record = value;
+	return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+}
+//#endregion
+//#region src/engine/rem/census.ts
+function sha256(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function validateRemProspectiveIdentity(input) {
+	if (input.writeIdentitySha256.includes(":")) return {
+		decision: "refuse",
+		reasonCode: "scan_generation_identity"
+	};
+	if (!isSha256(input.writeIdentitySha256) || !isSha256(input.candidateSetSha256)) return {
+		decision: "refuse",
+		reasonCode: "identity_invalid"
+	};
+	return {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function deriveRemWriteIdentity(input) {
+	return sha256(JSON.stringify([
+		input.rowId,
+		input.text,
+		input.contentHash,
+		input.timestamp
+	]));
+}
+function deriveRemReplayArtifactIdentity(input) {
+	const corpusSha256 = sha256(readFileSync(input.corpusPath));
+	const embedderSha256 = sha256(readFileSync(input.embedderPath));
+	const toolSha256 = sha256(readFileSync(input.toolPath));
+	const configurationSha256 = sha256(canonicalizeRemConfiguration(input.configuration));
+	return {
+		corpusSha256,
+		embedderSha256,
+		toolSha256,
+		configurationSha256,
+		replayIdentitySha256: sha256(JSON.stringify([
+			corpusSha256,
+			embedderSha256,
+			toolSha256,
+			configurationSha256
+		]))
+	};
+}
+function validateRemReplayIdentityTuple(input) {
+	return Object.values(input).every(isSha256) ? {
+		decision: "allow",
+		reasonCode: null
+	} : {
+		decision: "refuse",
+		reasonCode: "replay_identity_invalid"
+	};
+}
+function classifyRemCensusLabel(input) {
+	const observations = input.observations;
+	if (input.label === "reachability") {
+		if (observations["similarityMet"] !== true) return "unknown";
+		return observations["neighborEmitted"] === true ? "reachable" : "unreachable";
+	}
+	if (input.label === "contradiction") {
+		if (observations["sameFactKey"] !== true) return "undetermined";
+		return observations["valuesConflict"] === true ? "yes" : "no";
+	}
+	if (input.label === "coverageEligibility") {
+		if (observations["retrievabilityComputed"] !== true) return "undetermined";
+		return observations["referenceSetNonEmpty"] === true && observations["retiringAtomsMatched"] === true ? "eligible" : "ineligible";
+	}
+	throw new Error(`unknown REM census label: ${input.label}`);
+}
+function classifyAllRemCensusLabels(input) {
+	return {
+		reachability: classifyRemCensusLabel({
+			label: "reachability",
+			observations: input.reachability
+		}),
+		contradiction: classifyRemCensusLabel({
+			label: "contradiction",
+			observations: input.contradiction
+		}),
+		coverageEligibility: classifyRemCensusLabel({
+			label: "coverageEligibility",
+			observations: input.coverageEligibility
+		})
+	};
+}
+function validateRemCensusOracleProvenance(input) {
+	return input.authoredBy === "product-classifier" ? {
+		decision: "refuse",
+		reasonCode: "self_authored_oracle"
+	} : {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function validateRemCensusLabelTuple(input) {
+	return [
+		"reachable",
+		"unreachable",
+		"unknown"
+	].includes(input.reachability) && [
+		"yes",
+		"no",
+		"undetermined"
+	].includes(input.contradiction) && [
+		"eligible",
+		"ineligible",
+		"undetermined"
+	].includes(input.coverageEligibility) ? {
+		decision: "allow",
+		reasonCode: null
+	} : {
+		decision: "refuse",
+		reasonCode: "label_enum_mismatch"
+	};
+}
+function readRetainedRemCensusArtifact(input) {
+	if (!existsSync(input.artifactPath)) return {
+		decision: "refuse",
+		reasonCode: "artifact_missing"
+	};
+	const bytes = readFileSync(input.artifactPath);
+	try {
+		JSON.parse(bytes.toString("utf8"));
+	} catch {
+		return {
+			decision: "refuse",
+			reasonCode: "artifact_invalid"
+		};
+	}
+	return {
+		decision: "allow",
+		reasonCode: null,
+		artifactSha256: sha256(bytes)
+	};
+}
+function produceRemCensusArtifact(input) {
+	if (input.producer !== "capture" && input.producer !== "replay") throw new Error("REM census producer must be capture or replay");
+	writeFileSync(input.outputPath, `${JSON.stringify({ route: input.producer })}\n`);
+}
+function validateRemCensusRouteCoverage(input) {
+	const routes = new Set(input.map(({ route }) => route));
+	return routes.has("capture") && routes.has("replay") ? {
+		decision: "allow",
+		reasonCode: null
+	} : {
+		decision: "refuse",
+		reasonCode: "route_coverage_incomplete"
+	};
+}
+function journalRemGenerationTransition(input) {
+	if (input.outgoingGenerationId === input.incomingGenerationId) return {
+		decision: "refuse",
+		reasonCode: "generation_identity_reused"
+	};
+	input.database.prepare(`INSERT INTO nodix_rem_generation_transitions(
+				outgoing_generation_id, incoming_generation_id, recorded_at
+			) VALUES (?, ?, ?)`).run(input.outgoingGenerationId, input.incomingGenerationId, (/* @__PURE__ */ new Date()).toISOString());
+	return {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function summarizeRemBatchEvents(input) {
+	const distribution = {};
+	let calls = 0;
+	let tokens = 0;
+	let closeCount = 0;
+	let refusalCount = 0;
+	for (const event of input.events) {
+		calls += event.calls ?? 0;
+		tokens += event.tokens ?? 0;
+		closeCount += event.close ?? 0;
+		if (event.refusal !== void 0 && event.refusal !== null) refusalCount += 1;
+		if (event.verdict !== void 0) distribution[event.verdict] = (distribution[event.verdict] ?? 0) + 1;
+	}
+	input.database.prepare(`INSERT INTO nodix_rem_batch_summaries(
+				batch_id, generation_id, calls, tokens, pairCount, closeCount,
+				refusalCount, verdict_distribution_json
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(input.batchId, input.generationId ?? null, calls, tokens, input.events.length, closeCount, refusalCount, JSON.stringify(distribution));
+}
+function recordRemObservedVerdict(input) {
+	const isVerdict = (/* @__PURE__ */ new Set([
+		"replacement",
+		"keep",
+		"merge",
+		"unrelated"
+	])).has(input.observed);
+	input.database.prepare(`INSERT INTO nodix_rem_verdict_observations(
+				pair_id, audit_kind, persisted_verdict, raw_value
+			) VALUES (?, ?, ?, ?)`).run(input.pairId, isVerdict ? "VERDICT" : "SAMPLE", isVerdict ? input.observed : null, input.observed);
+}
+function recordRemCandidateCapCounts(input) {
+	input.database.prepare(`INSERT INTO nodix_rem_batch_summaries(
+				batch_id, generation_id, pre_truncation_count, emitted_count
+			) VALUES (?, ?, ?, ?)`).run(`candidate-cap:${input.generationId}`, input.generationId, input.total, Math.min(input.total, input.cap));
+}
+function reportRemSimilarityCalibration(input) {
+	const bytes = readFileSync(input.retainedArtifactPath);
+	JSON.parse(bytes.toString("utf8"));
+	const emitted = new Set(input.emittedPairIds);
+	const targets = new Set(input.targetPairIds);
+	const emittedTargetCount = [...targets].filter((pairId) => emitted.has(pairId)).length;
+	return {
+		emittedFraction: targets.size === 0 ? 0 : emittedTargetCount / targets.size,
+		targetRanks: input.targetPairIds.map((pairId) => input.rankedPairIds.indexOf(pairId) + 1),
+		adjudicationReachability: input.targetPairIds.map((pairId) => emitted.has(pairId)),
+		modelCallBudget: input.modelCallBudget,
+		consumedArtifactSha256: sha256(bytes)
+	};
+}
+function validateRemCalibrationCrossCheck(input) {
+	return input.independent === null || input.independent === void 0 ? {
+		decision: "refuse",
+		reasonCode: "independent_count_missing"
+	} : {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function isSha256(value) {
+	return /^[0-9a-f]{64}$/u.test(value);
+}
+//#endregion
+//#region src/engine/rem/clause-splitter.ts
+/**
+* Produces the fixed, lossless clause list used by REM judgments. The text itself
+* remains the authority: clause values are exact source slices and separators are retained.
+*/
+function splitExactClauses(text) {
+	if (text.trim().length === 0) throw new Error("REM clause splitter requires non-empty text");
+	const clauses = [];
+	let cursor = 0;
+	for (const boundary of text.matchAll(/\n+|(?<=[.!?;])\s+|(?<=,)\s+(?=\p{Ll})/gu)) {
+		const end = boundary.index;
+		clauses.push({
+			value: text.slice(cursor, end),
+			start: cursor,
+			end,
+			separatorAfter: boundary[0]
+		});
+		cursor = end + boundary[0].length;
+	}
+	clauses.push({
+		value: text.slice(cursor),
+		start: cursor,
+		end: text.length,
+		separatorAfter: ""
+	});
+	if (clauses.some((clause) => clause.value.trim().length === 0)) throw new Error("REM clause splitter cannot delimit an empty clause");
+	if (clauses.map((clause) => `${clause.value}${clause.separatorAfter}`).join("") !== text) throw new Error("REM clause splitter must preserve source bytes");
+	return clauses;
+}
+//#endregion
+//#region src/engine/rem/update-locale-resources.ts
+const REM_UPDATE_LOCALES = [
+	"en",
+	"de",
+	"es",
+	"fr",
+	"zh",
+	"zh-Hant",
+	"ja",
+	"ko",
+	"ru"
+];
+const REM_UPDATE_LOCALE_RESOURCES = {
+	en: {
+		valuePrefix: "Current preference: ",
+		listPrefix: "Current todos: ",
+		listSeparator: ", ",
+		spanSeparator: " ",
+		anchorMode: "capitalized-sequence"
+	},
+	de: {
+		valuePrefix: "Aktuelle Präferenz: ",
+		listPrefix: "Aktuelle Aufgaben: ",
+		listSeparator: ", ",
+		spanSeparator: " ",
+		anchorMode: "capitalized-sequence"
+	},
+	es: {
+		valuePrefix: "Preferencia actual: ",
+		listPrefix: "Tareas actuales: ",
+		listSeparator: ", ",
+		spanSeparator: " ",
+		anchorMode: "capitalized-sequence"
+	},
+	fr: {
+		valuePrefix: "Préférence actuelle : ",
+		listPrefix: "Tâches actuelles : ",
+		listSeparator: ", ",
+		spanSeparator: " ",
+		anchorMode: "capitalized-sequence"
+	},
+	zh: {
+		valuePrefix: "当前偏好：",
+		listPrefix: "当前任务：",
+		listSeparator: "、",
+		spanSeparator: "",
+		anchorMode: "explicit-script"
+	},
+	"zh-Hant": {
+		valuePrefix: "目前偏好：",
+		listPrefix: "目前任務：",
+		listSeparator: "、",
+		spanSeparator: "",
+		anchorMode: "explicit-script"
+	},
+	ja: {
+		valuePrefix: "現在の好み：",
+		listPrefix: "現在のタスク：",
+		listSeparator: "、",
+		spanSeparator: "",
+		anchorMode: "explicit-script"
+	},
+	ko: {
+		valuePrefix: "현재 선호: ",
+		listPrefix: "현재 작업: ",
+		listSeparator: ", ",
+		spanSeparator: " ",
+		anchorMode: "explicit-script"
+	},
+	ru: {
+		valuePrefix: "Текущее предпочтение: ",
+		listPrefix: "Текущие задачи: ",
+		listSeparator: ", ",
+		spanSeparator: " ",
+		anchorMode: "capitalized-sequence"
+	}
+};
+function getRemUpdateLocaleResource(locale) {
+	return REM_UPDATE_LOCALE_RESOURCES[locale];
+}
+//#endregion
+//#region src/engine/rem/update-rewrite.ts
+function composeRemNegatedCurrent(input) {
+	const generatedRowId = `rem-negated-${createHash("sha256").update(`${input.topic}\u0000${input.retractionText}`).digest("hex").slice(0, 24)}`;
+	return {
+		shape: "negated-current",
+		topic: input.topic,
+		assertions: [{
+			polarity: "negative",
+			provenance: input.retractionText
+		}],
+		generatedRowId,
+		consumedRowIds: [input.priorRowId]
+	};
+}
+function enumerateRemUpdateMembers(source) {
+	return extractListMemberSpans(source).map((span) => source.slice(span.start, span.end));
+}
+function buildRemUpdateReferenceSet(input) {
+	if (input.tier === "list") return buildMemberUnits(input.source, input.enumeratedMembers ?? []);
+	const clauses = splitExactClauses(input.source).map((clause, index) => toCoverageReference(input.source, `clause:${index}`, "clause", clause));
+	const anchors = extractAnchors(input.source, input.locale).map((anchor, index) => toCoverageReference(input.source, `anchor:${index}`, "anchor", anchor));
+	return [...clauses, ...anchors];
+}
+function buildMemberUnits(source, members) {
+	return members.map((value, index) => {
+		const start = source.indexOf(value);
+		return toCoverageReference(source, `member:${index}`, "structured-member", {
+			value,
+			start,
+			end: start < 0 ? -1 : start + value.length
+		});
+	});
+}
+function toCoverageReference(source, id, kind, span) {
+	const text = source.slice(span.start, span.end);
+	return {
+		id,
+		atomId: `atom:${id}`,
+		kind,
+		value: span.value,
+		text,
+		sourceTextSha256: createHash("sha256").update(source).digest("hex"),
+		start: span.start,
+		end: span.end,
+		startByte: Buffer.byteLength(source.slice(0, span.start)),
+		endByte: Buffer.byteLength(source.slice(0, span.end))
+	};
+}
+function extractListMemberSpans(source) {
+	return [...source.matchAll(/^[ \t]*[-*•][ \t]+(.+)$/gmu)].flatMap((match) => {
+		const member = match[1];
+		if (member === void 0 || match.index === void 0) return [];
+		const start = match.index + match[0].indexOf(member);
+		return [{
+			start,
+			end: start + member.length
+		}];
+	});
+}
+function extractAnchors(source, locale) {
+	const anchors = [...matches(source, /["“‘][^"”’]+["”’]/gu), ...matches(source, /\p{Sc}?\d[\d.,:/-]*/gu)];
+	if (getRemUpdateLocaleResource(locale).anchorMode === "capitalized-sequence") anchors.push(...matches(source, /\b\p{Lu}[\p{L}\p{M}]*(?:\s+\p{Lu}[\p{L}\p{M}]*)+\b/gu));
+	return uniqueSpans(anchors);
+}
+function matches(source, pattern) {
+	return [...source.matchAll(pattern)].flatMap((match) => {
+		if (match.index === void 0 || match[0].length === 0) return [];
+		return [{
+			value: match[0],
+			start: match.index,
+			end: match.index + match[0].length
+		}];
+	});
+}
+function uniqueSpans(spans) {
+	const seen = /* @__PURE__ */ new Set();
+	return spans.filter((span) => {
+		const key = `${span.start}:${span.end}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	}).sort((left, right) => left.start - right.start || left.end - right.end);
+}
+//#endregion
+//#region src/engine/rem/coverage-contract.ts
+function buildRemCoverageAtoms(input) {
+	if (input.source.trim().length === 0) return {
+		outcome: "refuse",
+		reason: "empty_reference_set"
+	};
+	if (input.format === "flattened-clauses") return {
+		outcome: "refuse",
+		reason: "unsegmentable_reference_set"
+	};
+	if (input.format === "prose") {
+		const atoms = buildRemUpdateReferenceSet({
+			source: input.source,
+			tier: "prose",
+			locale: "en"
+		});
+		return atoms.length === 0 ? {
+			outcome: "refuse",
+			reason: "empty_reference_set"
+		} : {
+			outcome: "accept",
+			atoms: atoms.map(selectCoverageFields)
+		};
+	}
+	return buildStructuredAtoms(input.source);
+}
+async function validateRemClauseCoverageArtifacts(input) {
+	const arms = {
+		goldSet: input.expectedGoldSetSha256 === input.measuredGoldSetSha256 ? "pass" : "fail",
+		confidence: input.confidenceSatisfied ? "pass" : "fail",
+		chronology: input.declarationSequence < input.firstScoredSequence ? "pass" : "fail",
+		measurement: input.measurementPresent ? "pass" : "fail",
+		artifactDigest: input.artifactDigestMatches ? "pass" : "fail",
+		accuracyFloor: input.accuracyFloor === null ? "owner-unset" : input.measuredAccuracy !== null && input.measuredAccuracy >= input.accuracyFloor ? "pass" : "fail"
+	};
+	if (input.accuracyFloor === null) return {
+		decision: "refuse",
+		reason: "coverage.accuracyFloor",
+		arms
+	};
+	if (input.measuredAccuracy === null) return {
+		decision: "refuse",
+		reason: "coverage.measurementMissing",
+		arms
+	};
+	for (const [arm, status] of Object.entries(arms)) if (status === "fail") return {
+		decision: "refuse",
+		reason: `coverage.${arm}`,
+		arms
+	};
+	return {
+		decision: "allow",
+		reason: null,
+		arms
+	};
+}
+function buildStructuredAtoms(source) {
+	let decoded;
+	try {
+		decoded = JSON.parse(source);
+	} catch {
+		return {
+			outcome: "refuse",
+			reason: "unsegmentable_reference_set"
+		};
+	}
+	if (decoded === null || typeof decoded !== "object") return {
+		outcome: "refuse",
+		reason: "unsegmentable_reference_set"
+	};
+	const descriptors = [];
+	collectStructuredLeaves(decoded, "", void 0, descriptors);
+	let cursor = 0;
+	const digest = createHash("sha256").update(source).digest("hex");
+	const atoms = descriptors.flatMap((descriptor) => {
+		let start = source.indexOf(descriptor.needle, cursor);
+		if (start < 0) start = source.indexOf(descriptor.needle);
+		if (start < 0) return [];
+		const end = start + descriptor.needle.length;
+		cursor = end;
+		return [{
+			atomId: `atom:${descriptor.id}`,
+			kind: descriptor.kind,
+			sourceTextSha256: digest,
+			startByte: Buffer.byteLength(source.slice(0, start)),
+			endByte: Buffer.byteLength(source.slice(0, end)),
+			text: source.slice(start, end)
+		}];
+	});
+	return atoms.length === descriptors.length && atoms.length > 0 ? {
+		outcome: "accept",
+		atoms
+	} : {
+		outcome: "refuse",
+		reason: "unsegmentable_reference_set"
+	};
+}
+function collectStructuredLeaves(value, pointer, objectKey, output) {
+	if (Array.isArray(value)) {
+		value.forEach((member, index) => {
+			const memberPointer = `${pointer}/${index}`;
+			if (member !== null && typeof member === "object") collectStructuredLeaves(member, memberPointer, void 0, output);
+			else output.push({
+				id: memberPointer,
+				kind: "structured-member",
+				needle: JSON.stringify(member)
+			});
+		});
+		return;
+	}
+	if (value !== null && typeof value === "object") {
+		for (const [key, field] of Object.entries(value)) collectStructuredLeaves(field, `${pointer}/${escapeJsonPointer(key)}`, key, output);
+		return;
+	}
+	if (objectKey !== void 0) output.push({
+		id: pointer,
+		kind: "structured-field",
+		needle: `${JSON.stringify(objectKey)}:${JSON.stringify(value)}`
+	});
+}
+function selectCoverageFields(unit) {
+	return {
+		atomId: unit.atomId,
+		kind: unit.kind,
+		sourceTextSha256: unit.sourceTextSha256,
+		startByte: unit.startByte,
+		endByte: unit.endByte,
+		text: unit.text
+	};
+}
+function escapeJsonPointer(value) {
+	return value.replace(/~/gu, "~0").replace(/\//gu, "~1");
+}
+//#endregion
+//#region src/engine/rem/enable-gate.ts
+const SHA256_PATTERN = /^[0-9a-f]{64}$/;
+const artifactSchema = z.object({
+	schema_version: z.number().int(),
+	job_type: z.enum(REM_BUILT_OPERATION_TYPES),
+	implementation_version: z.string().min(1),
+	corpus_sha256: z.string().regex(SHA256_PATTERN),
+	baseline_sha256: z.string().regex(SHA256_PATTERN),
+	result: z.enum(["pass", "fail"]),
+	evaluated_at: z.string().datetime(),
+	expires_at: z.string().datetime()
+}).strict();
+var RemEnableGateError = class extends Error {
+	code;
+	constructor(code) {
+		super(code);
+		this.code = code;
+		this.name = "RemEnableGateError";
+	}
+};
+const REM_ENABLE_GATE_BINDINGS = {
+	implementationVersion: "edge-rem-wave-20260806",
+	corpusSha256: "67d1acbe4451cccc0199a9b670b2b8df17b79ba7c3d6d431b4e0e303d73869e2",
+	baselineSha256: "87413c08883fddc81d479fe6dcb9d7a537ee156d2fb73716ab0603860caa64c1"
+};
+function loadRemEnableGate(input) {
+	const artifactPath = path.join(input.stateDir, "rem-gates", `${input.jobType}.json`);
+	let stat;
+	try {
+		stat = lstatSync(artifactPath);
+	} catch {
+		throw new RemEnableGateError("artifact_missing");
+	}
+	if (!stat.isFile() || stat.isSymbolicLink()) throw new RemEnableGateError("artifact_not_regular");
+	if ((stat.mode & 18) !== 0) throw new RemEnableGateError("artifact_permissions");
+	if (typeof process.getuid === "function" && stat.uid !== process.getuid()) throw new RemEnableGateError("artifact_owner");
+	const bytes = readFileSync(artifactPath);
+	if (createHash("sha256").update(bytes).digest("hex") !== input.artifactSha256) throw new RemEnableGateError("artifact_digest_mismatch");
+	const artifact = parseArtifact(bytes);
+	assertArtifactBindings(artifact, input);
+	return artifact;
+}
+function parseArtifact(bytes) {
+	let decoded;
+	try {
+		decoded = JSON.parse(bytes.toString("utf8"));
+	} catch {
+		throw new RemEnableGateError("artifact_schema");
+	}
+	const parsed = artifactSchema.safeParse(decoded);
+	if (!parsed.success) throw new RemEnableGateError("artifact_schema");
+	return parsed.data;
+}
+function assertArtifactBindings(artifact, input) {
+	if (artifact.schema_version !== 1) throw new RemEnableGateError("schema_version_mismatch");
+	if (artifact.job_type !== input.jobType) throw new RemEnableGateError("job_type_mismatch");
+	if (artifact.implementation_version !== input.implementationVersion) throw new RemEnableGateError("implementation_version_mismatch");
+	if (artifact.corpus_sha256 !== input.corpusSha256) throw new RemEnableGateError("corpus_mismatch");
+	if (artifact.baseline_sha256 !== input.baselineSha256) throw new RemEnableGateError("baseline_mismatch");
+	if (artifact.result !== "pass") throw new RemEnableGateError("result_not_pass");
+	const now = Date.parse(input.now);
+	const evaluatedAt = Date.parse(artifact.evaluated_at);
+	const expiresAt = Date.parse(artifact.expires_at);
+	if (!Number.isFinite(now) || evaluatedAt > now) throw new RemEnableGateError("artifact_not_yet_valid");
+	if (expiresAt <= now) throw new RemEnableGateError("artifact_expired");
+}
+//#endregion
+//#region src/engine/rem/entry-governance.ts
+async function recordNonRefusePairDecision(input) {
+	if (input.decision === "allow" || input.throughRefusePair) return;
+	if (input.reason === null || input.reason.trim().length === 0) throw new Error("A refused pair decision requires a reason");
+	const existing = input.database.prepare(`SELECT job_id, job_type, stage, outcome, reason
+			 FROM nodix_rem_journal WHERE attempt_id = ?`).get(input.attemptIdentity);
+	if (existing !== void 0) {
+		if (existing.job_id === input.waveId && existing.job_type === input.operation && existing.stage === input.source && existing.outcome === "refused" && existing.reason === input.reason) return;
+		throw new Error("attempt_decision_conflict");
+	}
+	input.database.prepare(`INSERT INTO nodix_rem_journal(
+				job_id, job_type, stage, attempt_id, outcome,
+				pairs_scanned, verdicts, actions_applied, reason
+			) VALUES (?, ?, ?, ?, 'refused', 0, 0, 0, ?)`).run(input.waveId, input.operation, input.source, input.attemptIdentity, input.reason);
+}
+function validateRemSubstantiveWaveEffects(input) {
+	const journalRows = input.database.prepare(`SELECT count(*) AS count FROM nodix_rem_journal
+			 WHERE job_id = ? AND outcome NOT IN ('refused', 'disabled', 'no-action')`).get(input.waveId);
+	const effects = input.database.prepare("SELECT count(*) AS count FROM nodix_rem_write_attempts WHERE job_id = ? AND outcome = 'succeeded'").get(input.waveId);
+	const groupCloses = input.database.prepare(`SELECT count(*) AS count
+			 FROM nodix_rem_journal AS journal
+			 JOIN nodix_memories AS memory
+			   ON memory.id = CASE WHEN json_valid(journal.detail)
+			      THEN json_extract(journal.detail, '$.targetRowId') END
+			 WHERE journal.job_id = ?
+			   AND journal.outcome = 'done'
+			   AND journal.stage LIKE 'update-retirement-target:%'
+			   AND json_extract(memory.metadata, '$.superseded_by') = CASE
+			       WHEN json_valid(journal.detail)
+			       THEN json_extract(journal.detail, '$.nominatedRowId') END`).get(input.waveId);
+	if ((journalRows?.count ?? 0) > 0 && (effects?.count ?? 0) + (groupCloses?.count ?? 0) === 0) return {
+		decision: "refuse",
+		reasonCode: "journal_only"
+	};
+	return {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function defineRemSafetyGuard(_metadata, guard) {
+	return guard;
+}
+function validateRemGuardCensus(input) {
+	const manifest = readJsonArray(input.manifestPath);
+	const required = readJsonArray(input.requiredGuardsPath);
+	const sourceFiles = input.sourceRoots.flatMap(listTypeScriptFiles);
+	const sources = new Map(sourceFiles.map((file) => [path.resolve(file), readFileSync(file, "utf8")]));
+	const discovered = /* @__PURE__ */ new Set();
+	for (const source of sources.values()) for (const match of source.matchAll(/defineRemSafetyGuard\s*\(\s*\{\s*guardId:\s*["']([^"']+)["']/gu)) {
+		const guardId = match[1];
+		if (guardId !== void 0) discovered.add(guardId);
+	}
+	const manifestIds = new Set(manifest.map((row) => row.guardId));
+	if (manifestIds.size === 0 && discovered.size === 0) return {
+		decision: "refuse",
+		reasonCode: "guard_inventory_empty"
+	};
+	if (!sameSet(manifestIds, discovered)) return {
+		decision: "refuse",
+		reasonCode: [...sources.values()].some((source) => /(?:function\s+\w+\s*\([^)]*\)\s*:\s*RemRefusalCode|throw\s+new\s+\w*RemGateError)/u.test(source)) ? "unmarked_guard" : "manifest_source_inequality"
+	};
+	if (required.length === 0 || manifest.some((row) => !required.some((item) => item.guardId === row.guardId)) || required.some((item) => !manifestIds.has(item.guardId))) return {
+		decision: "refuse",
+		reasonCode: "required_protection_missing"
+	};
+	const reachable = collectReachableFiles(input.productionRoots, sources);
+	for (const row of manifest) {
+		const moduleFile = [...sources.keys()].find((file) => file.endsWith(row.module));
+		if (moduleFile === void 0 || !reachable.has(moduleFile)) return {
+			decision: "refuse",
+			reasonCode: "guard_unreachable"
+		};
+	}
+	return {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function readJsonArray(file) {
+	const value = JSON.parse(readFileSync(file, "utf8"));
+	if (!Array.isArray(value)) throw new Error(`${file} must contain a JSON array`);
+	return value;
+}
+function listTypeScriptFiles(root) {
+	return readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+		const entryPath = path.join(root, entry.name);
+		if (entry.isDirectory()) return listTypeScriptFiles(entryPath);
+		return entry.isFile() && /\.tsx?$/u.test(entry.name) ? [entryPath] : [];
+	});
+}
+function collectReachableFiles(roots, sources) {
+	const reachable = /* @__PURE__ */ new Set();
+	const pending = roots.map((root) => path.resolve(root));
+	while (pending.length > 0) {
+		const file = pending.pop();
+		if (file === void 0 || reachable.has(file)) continue;
+		const source = sources.get(file);
+		if (source === void 0) continue;
+		reachable.add(file);
+		for (const match of source.matchAll(/(?:from\s+|import\s*\()["'](\.[^"']+)["']/gu)) {
+			const specifier = match[1];
+			if (specifier === void 0) continue;
+			for (const candidate of resolveSourceCandidates(file, specifier)) if (sources.has(candidate)) pending.push(candidate);
+		}
+	}
+	return reachable;
+}
+function resolveSourceCandidates(importer, specifier) {
+	const base = path.resolve(path.dirname(importer), specifier);
+	return [
+		base,
+		`${base}.ts`,
+		`${base}.tsx`,
+		path.join(base, "index.ts")
+	].map((file) => path.resolve(file));
+}
+function sameSet(left, right) {
+	return left.size === right.size && [...left].every((value) => right.has(value));
+}
+//#endregion
+//#region src/engine/rem/row-hash.ts
+/**
+* The one definition of a REM whole-row hash.
+*
+* A recovery record stores `expected_post_hash` before the write; the verified-write guard
+* recomputes it after the write and refuses the mutation when the two disagree. Those two
+* computations lived in different packages and drifted: this package hashed `SELECT *` while
+* `rem-sqlite-adapter` hashed a projected row, so adding the `timezone` column to the projection
+* made every text-version write refuse AFTER its transaction had already committed. One function,
+* imported by both sides, is what stops that happening again.
+*
+* `REM_ROW_HASH_FIELDS` IS the hash — reordering it, adding to it, or removing from it changes
+* every value this function produces. That is why it is versioned rather than edited in place.
+*/
+const REM_ROW_HASH_FIELDS = [
+	"id",
+	"text",
+	"category",
+	"project_id",
+	"importance",
+	"timestamp",
+	"timezone",
+	"metadata",
+	"content_hash",
+	"fact_id",
+	"derived_from",
+	"consolidation_epoch_id",
+	"confidence_source",
+	"lane",
+	"raw_candidate_json",
+	"disposition_reason",
+	"dispositioned_at_ms"
+];
+/**
+* Stamped on every recovery record this build writes. Version 1 means "written before the field
+* list was pinned", and a version-1 hash cannot be reproduced — the two producers of that era
+* covered different columns. Readers must branch on the stored version rather than assume.
+*/
+const REM_ROW_HASH_VERSION = 2;
+/** Version 1 records predate the pinned field list and carry a hash nothing can recompute. */
+const REM_ROW_HASH_VERSION_LEGACY = 1;
+function hashRemMemoryRow(row) {
+	const projected = {};
+	for (const field of REM_ROW_HASH_FIELDS) projected[field] = row[field] ?? null;
+	return createHash("sha256").update(JSON.stringify(projected)).digest("hex");
+}
+//#endregion
+//#region src/engine/rem/facet-persistence.ts
+async function writeRemTwoFacetTransaction(input) {
+	const timestamp = input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+	const updatedAtMs = Date.parse(timestamp);
+	if (!Number.isFinite(updatedAtMs)) throw new Error("REM facet timestamp must be valid");
+	if (input.current.trim().length === 0 || input.history.trim().length === 0) throw new Error("REM facet text must be non-empty");
+	if (input.currentChunks.length === 0) throw new Error("REM current facet requires prepared chunks");
+	assertJobIdentity(input.jobId, input.jobType);
+	return input.database.transaction(() => {
+		const row = input.database.prepare("SELECT * FROM nodix_memories WHERE id = ?").get(input.memoryId);
+		if (row === void 0) throw new Error("REM facet target row is missing");
+		const nextHash = input.contentHash ?? createHash("sha256").update(input.current, "utf8").digest("hex");
+		const recoveryHandle = randomUUID();
+		const priorFacets = input.database.prepare("SELECT facet, text, updated_at_ms FROM nodix_rem_memory_facets WHERE memory_id = ? ORDER BY facet").all(input.memoryId);
+		const priorChunkFacets = input.database.prepare("SELECT chunk_id, facet, chunk_index FROM nodix_memory_chunks WHERE memory_id = ? ORDER BY chunk_id").all(input.memoryId);
+		if (input.metadata === void 0) input.database.prepare("UPDATE nodix_memories SET text = ?, content_hash = ? WHERE id = ?").run(input.current, nextHash, input.memoryId);
+		else input.database.prepare("UPDATE nodix_memories SET text = ?, metadata = ?, content_hash = ? WHERE id = ?").run(input.current, input.metadata, nextHash, input.memoryId);
+		if (process.env["SNO_STATION_MEM_REM_TEST_FAILPOINT"] === "after_primary_write") throw new Error("SNO_STATION_MEM_REM_TEST_FAILPOINT:after_primary_write");
+		const postRow = input.database.prepare("SELECT * FROM nodix_memories WHERE id = ?").get(input.memoryId);
+		if (postRow === void 0) throw new Error("REM facet target row disappeared after update");
+		const expectedPostHash = hashRemMemoryRow(postRow);
+		input.database.prepare(`INSERT INTO nodix_rem_recovery_history(
+					recovery_handle, row_id, operation_kind, prior_row_image, prior_content_hash,
+					expected_post_hash, row_hash_version, reason, mutation_ts
+				) VALUES (?, ?, 'text-version', ?, ?, ?, ?, ?, ?)`).run(recoveryHandle, input.memoryId, JSON.stringify(row), row.content_hash, expectedPostHash, 2, input.reason ?? "REM two-facet update", timestamp);
+		if (input.attemptId !== void 0) input.database.prepare(`UPDATE nodix_rem_write_attempts SET expected_post_content_sha256 = ?
+					WHERE attempt_id = ? AND outcome = 'pending'`).run(nextHash, input.attemptId);
+		const historyIndex = input.database.prepare("SELECT COALESCE(MAX(chunk_index), -1) AS value FROM nodix_memory_chunks WHERE memory_id = ? AND facet = 'history'").get(input.memoryId);
+		input.database.prepare("UPDATE nodix_memory_chunks SET facet = 'history', chunk_index = chunk_index + ? WHERE memory_id = ? AND facet = 'current'").run(historyIndex.value + 1, input.memoryId);
+		const insertChunk = input.database.prepare(`INSERT INTO nodix_memory_chunks(
+				chunk_id, memory_id, chunk_index, chunk_text, dense_payload, summary,
+				entities, tags, source, start_offset, end_offset, token_count, content_type,
+				chunking_version, embedder_provider, embedder_model, embedder_dim,
+				created_at, updated_at, facet
+			) VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'current')`);
+		const insertVector = input.database.prepare("INSERT INTO nodix_memory_chunk_vectors(id, project_id, embedding) VALUES (?, ?, vec_f32(?))");
+		for (const chunk of input.currentChunks) {
+			insertChunk.run(chunk.chunkId, input.memoryId, chunk.chunkIndex, chunk.chunkText, chunk.densePayload, chunk.summary ?? null, chunk.startOffset, chunk.endOffset, chunk.tokenCount, chunk.contentType, chunk.chunkingVersion, chunk.embedderProvider, chunk.embedderModel, chunk.embedderDim, updatedAtMs, updatedAtMs);
+			insertVector.run(chunk.chunkId, row.project_id, chunk.vectorBytes);
+		}
+		input.database.prepare("DELETE FROM nodix_rem_memory_facets WHERE memory_id = ?").run(input.memoryId);
+		const insertFacet = input.database.prepare("INSERT INTO nodix_rem_memory_facets(memory_id, facet, text, updated_at_ms) VALUES (?, ?, ?, ?)");
+		insertFacet.run(input.memoryId, "current", input.current, updatedAtMs);
+		insertFacet.run(input.memoryId, "history", input.history, updatedAtMs);
+		const expectedFacets = input.database.prepare("SELECT facet, text, updated_at_ms FROM nodix_rem_memory_facets WHERE memory_id = ? ORDER BY facet").all(input.memoryId);
+		const expectedChunkFacets = input.database.prepare("SELECT chunk_id, facet, chunk_index FROM nodix_memory_chunks WHERE memory_id = ? ORDER BY chunk_id").all(input.memoryId);
+		input.database.prepare(`INSERT INTO nodix_rem_facet_recovery(
+					recovery_handle, prior_facets_json, prior_chunk_facets_json,
+					expected_facets_json, expected_chunk_facets_json
+				) VALUES (?, ?, ?, ?, ?)`).run(recoveryHandle, JSON.stringify(priorFacets), JSON.stringify(priorChunkFacets), JSON.stringify(expectedFacets), JSON.stringify(expectedChunkFacets));
+		const queueId = input.jobId;
+		input.database.prepare(`INSERT INTO nodix_rem_journal(
+					job_id, job_type, stage, outcome, row_id, pairs_scanned, verdicts, actions_applied
+				) VALUES (?, ?, 'two-facet-write', 'done', ?, 0, 0, 1)`).run(queueId, input.jobType, input.memoryId);
+		return {
+			contentHash: nextHash,
+			recoveryHandle
+		};
+	}).immediate();
+}
+//#endregion
+//#region src/engine/rem/repository.ts
+const bootIdPath = "/proc/sys/kernel/random/boot_id";
+function createRemRepository(database) {
+	return {
+		recordClassification: (input) => recordClassification(database, input),
+		claimRow: (input) => claimRow(database, input),
+		recoverRowClaim: (input) => recoverRowClaim(database, input),
+		completeRowClaim: (input) => completeRowClaim(database, input),
+		releaseRowClaim: (input) => releaseRowClaim(database, input),
+		createVerdictGeneration: (input) => createVerdictGeneration(database, input),
+		findOpenVerdictGeneration: (input) => findOpenVerdictGeneration(database, input),
+		listVerdictPairs: (generationId) => listVerdictPairs(database, generationId),
+		readClosedVerdictPairIds: (pairIds) => readClosedVerdictPairIds(database, pairIds),
+		claimNextPair: (input) => claimNextPair(database, input),
+		releasePairClaim: (input) => releasePairClaim(database, input),
+		completePair: (input) => completePair(database, input),
+		refusePair: (input) => refusePair(database, input),
+		reserveLlmBudget: (input) => reserveLlmBudget(database, input),
+		readGeneration: (generationId) => readGeneration(database, generationId),
+		readInvocation: (input) => readInvocation(database, input),
+		appendJournal: (jobId, jobType, entry) => appendJournal(database, jobId, jobType, entry),
+		listJournal: (jobId, jobType) => listJournal(database, jobId, jobType),
+		recordVerdictCheckpoint: (input) => recordVerdictCheckpoint(database, input),
+		resumeVerdictPair: (input) => resumeVerdictPair(database, input),
+		readVerdictPair: (generationId, pairId) => readVerdictPair(database, generationId, pairId)
+	};
+}
+function recordClassification(database, input) {
+	database.prepare(`INSERT INTO nodix_rem_relation_ledger(
+				row_id, content_hash, state, owner, claim_ts, classified_at
+			) VALUES (?, ?, ?, 'none', NULL, ?)
+			ON CONFLICT(row_id) DO UPDATE SET
+				content_hash = excluded.content_hash,
+				state = excluded.state,
+				classified_at = excluded.classified_at
+			WHERE nodix_rem_relation_ledger.owner = 'none'`).run(input.rowId, input.contentHash, input.state, input.classifiedAt);
+}
+function claimRow(database, input) {
+	const holderProcessStart = requireProcessStart(input.holderPid);
+	const holderBootId = requireBootId();
+	return database.transaction(() => {
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_relation_ledger
+					SET owner = ?, claim_ts = ?
+					WHERE row_id = ? AND owner = 'none' AND content_hash = ?
+						AND EXISTS (
+							SELECT 1 FROM nodix_memories
+							WHERE id = nodix_rem_relation_ledger.row_id
+								AND content_hash = nodix_rem_relation_ledger.content_hash
+						)`).run(input.owner, input.claimTs, input.rowId, input.contentHash)).changes === 1) {
+			database.prepare(`INSERT INTO nodix_rem_row_claims(
+						row_id, content_hash, owner, claim_token, holder_pid,
+						holder_process_start, holder_boot_id, claimed_at
+					) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(input.rowId, input.contentHash, input.owner, input.claimToken, input.holderPid, holderProcessStart, holderBootId, input.claimTs);
+			return { claimed: true };
+		}
+		const ledger = database.prepare("SELECT content_hash, owner FROM nodix_rem_relation_ledger WHERE row_id = ?").get(input.rowId);
+		const memory = database.prepare("SELECT content_hash FROM nodix_memories WHERE id = ?").get(input.rowId);
+		if (!ledger || !memory) return {
+			claimed: false,
+			reason: "missing"
+		};
+		if (ledger.content_hash !== input.contentHash || memory.content_hash !== input.contentHash) return {
+			claimed: false,
+			reason: "content_changed"
+		};
+		const claim = database.prepare("SELECT claim_token FROM nodix_rem_row_claims WHERE row_id = ?").get(input.rowId);
+		if (!claim) throw new Error("row claim has inconsistent durable state");
+		return {
+			claimed: false,
+			reason: "already_claimed",
+			claimToken: claim.claim_token
+		};
+	}).immediate();
+}
+function recoverRowClaim(database, input) {
+	const holderProcessStart = requireProcessStart(input.holderPid);
+	const holderBootId = requireBootId();
+	const refusal = inspectRowClaimOwnership(database, input);
+	if (refusal) return {
+		recovered: false,
+		reason: refusal
+	};
+	const prior = getRowClaim(database, input.rowId);
+	if (!(prior.holder_pid === input.holderPid && prior.holder_process_start === holderProcessStart && prior.holder_boot_id === holderBootId) && isExactProcessAlive(prior.holder_pid, prior.holder_process_start, prior.holder_boot_id, holderBootId)) return {
+		recovered: false,
+		reason: "holder_alive"
+	};
+	return database.transaction(() => {
+		const currentRefusal = inspectRowClaimOwnership(database, input);
+		if (currentRefusal) return {
+			recovered: false,
+			reason: currentRefusal
+		};
+		const memory = database.prepare("SELECT content_hash FROM nodix_memories WHERE id = ?").get(input.rowId);
+		if (!memory) return {
+			recovered: false,
+			reason: "missing"
+		};
+		if (memory.content_hash !== input.contentHash) {
+			if (asRunResult(database.prepare(`DELETE FROM nodix_rem_row_claims
+						WHERE row_id = ? AND content_hash = ? AND owner = ? AND state = 'active'
+							AND claim_token = ? AND holder_pid = ? AND holder_process_start = ?
+							AND holder_boot_id IS ?`).run(input.rowId, input.contentHash, input.owner, input.expectedClaimToken, prior.holder_pid, prior.holder_process_start, prior.holder_boot_id)).changes !== 1) return {
+				recovered: false,
+				reason: "claim_changed"
+			};
+			if (asRunResult(database.prepare(`UPDATE nodix_rem_relation_ledger SET owner = 'none', claim_ts = NULL
+						WHERE row_id = ? AND content_hash = ? AND owner = ?`).run(input.rowId, input.contentHash, input.owner)).changes !== 1) throw new Error("row claim has inconsistent durable state");
+			return {
+				recovered: false,
+				reason: "content_changed_released"
+			};
+		}
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_row_claims SET
+						claim_token = ?, holder_pid = ?, holder_process_start = ?,
+						holder_boot_id = ?, claimed_at = ?
+					WHERE row_id = ? AND content_hash = ? AND owner = ? AND state = 'active'
+						AND claim_token = ? AND holder_pid = ? AND holder_process_start = ?
+						AND holder_boot_id IS ?`).run(input.claimToken, input.holderPid, holderProcessStart, holderBootId, input.claimTs, input.rowId, input.contentHash, input.owner, input.expectedClaimToken, prior.holder_pid, prior.holder_process_start, prior.holder_boot_id)).changes !== 1) return {
+			recovered: false,
+			reason: "claim_changed"
+		};
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_relation_ledger SET claim_ts = ?
+					WHERE row_id = ? AND content_hash = ? AND owner = ?
+						AND EXISTS (
+							SELECT 1 FROM nodix_memories
+							WHERE id = nodix_rem_relation_ledger.row_id
+								AND content_hash = nodix_rem_relation_ledger.content_hash
+						)`).run(input.claimTs, input.rowId, input.contentHash, input.owner)).changes !== 1) throw new Error("row claim has inconsistent durable state");
+		return { recovered: true };
+	}).immediate();
+}
+function completeRowClaim(database, input) {
+	assertJobIdentity(input.jobId, input.jobType);
+	return database.transaction(() => {
+		const prior = getRowClaim(database, input.rowId);
+		if (prior.state === "completed") {
+			const ledger = database.prepare("SELECT content_hash, owner FROM nodix_rem_relation_ledger WHERE row_id = ?").get(input.rowId);
+			const memory = database.prepare("SELECT content_hash FROM nodix_memories WHERE id = ?").get(input.rowId);
+			if (prior.claim_token === input.claimToken && prior.content_hash === input.contentHash && prior.owner === input.owner && ledger?.content_hash === input.contentHash && ledger.owner === input.owner && memory?.content_hash === input.currentContentHash) return { completed: true };
+		}
+		const refusal = inspectRowClaim(database, {
+			...input,
+			expectedClaimToken: input.claimToken,
+			expectedMemoryContentHash: input.currentContentHash
+		});
+		if (refusal) {
+			if (refusal === "content_changed") appendJournal(database, input.jobId, input.jobType, {
+				stage: `row-claim:${input.rowId}`,
+				outcome: "refused",
+				pairsScanned: 0,
+				verdicts: 0,
+				actionsApplied: 0,
+				reason: refusal,
+				rowId: input.rowId
+			});
+			return {
+				completed: false,
+				reason: refusal
+			};
+		}
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_row_claims SET state = 'completed', completed_at = ?
+					WHERE row_id = ? AND content_hash = ? AND owner = ?
+						AND claim_token = ? AND state = 'active'`).run(input.completedAt, input.rowId, input.contentHash, input.owner, input.claimToken)).changes !== 1) return {
+			completed: false,
+			reason: "claim_changed"
+		};
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_relation_ledger SET claim_ts = NULL
+					WHERE row_id = ? AND content_hash = ? AND owner = ?`).run(input.rowId, input.contentHash, input.owner)).changes !== 1) throw new Error("row claim has inconsistent durable state");
+		return { completed: true };
+	}).immediate();
+}
+function releaseRowClaim(database, input) {
+	return database.transaction(() => {
+		const refusal = inspectRowClaimOwnership(database, {
+			...input,
+			expectedClaimToken: input.claimToken
+		});
+		if (refusal) return {
+			released: false,
+			reason: refusal
+		};
+		if (asRunResult(database.prepare(`DELETE FROM nodix_rem_row_claims
+					WHERE row_id = ? AND content_hash = ? AND owner = ?
+						AND claim_token = ? AND state = 'active'`).run(input.rowId, input.contentHash, input.owner, input.claimToken)).changes !== 1) return {
+			released: false,
+			reason: "claim_changed"
+		};
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_relation_ledger SET owner = 'none', claim_ts = NULL
+					WHERE row_id = ? AND content_hash = ? AND owner = ?`).run(input.rowId, input.contentHash, input.owner)).changes !== 1) throw new Error("row claim has inconsistent durable state");
+		return { released: true };
+	}).immediate();
+}
+function createVerdictGeneration(database, input) {
+	database.transaction(() => {
+		database.prepare(`INSERT INTO nodix_rem_scan_generations(
+					generation_id, corpus_snapshot_hash, pairing_config_hash, max_llm_calls, max_tokens
+				) VALUES (?, ?, ?, ?, ?)`).run(input.generationId, input.corpusSnapshotHash, input.pairingConfigHash, input.maxLlmCalls, input.maxTokens);
+		const insertPair = database.prepare(`INSERT INTO nodix_rem_scan_pairs(
+				generation_id, pair_id, left_row_id, right_row_id, sort_key,
+				claim_state, attempt_count, progress_state, refusal_reason, inherited_from_generation_id
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+		const inheritedRefusal = input.inheritedRefusalsFromGenerationId ? database.prepare(`SELECT attempt_count, refusal_reason FROM nodix_rem_scan_pairs
+				WHERE generation_id = ? AND pair_id = ? AND progress_state = 'refused'
+					AND refusal_reason IN ('content_changed', 'target_changed')`) : void 0;
+		for (const pair of input.pairs) {
+			const inherited = inheritedRefusal?.get(input.inheritedRefusalsFromGenerationId, pair.pairId);
+			insertPair.run(input.generationId, pair.pairId, pair.leftRowId, pair.rightRowId, pair.sortKey, "unvisited", inherited?.attempt_count ?? 0, inherited ? "refused" : "pending", inherited?.refusal_reason ?? null, inherited ? input.inheritedRefusalsFromGenerationId : null);
+		}
+	}).immediate();
+}
+function findOpenVerdictGeneration(database, input) {
+	const row = database.prepare(`SELECT generation_id, corpus_snapshot_hash
+			FROM nodix_rem_scan_generations AS generation
+			WHERE corpus_snapshot_hash = ? AND pairing_config_hash = ?
+				AND EXISTS (
+					SELECT 1 FROM nodix_rem_scan_pairs AS pair
+					WHERE pair.generation_id = generation.generation_id
+						AND pair.claim_state != 'done'
+				)
+			ORDER BY rowid
+			LIMIT 1`).get(input.corpusSnapshotHash, input.pairingConfigHash);
+	return row === void 0 ? void 0 : {
+		generationId: row.generation_id,
+		corpusSnapshotHash: row.corpus_snapshot_hash
+	};
+}
+function listVerdictPairs(database, generationId) {
+	return database.prepare(`SELECT pair_id, left_row_id, right_row_id, sort_key, claim_state, invocation_id
+			FROM nodix_rem_scan_pairs
+			WHERE generation_id = ?
+			ORDER BY sort_key, pair_id`).all(generationId).map((row) => ({
+		pairId: row.pair_id,
+		leftRowId: row.left_row_id,
+		rightRowId: row.right_row_id,
+		sortKey: row.sort_key,
+		claimState: row.claim_state,
+		invocationId: row.invocation_id
+	}));
+}
+function readClosedVerdictPairIds(database, pairIds) {
+	const rows = database.prepare(`SELECT DISTINCT pair_id FROM nodix_rem_scan_pairs
+			WHERE progress_state = 'closed' AND pair_id IN (SELECT value FROM json_each(?))`).all(JSON.stringify(pairIds));
+	return new Set(rows.map((row) => row.pair_id));
+}
+function claimNextPair(database, input) {
+	const holderProcessStart = requireProcessStart(input.holderPid);
+	const holderBootId = requireBootId();
+	return database.transaction(() => {
+		ensureInvocation(database, input.generationId, input.invocationId, input.claimedAt);
+		const pair = database.prepare(`SELECT pair_id, left_row_id, right_row_id, sort_key, checkpoint, verdict,
+					actions_applied, claim_state, invocation_id, budget_reserved, budget_invocation_id,
+					reserved_tokens, attempt_count, progress_state, refusal_reason, inherited_from_generation_id
+				FROM nodix_rem_scan_pairs
+				WHERE generation_id = ? AND claim_state = 'unvisited'
+				ORDER BY CASE progress_state WHEN 'refused' THEN 0 ELSE 1 END, sort_key, pair_id
+				LIMIT 1`).get(input.generationId);
+		if (!pair) return void 0;
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_scan_pairs SET
+						claim_state = 'claimed', invocation_id = ?, claimed_at = ?,
+						attempt_count = attempt_count + 1, progress_state = 'pending', refusal_reason = NULL
+					WHERE generation_id = ? AND pair_id = ? AND claim_state = 'unvisited'`).run(input.invocationId, input.claimedAt, input.generationId, pair.pair_id)).changes !== 1) return void 0;
+		database.prepare(`INSERT INTO nodix_rem_pair_claims(
+					generation_id, pair_id, claim_token, holder_pid, holder_process_start,
+					holder_boot_id, claimed_at
+				) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(input.generationId, pair.pair_id, input.invocationId, input.holderPid, holderProcessStart, holderBootId, input.claimedAt);
+		return {
+			pairId: pair.pair_id,
+			leftRowId: pair.left_row_id,
+			rightRowId: pair.right_row_id
+		};
+	}).immediate();
+}
+function completePair(database, input) {
+	database.transaction(() => {
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_scan_pairs SET claim_state = 'done', progress_state = 'closed'
+					WHERE generation_id = ? AND pair_id = ? AND claim_state = 'claimed'
+						AND invocation_id = ?`).run(input.generationId, input.pairId, input.invocationId)).changes !== 1) throw new Error("pair is not owned by invocation");
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_pair_claims SET state = 'completed', completed_at = CURRENT_TIMESTAMP
+					WHERE generation_id = ? AND pair_id = ? AND claim_token = ? AND state = 'active'`).run(input.generationId, input.pairId, input.invocationId)).changes !== 1) throw new Error("pair claim has inconsistent durable state");
+	}).immediate();
+}
+function releasePairClaim(database, input) {
+	database.transaction(() => {
+		if (asRunResult(database.prepare(`DELETE FROM nodix_rem_pair_claims WHERE generation_id = ? AND pair_id = ?
+				AND claim_token = ? AND state = 'active'`).run(input.generationId, input.pairId, input.invocationId)).changes !== 1) throw new Error("pair claim is not owned by invocation");
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_scan_pairs SET claim_state = 'unvisited', invocation_id = NULL,
+				claimed_at = NULL, checkpoint = NULL, verdict = NULL,
+				budget_reserved = 0, budget_invocation_id = NULL, reserved_tokens = 0,
+				attempt_count = MAX(0, attempt_count - 1)
+			WHERE generation_id = ? AND pair_id = ? AND claim_state = 'claimed' AND invocation_id = ?`).run(input.generationId, input.pairId, input.invocationId)).changes !== 1) throw new Error("pair claim has inconsistent durable state");
+		database.prepare("DELETE FROM nodix_rem_pair_stage_budgets WHERE generation_id = ? AND pair_id = ?").run(input.generationId, input.pairId);
+	}).immediate();
+}
+function refusePair(database, input) {
+	if (input.reason.trim().length === 0) throw new Error("pair refusal requires a reason");
+	assertJobIdentity(input.jobId, input.jobType);
+	return database.transaction(() => {
+		const pair = getPairRow(database, input.generationId, input.pairId);
+		if (pair.claim_state !== "claimed" || pair.invocation_id !== input.invocationId) throw new Error("pair is not owned by invocation");
+		const state = pair.attempt_count >= 3 ? "exhausted" : "refused";
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_scan_pairs SET claim_state = 'done', progress_state = ?, refusal_reason = ?
+					WHERE generation_id = ? AND pair_id = ? AND claim_state = 'claimed'
+						AND invocation_id = ?`).run(state, input.reason, input.generationId, input.pairId, input.invocationId)).changes !== 1) throw new Error("pair is not owned by invocation");
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_pair_claims SET state = 'completed', completed_at = CURRENT_TIMESTAMP
+					WHERE generation_id = ? AND pair_id = ? AND claim_token = ? AND state = 'active'`).run(input.generationId, input.pairId, input.invocationId)).changes !== 1) throw new Error("pair claim has inconsistent durable state");
+		appendJournal(database, input.jobId, input.jobType, {
+			stage: `replace-pair:${input.pairId}`,
+			outcome: "refused",
+			pairsScanned: 1,
+			verdicts: 1,
+			actionsApplied: 0,
+			reason: input.reason,
+			pairId: input.pairId
+		});
+		return {
+			state,
+			attemptCount: pair.attempt_count
+		};
+	}).immediate();
+}
+function reserveLlmBudget(database, input) {
+	return parseBudgetReservation(database.transaction(() => {
+		const pair = getPairRow(database, input.generationId, input.pairId);
+		if (pair.claim_state !== "claimed" || pair.invocation_id !== input.invocationId) throw new Error("budget pair is not owned by invocation");
+		const holder = getPairClaim(database, input.generationId, input.pairId);
+		if (holder.state !== "active" || holder.claim_token !== input.invocationId) throw new Error("budget pair has inconsistent durable claim");
+		const existingStage = database.prepare(`SELECT reserved_tokens, idempotency_key FROM nodix_rem_pair_stage_budgets
+				WHERE generation_id = ? AND pair_id = ? AND stage = ?`).get(input.generationId, input.pairId, input.stage);
+		if (existingStage !== void 0) return {
+			status: "reserved",
+			tokens: existingStage.reserved_tokens,
+			idempotencyKey: existingStage.idempotency_key
+		};
+		if (!Number.isSafeInteger(input.outputTokenCap) || input.outputTokenCap < 0) throw new Error("output token cap must be a non-negative safe integer");
+		let tokens;
+		if (input.providerUsage) tokens = input.providerUsage.inputTokens + input.providerUsage.outputTokens;
+		else if (input.countTokens) tokens = input.countTokens(input.prompt) + input.outputTokenCap;
+		else {
+			persistPendingStage(database, input.generationId, input.stage);
+			return {
+				status: "pending",
+				reason: "tokenizer_unavailable"
+			};
+		}
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_scan_invocations
+					SET llm_calls_used = llm_calls_used + 1, tokens_used = tokens_used + ?
+					WHERE generation_id = ? AND invocation_id = ?`).run(tokens, input.generationId, input.invocationId)).changes === 1) {
+			database.prepare(`UPDATE nodix_rem_scan_generations
+					SET llm_calls_used = llm_calls_used + 1, tokens_used = tokens_used + ?
+					WHERE generation_id = ?`).run(tokens, input.generationId);
+			const idempotencyKey = `${holder.claim_token}:${input.stage}`;
+			database.prepare(`INSERT INTO nodix_rem_pair_stage_budgets(
+					generation_id, pair_id, stage, invocation_id, reserved_tokens, idempotency_key
+				) VALUES (?, ?, ?, ?, ?, ?)`).run(input.generationId, input.pairId, input.stage, input.invocationId, tokens, idempotencyKey);
+			return {
+				status: "reserved",
+				tokens,
+				idempotencyKey
+			};
+		}
+		persistPendingStage(database, input.generationId, input.stage);
+		return {
+			status: "pending",
+			reason: "invocation_row_missing"
+		};
+	}).immediate());
+}
+function readGeneration(database, generationId) {
+	const row = getGenerationRow(database, generationId);
+	return {
+		generationId: row.generation_id,
+		pendingStages: parsePendingStages(row.pending_stages_json),
+		llmCallsUsed: row.llm_calls_used,
+		tokensUsed: row.tokens_used
+	};
+}
+function readInvocation(database, input) {
+	const row = getInvocationRow(database, input.generationId, input.invocationId);
+	return {
+		llmCallsUsed: row.llm_calls_used,
+		tokensUsed: row.tokens_used
+	};
+}
+function appendJournal(database, jobId, jobType, entry) {
+	database.prepare(`INSERT INTO nodix_rem_journal(
+				job_id, job_type, stage, outcome, pairs_scanned, verdicts, actions_applied, reason,
+				detail, row_id, pair_id
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(jobId, jobType, entry.stage, entry.outcome, entry.pairsScanned, entry.verdicts, entry.actionsApplied, entry.reason ?? null, entry.detail ?? null, entry.rowId ?? null, entry.pairId ?? null);
+}
+function listJournal(database, jobId, jobType) {
+	const operationFilter = jobType === void 0 ? "" : " AND job_type = ?";
+	const parameters = jobType === void 0 ? [jobId] : [jobId, jobType];
+	return database.prepare(`SELECT stage, outcome, pairs_scanned, verdicts, actions_applied, reason, detail,
+				row_id, pair_id
+			FROM nodix_rem_journal WHERE job_id = ?${operationFilter} ORDER BY sequence`).all(...parameters).map((row) => ({
+		stage: row.stage,
+		outcome: row.outcome,
+		pairsScanned: row.pairs_scanned,
+		verdicts: row.verdicts,
+		actionsApplied: row.actions_applied,
+		...row.reason === null ? {} : { reason: row.reason },
+		...row.detail === null ? {} : { detail: row.detail },
+		...row.row_id === null ? {} : { rowId: row.row_id },
+		...row.pair_id === null ? {} : { pairId: row.pair_id }
+	}));
+}
+function recordVerdictCheckpoint(database, input) {
+	if (input.verdict !== void 0 && input.verdict !== "keep" && input.verdict !== "replacement" && input.verdict !== "uncertain") throw new Error("verdict must be keep, replacement, or uncertain");
+	if (asRunResult(database.prepare(`UPDATE nodix_rem_scan_pairs SET
+					claimed_at = ?,
+					checkpoint = ?,
+					verdict = COALESCE(?, verdict),
+					actions_applied = CASE
+						WHEN ? = 'action_applied' THEN 1
+						ELSE actions_applied
+					END
+				WHERE generation_id = ? AND pair_id = ? AND claim_state = 'claimed'
+					AND invocation_id = ?
+					AND CASE checkpoint
+						WHEN 'action_applied' THEN 3
+						WHEN 'verdict_recorded' THEN 2
+						WHEN 'before_llm' THEN 1
+						ELSE 0
+					END <= CASE ?
+						WHEN 'action_applied' THEN 3
+						WHEN 'verdict_recorded' THEN 2
+						WHEN 'before_llm' THEN 1
+						ELSE 0
+					END`).run(input.recordedAt, input.checkpoint, input.verdict ?? null, input.checkpoint, input.generationId, input.pairId, input.invocationId, input.checkpoint)).changes !== 1) throw new Error("verdict pair is not owned by invocation");
+}
+function resumeVerdictPair(database, input) {
+	const holderProcessStart = requireProcessStart(input.holderPid);
+	const holderBootId = requireBootId();
+	const pair = getPairRow(database, input.generationId, input.pairId);
+	const holder = getPairClaim(database, input.generationId, input.pairId);
+	if (pair.claim_state !== "claimed" || pair.invocation_id !== input.expectedInvocationId || holder.state !== "active" || holder.claim_token !== input.expectedInvocationId) throw new Error("verdict pair is not owned by invocation");
+	if (!(holder.holder_pid === input.holderPid && holder.holder_process_start === holderProcessStart && holder.holder_boot_id === holderBootId) && isExactProcessAlive(holder.holder_pid, holder.holder_process_start, holder.holder_boot_id, holderBootId)) return {
+		next: "refused",
+		reason: "holder_alive"
+	};
+	const claimToken = input.invocationId;
+	return database.transaction(() => {
+		ensureInvocation(database, input.generationId, claimToken, input.resumedAt);
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_scan_pairs SET invocation_id = ?, claimed_at = ?
+					WHERE generation_id = ? AND pair_id = ? AND claim_state = 'claimed'
+						AND invocation_id = ?`).run(claimToken, input.resumedAt, input.generationId, input.pairId, input.expectedInvocationId)).changes !== 1) throw new Error("verdict pair is not owned by invocation");
+		if (asRunResult(database.prepare(`UPDATE nodix_rem_pair_claims SET
+						claim_token = ?, holder_pid = ?, holder_process_start = ?,
+						holder_boot_id = ?, claimed_at = ?
+					WHERE generation_id = ? AND pair_id = ? AND state = 'active'
+						AND claim_token = ? AND holder_pid = ? AND holder_process_start = ?
+						AND holder_boot_id IS ?`).run(claimToken, input.holderPid, holderProcessStart, holderBootId, input.resumedAt, input.generationId, input.pairId, input.expectedInvocationId, holder.holder_pid, holder.holder_process_start, holder.holder_boot_id)).changes !== 1) throw new Error("verdict pair has inconsistent durable claim");
+		const resumed = getPairRow(database, input.generationId, input.pairId);
+		if (resumed.checkpoint === "action_applied") return {
+			next: "complete",
+			claimToken
+		};
+		if (resumed.checkpoint === "verdict_recorded") {
+			if (!resumed.verdict) throw new Error("recorded verdict is missing");
+			return {
+				next: "apply_action",
+				verdict: resumed.verdict,
+				claimToken
+			};
+		}
+		return {
+			next: "call_llm",
+			claimToken
+		};
+	}).immediate();
+}
+function readVerdictPair(database, generationId, pairId) {
+	const pair = getPairRow(database, generationId, pairId);
+	return {
+		checkpoint: pair.checkpoint,
+		actionsApplied: pair.actions_applied
+	};
+}
+function getGenerationRow(database, generationId) {
+	const row = database.prepare("SELECT * FROM nodix_rem_scan_generations WHERE generation_id = ?").get(generationId);
+	if (!row) throw new Error("scan generation not found");
+	return row;
+}
+function ensureInvocation(database, generationId, invocationId, createdAt) {
+	database.prepare(`INSERT INTO nodix_rem_scan_invocations(generation_id, invocation_id, created_at)
+			VALUES (?, ?, ?) ON CONFLICT(generation_id, invocation_id) DO NOTHING`).run(generationId, invocationId, createdAt);
+}
+function getInvocationRow(database, generationId, invocationId) {
+	const row = database.prepare(`SELECT llm_calls_used, tokens_used FROM nodix_rem_scan_invocations
+			WHERE generation_id = ? AND invocation_id = ?`).get(generationId, invocationId);
+	if (!row) throw new Error("scan invocation not found");
+	return row;
+}
+function getPairRow(database, generationId, pairId) {
+	const row = database.prepare(`SELECT pair_id, left_row_id, right_row_id, sort_key, checkpoint, verdict,
+				actions_applied, claim_state, invocation_id, budget_reserved, budget_invocation_id,
+				reserved_tokens, attempt_count, progress_state, refusal_reason, inherited_from_generation_id
+			FROM nodix_rem_scan_pairs WHERE generation_id = ? AND pair_id = ?`).get(generationId, pairId);
+	if (!row) throw new Error("verdict pair not found");
+	return row;
+}
+function getPairClaim(database, generationId, pairId) {
+	const row = database.prepare(`SELECT claim_token, holder_pid, holder_process_start, holder_boot_id, state
+			FROM nodix_rem_pair_claims WHERE generation_id = ? AND pair_id = ?`).get(generationId, pairId);
+	if (!row) throw new Error("verdict pair has inconsistent durable claim");
+	return row;
+}
+function getRowClaim(database, rowId) {
+	const row = database.prepare(`SELECT content_hash, owner, claim_token, holder_pid, holder_process_start,
+				holder_boot_id, state
+			FROM nodix_rem_row_claims WHERE row_id = ?`).get(rowId);
+	if (!row) throw new Error("row claim has inconsistent durable state");
+	return row;
+}
+function inspectRowClaim(database, input) {
+	const ownershipRefusal = inspectRowClaimOwnership(database, input);
+	if (ownershipRefusal) return ownershipRefusal;
+	const memory = database.prepare("SELECT content_hash FROM nodix_memories WHERE id = ?").get(input.rowId);
+	if (!memory) return "missing";
+	if (memory.content_hash !== (input.expectedMemoryContentHash ?? input.contentHash)) return "content_changed";
+}
+function inspectRowClaimOwnership(database, input) {
+	const ledger = database.prepare("SELECT content_hash, owner FROM nodix_rem_relation_ledger WHERE row_id = ?").get(input.rowId);
+	if (!ledger) return "missing";
+	if (ledger.content_hash !== input.contentHash) return "inconsistent_state";
+	const claim = database.prepare(`SELECT content_hash, owner, claim_token, holder_pid, holder_process_start,
+				holder_boot_id, state
+			FROM nodix_rem_row_claims WHERE row_id = ?`).get(input.rowId);
+	if (!claim) return ledger.owner === "none" ? "claim_changed" : "inconsistent_state";
+	if (claim.claim_token !== input.expectedClaimToken || claim.content_hash !== input.contentHash || claim.owner !== input.owner || claim.state !== "active") return "claim_changed";
+	if (ledger.owner !== input.owner) return "inconsistent_state";
+}
+function requireProcessStart(pid) {
+	if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error("holder pid must be positive");
+	const marker = readProcessStart(pid);
+	if (!marker) throw new Error("holder process is not running");
+	return marker;
+}
+function isExactProcessAlive(pid, expectedStart, expectedBootId, currentBootId) {
+	if (expectedBootId !== currentBootId) return false;
+	const processStat = readProcessStat(pid);
+	return processStat !== void 0 && processStat.start === expectedStart && processStat.state !== "Z" && processStat.state !== "X" && processStat.state !== "x";
+}
+function readProcessStart(pid) {
+	return readProcessStat(pid)?.start;
+}
+function readProcessStat(pid) {
+	try {
+		const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+		const fields = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/);
+		const state = fields[0];
+		const start = fields[19];
+		if (!state) throw new Error(`process ${pid} stat is missing its state`);
+		if (!start) throw new Error(`process ${pid} stat is missing its start marker`);
+		return {
+			state,
+			start
+		};
+	} catch (error) {
+		if (typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ESRCH")) return;
+		throw error;
+	}
+}
+function requireBootId() {
+	const bootId = readFileSync(bootIdPath, "utf8").trim();
+	if (!bootId) throw new Error("kernel boot id is empty");
+	return bootId;
+}
+function persistPendingStage(database, generationId, stage) {
+	const row = getGenerationRow(database, generationId);
+	const pending = new Set(parsePendingStages(row.pending_stages_json));
+	pending.add(stage);
+	database.prepare("UPDATE nodix_rem_scan_generations SET pending_stages_json = ? WHERE generation_id = ?").run(JSON.stringify(Array.from(pending)), generationId);
+}
+function parsePendingStages(value) {
+	const parsed = JSON.parse(value);
+	if (!Array.isArray(parsed) || !parsed.every((item) => typeof item === "string")) throw new Error("invalid pending stage record");
+	return parsed;
+}
+function asRunResult(value) {
+	if (typeof value !== "object" || value === null || !("changes" in value) || typeof value.changes !== "number") throw new Error("database run result is missing changes");
+	return { changes: value.changes };
+}
+function parseBudgetReservation(value) {
+	if (typeof value !== "object" || value === null || !("status" in value)) throw new Error("budget transaction returned an invalid result");
+	if (value.status === "reserved" && "tokens" in value && typeof value.tokens === "number" && "idempotencyKey" in value && typeof value.idempotencyKey === "string") return {
+		status: "reserved",
+		tokens: value.tokens,
+		idempotencyKey: value.idempotencyKey
+	};
+	if (value.status === "pending" && "reason" in value && (value.reason === "invocation_row_missing" || value.reason === "tokenizer_unavailable")) return {
+		status: "pending",
+		reason: value.reason
+	};
+	throw new Error("budget transaction returned an invalid result");
+}
+//#endregion
+//#region src/engine/rem/replace-clause-verdict.ts
+function buildReplaceEligibleClauses(older, newer) {
+	return [...splitExactClauses(older).map((clause) => ({
+		origin: "older",
+		...clause
+	})), ...splitExactClauses(newer).map((clause) => ({
+		origin: "newer",
+		...clause
+	}))];
+}
+function renderReplaceClauseVerdictPrompt(clauses) {
+	return [
+		"Judge whether the newer memory replaces the older memory.",
+		"replacement: the newer memory supersedes the older memory, so one or more older clauses should retire.",
+		"keep: the two memories should remain independently active because they are compatible, describe different facts, or the newer memory does not establish a replacement.",
+		"uncertain: you cannot determine whether the newer memory replaces the older memory from the supplied content; take no action.",
+		"Return JSON only: {\"verdict\":\"replacement|keep|uncertain\",\"retiring_clause_indices\":[0]}.",
+		"Use only the zero-based indices in the supplied eligible clauses.",
+		"A retiring clause must originate from the older memory. Do not produce text or explanations.",
+		`Eligible clauses: ${JSON.stringify(clauses)}`
+	].join("\n\n");
+}
+function parseReplaceClauseVerdict(response, clauses) {
+	if (!isRecord(response)) return invalidVerdict();
+	if (!hasOnlyKeys(response, ["verdict", "retiring_clause_indices"])) return invalidVerdict();
+	const verdict = response["verdict"];
+	const indices = response["retiring_clause_indices"];
+	if (verdict !== "replacement" && verdict !== "keep" && verdict !== "uncertain" || !Array.isArray(indices) || !indices.every((index) => Number.isInteger(index) && index >= 0 && index < clauses.length) || new Set(indices).size !== indices.length || indices.some((index) => clauses[index]?.origin !== "older")) return invalidVerdict();
+	return {
+		parseState: "valid",
+		verdict,
+		retiringClauseIndices: indices
+	};
+}
+function arbitrateReplaceVerdicts(pairVerdict, clauseVerdict) {
+	if (pairVerdict !== "replacement") return { outcome: "no-action" };
+	if (clauseVerdict.parseState === "invalid") return {
+		outcome: "refused",
+		reason: "clause_parse_failed"
+	};
+	if (clauseVerdict.retiringClauseIndices.length === 0) return {
+		outcome: "refused",
+		reason: "empty_retiring_set"
+	};
+	return {
+		outcome: "proceed",
+		retiringClauseIndices: clauseVerdict.retiringClauseIndices
+	};
+}
+function invalidVerdict() {
+	return {
+		parseState: "invalid",
+		verdict: "uncertain",
+		retiringClauseIndices: []
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, expected) {
+	return Object.keys(value).length === expected.length && expected.every((key) => key in value);
+}
+//#endregion
+//#region src/engine/rem/replace-coverage.ts
+const replaceCoverageSchema = z.object({ atoms: z.array(z.object({
+	clause_index: z.number().int().nonnegative(),
+	class: z.enum([
+		"current-fact",
+		"retired-fact",
+		"event-fact"
+	]),
+	status: z.enum([
+		"covered",
+		"uncovered",
+		"undetermined"
+	])
+}).strict()) }).strict();
+function renderReplaceCoveragePrompt(input) {
+	const olderClauses = buildReplaceEligibleClauses(input.older, input.newer).filter((clause) => clause.origin === "older");
+	return [
+		"Classify whether every older-memory clause remains covered after replacement.",
+		"Return JSON only: {\"atoms\":[{\"clause_index\":0,\"class\":\"current-fact|retired-fact|event-fact\",\"status\":\"covered|uncovered|undetermined\"}]}.",
+		"Return exactly one atom for each older clause. Prefer undetermined over guessing.",
+		"Covered means the newer memory carries the older clause's information. A newer value for the same fact counts as covered: the older value was replaced, not lost.",
+		"Uncovered means the older clause also holds a separate fact that the newer memory neither updates nor restates, so closing the older row would lose it.",
+		"Class describes what kind of assertion the older clause makes, independently of Retiring older-clause indices. Those indices do not determine class or status and do not excuse information loss; evaluate every older clause.",
+		`Older clauses: ${JSON.stringify(olderClauses)}`,
+		`Newer memory: ${JSON.stringify(input.newer)}`,
+		`Retiring older-clause indices: ${JSON.stringify(input.retiringClauseIndices)}`
+	].join("\n\n");
+}
+function parseReplaceCoverageAtoms(value) {
+	const parsed = replaceCoverageSchema.safeParse(value);
+	if (!parsed.success) return void 0;
+	return parsed.data.atoms.map((atom) => ({
+		clauseIndex: atom.clause_index,
+		class: atom.class,
+		status: atom.status
+	}));
+}
+/** Validates model-classified coverage against the code-owned older-clause reference set. */
+/**
+* Every refusal raised after the observation list exists carries what was seen up to that point.
+* Owner ruling 2026-08-13: the count is of conditions detected. Refusing on one condition while
+* silently dropping another the same pair exhibited is how a deletion stays unmeasurable.
+*/
+function refuseWith(reason, atoms, observations, detail) {
+	return {
+		decision: "refuse",
+		reason,
+		atoms,
+		...detail === void 0 ? {} : { detail },
+		...observations.length === 0 ? {} : { observations: [...observations] }
+	};
+}
+function decideReplaceCoverage(input) {
+	const atoms = input.atoms.map((atom) => ({ ...atom }));
+	if (input.older.trim().length === 0) return {
+		decision: "refuse",
+		reason: "empty_older_clause_set",
+		atoms
+	};
+	const olderClauses = buildReplaceEligibleClauses(input.older, input.newer).filter((clause) => clause.origin === "older");
+	if (olderClauses.length === 0) return {
+		decision: "refuse",
+		reason: "empty_older_clause_set",
+		atoms
+	};
+	const observations = [];
+	if (atoms.length !== olderClauses.length || new Set(atoms.map((atom) => atom.clauseIndex)).size !== atoms.length || atoms.some((atom) => atom.clauseIndex < 0 || atom.clauseIndex >= olderClauses.length)) observations.push({
+		code: "incomplete_clause_accounting",
+		detail: `atoms=${atoms.length} clauses=${olderClauses.length}`
+	});
+	const retiring = new Set(input.retiringClauseIndices);
+	for (const atom of atoms) {
+		if (atom.status !== "covered") return refuseWith(`atom_${atom.status}`, atoms, observations);
+		if (atom.class === "retired-fact" && !retiring.has(atom.clauseIndex)) observations.push({
+			code: "retiring_side_mismatch",
+			detail: `clause_index=${atom.clauseIndex}`
+		});
+		if (atom.class === "retired-fact" && input.rawCandidateEvidence !== void 0) {
+			const clause = olderClauses[atom.clauseIndex];
+			if (clause !== void 0 && !input.rawCandidateEvidence.includes(clause.value)) {
+				atom.status = "undetermined";
+				return refuseWith("retired_fact_not_in_evidence", atoms, observations);
+			}
+		}
+	}
+	const certified = new Set(atoms.filter((atom) => atom.status === "covered").map((atom) => atom.clauseIndex));
+	const uncertifiedClauses = olderClauses.map((clause, index) => certified.has(index) || retiring.has(index) ? void 0 : clause.value).filter((value) => value !== void 0);
+	if (atoms.some((atom) => atom.class === "event-fact")) {
+		if (input.carrier === void 0) return refuseWith("event_retrievability_port_missing", atoms, observations);
+		return decideEventFacts(input.carrier, atoms, observations, uncertifiedClauses);
+	}
+	return {
+		decision: "allow",
+		atoms,
+		...observations.length === 0 ? {} : { observations },
+		...uncertifiedClauses.length === 0 ? {} : { uncertifiedClauses }
+	};
+}
+async function decideEventFacts(carrier, atoms, observations, uncertifiedClauses) {
+	const state = await carrier.carrierState();
+	if (!state.retained) return refuseWith("event_not_retrievable", atoms, observations, state.fault);
+	return {
+		decision: "allow",
+		atoms,
+		...observations.length === 0 ? {} : { observations: [...observations] },
+		...uncertifiedClauses.length === 0 ? {} : { uncertifiedClauses: [...uncertifiedClauses] }
+	};
+}
+//#endregion
+//#region src/engine/rem/rem-update-judgment.ts
+const judgmentSchema = z.object({
+	proposed_current: z.string(),
+	retired_values: z.array(z.string())
+}).strict();
+const relationJudgmentSchema = z.object({
+	supersedes: z.boolean(),
+	retires_anything: z.boolean(),
+	supersedes_everything: z.boolean()
+}).strict();
+const retirementTargetSchema = z.object({ target_row_ids: z.array(z.string().min(1)) }).strict();
+const verificationSchema = z.object({
+	faithful: z.boolean(),
+	retired_absent: z.boolean(),
+	all_facts_accounted: z.boolean()
+}).strict();
+function renderRemUpdateJudgmentPrompt(input) {
+	return [
+		input.judgmentSkill,
+		"Task: REM source rewrite.",
+		"Return exactly one JSON object and no prose: {\"proposed_current\":\"\",\"retired_values\":[]}.",
+		"Use exactly those two fields and no additional fields.",
+		"proposed_current must be a string.",
+		"retired_values must be an array of strings.",
+		`Source row: ${JSON.stringify(input.source)}`,
+		...input.enumeratedMembers === void 0 ? [] : [`Code-enumerated members: ${JSON.stringify(input.enumeratedMembers)}`],
+		...input.supersedingText === void 0 ? [] : [`Newer record that supersedes part of this row: ${JSON.stringify(input.supersedingText)}`]
+	].join("\n\n");
+}
+function renderRemUpdateRelationJudgmentPrompt(input) {
+	return [
+		input.judgmentSkill,
+		"Task: REM relation judgment.",
+		"Return exactly one JSON object and no prose: {\"supersedes\":false,\"retires_anything\":false,\"supersedes_everything\":false}.",
+		"Use exactly those three fields and no additional fields.",
+		"supersedes must be a boolean.",
+		"retires_anything must be a boolean.",
+		"supersedes_everything must be a boolean.",
+		`Record under judgment: ${JSON.stringify(input.rowText)}`,
+		`Older records: ${JSON.stringify(input.predecessorTexts)}`,
+		`Other related records: ${JSON.stringify(input.successorTexts)}`
+	].join("\n\n");
+}
+function renderRemRetirementTargetPrompt(input) {
+	return [
+		input.judgmentSkill,
+		"Task: REM retirement target judgment.",
+		"Return exactly one JSON object and no prose: {\"target_row_ids\":[]}.",
+		"Use exactly that field and no additional fields.",
+		"target_row_ids must contain only ids from Candidate rows and must not contain duplicates.",
+		`Nominated row: ${JSON.stringify(input.nominatedRow)}`,
+		`Candidate rows: ${JSON.stringify(input.candidateRows)}`
+	].join("\n\n");
+}
+function renderRemUpdateVerificationPrompt(input) {
+	return [
+		input.judgmentSkill,
+		"Task: REM rewrite verification.",
+		"Return exactly one JSON object and no prose: {\"faithful\":false,\"retired_absent\":false,\"all_facts_accounted\":false}.",
+		"Use exactly those three fields and no additional fields.",
+		...input.retractionText === void 0 ? [] : ["Judge whether the proposed rewrite follows from the relation between the original row and the retraction row."],
+		`Original row: ${JSON.stringify(input.source)}`,
+		...input.supersedingText === void 0 ? [] : [`Newer record: ${JSON.stringify(input.supersedingText)}`],
+		...input.retractionText === void 0 ? [] : [`Retraction row: ${JSON.stringify(input.retractionText)}`],
+		`Proposed rewrite: ${JSON.stringify(input.proposedCurrent)}`,
+		`Retired values: ${JSON.stringify(input.retiredValues)}`
+	].join("\n\n");
+}
+function renderRemClauseCarryPrompt(input) {
+	return [
+		input.judgmentSkill,
+		"Task: REM clause carry judgment.",
+		"Return exactly one JSON object and no prose: {\"already_current\":[true,false]}.",
+		"Use exactly that field and no additional fields.",
+		"already_current must contain exactly one boolean per numbered clause, in the same order.",
+		`Survivor text: ${JSON.stringify(input.survivorText)}`,
+		...input.clauses.map((clause, index) => `Clause ${index + 1}: ${JSON.stringify(clause)}`)
+	].join("\n\n");
+}
+function decideRemUpdateRelationFromReply(reply) {
+	const json = extractJsonFromResponse(reply);
+	if (json === null) return {
+		outcome: "refuse",
+		reason: "model_response_invalid"
+	};
+	let value;
+	try {
+		value = JSON.parse(json);
+	} catch {
+		return {
+			outcome: "refuse",
+			reason: "model_response_invalid"
+		};
+	}
+	const parsed = relationJudgmentSchema.safeParse(value);
+	if (!parsed.success) return {
+		outcome: "refuse",
+		reason: "model_response_invalid"
+	};
+	if (!parsed.data.supersedes || !parsed.data.retires_anything) return {
+		outcome: "refuse",
+		reason: "no_retired_fact"
+	};
+	return {
+		outcome: "allow",
+		supersedesEverything: parsed.data.supersedes_everything
+	};
+}
+function decideRemRetirementTargetFromReply(reply, offeredRowIds) {
+	const json = extractJsonFromResponse(reply);
+	if (json === null) return {
+		outcome: "refuse",
+		reason: "model_response_invalid"
+	};
+	let value;
+	try {
+		value = JSON.parse(json);
+	} catch {
+		return {
+			outcome: "refuse",
+			reason: "model_response_invalid"
+		};
+	}
+	const parsed = retirementTargetSchema.safeParse(value);
+	if (!parsed.success) return {
+		outcome: "refuse",
+		reason: "model_response_invalid"
+	};
+	const targetRowIds = new Set(parsed.data.target_row_ids);
+	if (targetRowIds.size !== parsed.data.target_row_ids.length) return {
+		outcome: "refuse",
+		reason: "model_response_invalid"
+	};
+	if ([...targetRowIds].some((rowId) => !offeredRowIds.has(rowId))) return {
+		outcome: "refuse",
+		reason: "row_id_not_offered"
+	};
+	return {
+		outcome: "allow",
+		targetRowIds: [...targetRowIds]
+	};
+}
+function decideRemUpdateFromReply(reply) {
+	const parsed = parseJudgment(reply);
+	if (parsed === void 0) return {
+		outcome: "refuse",
+		reason: "model_response_invalid"
+	};
+	if (parsed.retiredValues.length === 0) return {
+		outcome: "refuse",
+		reason: "no_retired_fact"
+	};
+	if (parsed.proposedCurrent.trim().length === 0) return {
+		outcome: "refuse",
+		reason: "no_surviving_remainder"
+	};
+	return {
+		outcome: "verify",
+		...parsed
+	};
+}
+function decideRemUpdateVerification(reply) {
+	const json = extractJsonFromResponse(reply);
+	if (json === null) return {
+		outcome: "refuse",
+		reason: "model_response_invalid"
+	};
+	let value;
+	try {
+		value = JSON.parse(json);
+	} catch {
+		return {
+			outcome: "refuse",
+			reason: "model_response_invalid"
+		};
+	}
+	const parsed = verificationSchema.safeParse(value);
+	if (!parsed.success) return {
+		outcome: "refuse",
+		reason: "model_response_invalid"
+	};
+	if (!parsed.data.faithful) return {
+		outcome: "refuse",
+		reason: "proposal_not_faithful"
+	};
+	if (!parsed.data.retired_absent) return {
+		outcome: "refuse",
+		reason: "retired_value_survives"
+	};
+	if (!parsed.data.all_facts_accounted) return {
+		outcome: "refuse",
+		reason: "surviving_fact_lost"
+	};
+	return { outcome: "apply" };
+}
+function decideRemClauseCarry(reply, clauseCount) {
+	if (!Number.isSafeInteger(clauseCount) || clauseCount < 0) return {
+		outcome: "refuse",
+		reason: "model_response_invalid"
+	};
+	const json = extractJsonFromResponse(reply);
+	if (json === null) return {
+		outcome: "refuse",
+		reason: "model_response_invalid"
+	};
+	let value;
+	try {
+		value = JSON.parse(json);
+	} catch {
+		return {
+			outcome: "refuse",
+			reason: "model_response_invalid"
+		};
+	}
+	const parsed = z.object({ already_current: z.array(z.boolean()).length(clauseCount) }).strict().safeParse(value);
+	if (!parsed.success) return {
+		outcome: "refuse",
+		reason: "model_response_invalid"
+	};
+	return {
+		outcome: "decided",
+		alreadyCurrent: parsed.data.already_current
+	};
+}
+function parseJudgment(reply) {
+	const json = extractJsonFromResponse(reply);
+	if (json === null) return void 0;
+	let value;
+	try {
+		value = JSON.parse(json);
+	} catch {
+		return;
+	}
+	const parsed = judgmentSchema.safeParse(value);
+	if (!parsed.success) return void 0;
+	return {
+		proposedCurrent: parsed.data.proposed_current,
+		retiredValues: parsed.data.retired_values
+	};
+}
+//#endregion
+//#region src/engine/rem/runner.ts
+async function runRemStages(input) {
+	const results = {};
+	for (const stage of input.stages) {
+		let entry;
+		try {
+			const observed = await stage.run();
+			results[stage.name] = "done";
+			entry = {
+				...journal(stage.name, "done"),
+				...observed
+			};
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			input.onStageError?.({
+				stage: stage.name,
+				error
+			});
+			results[stage.name] = "failed";
+			entry = {
+				...journal(stage.name, "failed"),
+				reason
+			};
+		}
+		try {
+			await input.repository.appendJournal(input.jobId, input.jobType, entry);
+		} catch (error) {
+			createLogger("sno-station-mem:rem-runner").error("rem.stage.journal.failed", {
+				error,
+				stage: stage.name
+			}, {
+				event_name: "rem.stage.journal.failed",
+				file: "packages/memory/src/engine/rem/runner.ts",
+				function: "runRemStages",
+				site_id: "rem.stage.journal.failed"
+			});
+		}
+	}
+	return results;
+}
+function journal(stage, outcome) {
+	return {
+		stage,
+		outcome,
+		pairsScanned: 0,
+		verdicts: 0,
+		actionsApplied: 0
+	};
+}
+//#endregion
+//#region src/engine/rem/schema.ts
+const REM_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS nodix_rem_relation_ledger (
+	row_id TEXT PRIMARY KEY,
+	content_hash TEXT NOT NULL,
+	state TEXT NOT NULL CHECK (state IN ('transition', 'stale-current', 'pure-negation', 'ambiguous')),
+	owner TEXT NOT NULL DEFAULT 'none' CHECK (owner IN ('restate', 'verdict', 'none')),
+	claim_ts TEXT,
+	classified_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_row_claims (
+	row_id TEXT PRIMARY KEY,
+	content_hash TEXT NOT NULL,
+	owner TEXT NOT NULL CHECK (owner IN ('restate', 'verdict')),
+	claim_token TEXT NOT NULL,
+	holder_pid INTEGER NOT NULL CHECK (holder_pid > 0),
+	holder_process_start TEXT NOT NULL,
+	holder_boot_id TEXT NOT NULL,
+	state TEXT NOT NULL DEFAULT 'active' CHECK (state IN ('active', 'completed')),
+	claimed_at TEXT NOT NULL,
+	completed_at TEXT,
+	FOREIGN KEY (row_id) REFERENCES nodix_rem_relation_ledger(row_id)
+);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_scan_generations (
+	generation_id TEXT PRIMARY KEY,
+	corpus_snapshot_hash TEXT NOT NULL,
+	pairing_config_hash TEXT NOT NULL,
+	max_llm_calls INTEGER NOT NULL CHECK (max_llm_calls >= 0),
+	max_tokens INTEGER NOT NULL CHECK (max_tokens >= 0),
+	llm_calls_used INTEGER NOT NULL DEFAULT 0,
+	tokens_used INTEGER NOT NULL DEFAULT 0,
+	pending_stages_json TEXT NOT NULL DEFAULT '[]'
+);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_scan_pairs (
+	generation_id TEXT NOT NULL,
+	pair_id TEXT NOT NULL,
+	left_row_id TEXT NOT NULL,
+	right_row_id TEXT NOT NULL,
+	sort_key TEXT NOT NULL,
+	claim_state TEXT NOT NULL DEFAULT 'unvisited'
+		CHECK (claim_state IN ('unvisited', 'claimed', 'done')),
+	invocation_id TEXT,
+	claimed_at TEXT,
+	checkpoint TEXT,
+	verdict TEXT,
+	actions_applied INTEGER NOT NULL DEFAULT 0 CHECK (actions_applied IN (0, 1)),
+	budget_reserved INTEGER NOT NULL DEFAULT 0 CHECK (budget_reserved IN (0, 1)),
+	budget_invocation_id TEXT,
+	reserved_tokens INTEGER NOT NULL DEFAULT 0 CHECK (reserved_tokens >= 0),
+	attempt_count INTEGER NOT NULL DEFAULT 0 CHECK (attempt_count >= 0),
+	progress_state TEXT NOT NULL DEFAULT 'pending'
+		CHECK (progress_state IN ('pending', 'refused', 'closed', 'exhausted')),
+	refusal_reason TEXT,
+	inherited_from_generation_id TEXT,
+	PRIMARY KEY (generation_id, pair_id),
+	FOREIGN KEY (generation_id) REFERENCES nodix_rem_scan_generations(generation_id)
+);
+CREATE INDEX IF NOT EXISTS rem_scan_pairs_cursor
+	ON nodix_rem_scan_pairs(generation_id, claim_state, sort_key, pair_id);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_scan_invocations (
+	generation_id TEXT NOT NULL,
+	invocation_id TEXT NOT NULL,
+	llm_calls_used INTEGER NOT NULL DEFAULT 0,
+	tokens_used INTEGER NOT NULL DEFAULT 0,
+	created_at TEXT NOT NULL,
+	PRIMARY KEY (generation_id, invocation_id),
+	FOREIGN KEY (generation_id) REFERENCES nodix_rem_scan_generations(generation_id)
+);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_pair_stage_budgets (
+	generation_id TEXT NOT NULL,
+	pair_id TEXT NOT NULL,
+	stage TEXT NOT NULL,
+	invocation_id TEXT NOT NULL,
+	reserved_tokens INTEGER NOT NULL CHECK (reserved_tokens >= 0),
+	idempotency_key TEXT NOT NULL,
+	PRIMARY KEY (generation_id, pair_id, stage),
+	FOREIGN KEY (generation_id, pair_id) REFERENCES nodix_rem_scan_pairs(generation_id, pair_id),
+	FOREIGN KEY (generation_id, invocation_id) REFERENCES nodix_rem_scan_invocations(generation_id, invocation_id)
+);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_pair_claims (
+	generation_id TEXT NOT NULL,
+	pair_id TEXT NOT NULL,
+	claim_token TEXT NOT NULL,
+	holder_pid INTEGER NOT NULL CHECK (holder_pid > 0),
+	holder_process_start TEXT NOT NULL,
+	holder_boot_id TEXT NOT NULL,
+	state TEXT NOT NULL DEFAULT 'active' CHECK (state IN ('active', 'completed')),
+	claimed_at TEXT NOT NULL,
+	completed_at TEXT,
+	PRIMARY KEY (generation_id, pair_id),
+	FOREIGN KEY (generation_id, pair_id) REFERENCES nodix_rem_scan_pairs(generation_id, pair_id)
+);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_journal (
+	sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+	job_id TEXT NOT NULL,
+	job_type TEXT NOT NULL,
+	stage TEXT NOT NULL,
+	attempt_id TEXT,
+	outcome TEXT NOT NULL CHECK (outcome IN ('done', 'failed', 'disabled', 'pending', 'refused', 'no-action')),
+	row_id TEXT,
+	pair_id TEXT,
+	pairs_scanned INTEGER NOT NULL DEFAULT 0,
+	verdicts INTEGER NOT NULL DEFAULT 0,
+	actions_applied INTEGER NOT NULL DEFAULT 0,
+	reason TEXT,
+	detail TEXT,
+	CHECK (outcome NOT IN ('failed', 'refused') OR length(trim(reason)) > 0)
+);
+CREATE INDEX IF NOT EXISTS rem_journal_job_sequence ON nodix_rem_journal(job_id, sequence);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_recovery_history (
+	recovery_handle TEXT PRIMARY KEY,
+	row_id TEXT NOT NULL,
+	operation_kind TEXT NOT NULL CHECK (operation_kind IN ('lane', 'text-version', 'mark')),
+	prior_row_image TEXT NOT NULL,
+	prior_content_hash TEXT NOT NULL,
+	expected_post_hash TEXT NOT NULL,
+	row_hash_version INTEGER NOT NULL DEFAULT 1,
+	reason TEXT NOT NULL CHECK (length(trim(reason)) > 0),
+	mutation_ts TEXT NOT NULL,
+	restored_at TEXT
+);
+CREATE INDEX IF NOT EXISTS rem_recovery_history_row ON nodix_rem_recovery_history(row_id);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_memory_facets (
+	memory_id TEXT NOT NULL,
+	facet TEXT NOT NULL CHECK (facet IN ('current', 'history')),
+	text TEXT NOT NULL,
+	updated_at_ms INTEGER NOT NULL,
+	PRIMARY KEY (memory_id, facet),
+	FOREIGN KEY (memory_id) REFERENCES nodix_memories(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS rem_memory_facets_by_facet
+	ON nodix_rem_memory_facets(facet, memory_id);
+
+CREATE TRIGGER IF NOT EXISTS rem_memory_facets_after_insert
+AFTER INSERT ON nodix_memories
+BEGIN
+	INSERT INTO nodix_rem_memory_facets(memory_id, facet, text, updated_at_ms)
+		VALUES (NEW.id, 'current', NEW.text, NEW.timestamp);
+END;
+
+CREATE TRIGGER IF NOT EXISTS rem_memory_facets_after_text_update
+AFTER UPDATE OF text ON nodix_memories
+BEGIN
+	INSERT INTO nodix_rem_memory_facets(memory_id, facet, text, updated_at_ms)
+		VALUES (NEW.id, 'current', NEW.text, NEW.timestamp)
+	ON CONFLICT(memory_id, facet) DO UPDATE SET
+		text = excluded.text, updated_at_ms = excluded.updated_at_ms;
+END;
+
+CREATE TABLE IF NOT EXISTS nodix_rem_facet_recovery (
+	recovery_handle TEXT PRIMARY KEY,
+	prior_facets_json TEXT NOT NULL,
+	prior_chunk_facets_json TEXT NOT NULL,
+	expected_facets_json TEXT NOT NULL,
+	expected_chunk_facets_json TEXT NOT NULL,
+	FOREIGN KEY (recovery_handle) REFERENCES nodix_rem_recovery_history(recovery_handle)
+);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_write_verdicts (
+	evidence_id TEXT PRIMARY KEY,
+	winner_row_id TEXT NOT NULL,
+	loser_row_id TEXT NOT NULL,
+	target_row_id TEXT NOT NULL,
+	retired_fact_atoms_json TEXT NOT NULL,
+	recorded_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_write_attempts (
+	attempt_id TEXT PRIMARY KEY,
+	job_id TEXT NOT NULL,
+	stage TEXT NOT NULL,
+	row_id TEXT NOT NULL,
+	writer TEXT NOT NULL,
+	attempt_ordinal INTEGER NOT NULL CHECK (attempt_ordinal > 0),
+	outcome TEXT NOT NULL CHECK (outcome IN ('pending', 'succeeded', 'failed', 'refused', 'degraded')),
+	reason_code TEXT,
+	pre_write_content_sha256 TEXT NOT NULL,
+	proposed_text_sha256 TEXT NOT NULL,
+	evidence_id TEXT NOT NULL,
+	configuration_sha256 TEXT NOT NULL,
+	expected_post_content_sha256 TEXT,
+	post_write_content_sha256 TEXT,
+	opened_at TEXT NOT NULL,
+	closed_at TEXT
+);
+CREATE INDEX IF NOT EXISTS rem_write_attempts_outcome ON nodix_rem_write_attempts(outcome, opened_at);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_census_rows (
+	row_id TEXT PRIMARY KEY,
+	write_identity_sha256 TEXT,
+	candidate_set_sha256 TEXT,
+	generation_id TEXT,
+	corpus_sha256 TEXT,
+	embedder_sha256 TEXT,
+	configuration_sha256 TEXT
+);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_generation_transitions (
+	sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+	outgoing_generation_id TEXT NOT NULL,
+	incoming_generation_id TEXT NOT NULL,
+	recorded_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_batch_summaries (
+	batch_id TEXT PRIMARY KEY,
+	generation_id TEXT UNIQUE,
+	calls INTEGER NOT NULL DEFAULT 0,
+	tokens INTEGER NOT NULL DEFAULT 0,
+	pairCount INTEGER NOT NULL DEFAULT 0,
+	closeCount INTEGER NOT NULL DEFAULT 0,
+	refusalCount INTEGER NOT NULL DEFAULT 0,
+	verdict_distribution_json TEXT NOT NULL DEFAULT '{}',
+	pre_truncation_count INTEGER,
+	emitted_count INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS nodix_rem_verdict_observations (
+	pair_id TEXT PRIMARY KEY,
+	audit_kind TEXT NOT NULL CHECK (audit_kind IN ('VERDICT', 'SAMPLE')),
+	persisted_verdict TEXT,
+	raw_value TEXT NOT NULL
+);
+`;
+function installRemSchema(database) {
+	database.exec(REM_SCHEMA_SQL);
+	ensureAmbiguousRowState(database);
+	ensureHolderBootIdColumn(database, "nodix_rem_row_claims");
+	ensureHolderBootIdColumn(database, "nodix_rem_pair_claims");
+	ensureJournalNullableColumn(database, "row_id");
+	ensureJournalNullableColumn(database, "pair_id");
+	ensureJournalNullableColumn(database, "attempt_id");
+	ensureJournalNullableColumn(database, "detail");
+	database.exec(`
+		CREATE UNIQUE INDEX IF NOT EXISTS rem_journal_external_decision_attempt
+			ON nodix_rem_journal(attempt_id)
+			WHERE attempt_id IS NOT NULL AND stage IN ('arbitration', 'coverage');
+	`);
+	ensureRemChunkFacet(database);
+	backfillRemCurrentFacets(database);
+}
+function ensureAmbiguousRowState(database) {
+	if (database.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'nodix_rem_relation_ledger'").get()?.sql?.includes("'ambiguous'")) return;
+	database.exec("PRAGMA foreign_keys = OFF");
+	try {
+		database.transaction(() => {
+			database.exec(`
+				CREATE TABLE nodix_rem_relation_ledger_next (
+					row_id TEXT PRIMARY KEY,
+					content_hash TEXT NOT NULL,
+					state TEXT NOT NULL CHECK (state IN ('transition', 'stale-current', 'pure-negation', 'ambiguous')),
+					owner TEXT NOT NULL DEFAULT 'none' CHECK (owner IN ('restate', 'verdict', 'none')),
+					claim_ts TEXT,
+					classified_at TEXT NOT NULL
+				);
+				INSERT INTO nodix_rem_relation_ledger_next(
+					row_id, content_hash, state, owner, claim_ts, classified_at
+				) SELECT row_id, content_hash, state, owner, claim_ts, classified_at
+				FROM nodix_rem_relation_ledger;
+				DROP TABLE nodix_rem_relation_ledger;
+				ALTER TABLE nodix_rem_relation_ledger_next RENAME TO nodix_rem_relation_ledger;
+			`);
+		}).immediate();
+	} finally {
+		database.exec("PRAGMA foreign_keys = ON");
+	}
+}
+function ensureRemChunkFacet(database) {
+	if (!tableExists(database, "nodix_memory_chunks")) return;
+	if (!database.prepare("PRAGMA table_info(nodix_memory_chunks)").all().some(({ name }) => name === "facet")) database.exec("ALTER TABLE nodix_memory_chunks ADD COLUMN facet TEXT NOT NULL DEFAULT 'current' CHECK (facet IN ('current', 'history'))");
+	database.exec(`
+		DROP INDEX IF EXISTS nodix_idx_memory_chunks_memory;
+		CREATE UNIQUE INDEX IF NOT EXISTS nodix_idx_memory_chunks_memory_facet
+			ON nodix_memory_chunks(memory_id, facet, chunk_index);
+	`);
+}
+function backfillRemCurrentFacets(database) {
+	if (!tableExists(database, "nodix_memories")) return;
+	database.exec(`
+		INSERT OR IGNORE INTO nodix_rem_memory_facets(memory_id, facet, text, updated_at_ms)
+			SELECT id, 'current', text, timestamp FROM nodix_memories;
+	`);
+}
+function tableExists(database, tableName) {
+	return database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName) !== void 0;
+}
+function ensureJournalNullableColumn(database, column) {
+	if (database.prepare("PRAGMA table_info(nodix_rem_journal)").all().some((candidate) => candidate.name === column)) return;
+	database.exec(`ALTER TABLE nodix_rem_journal ADD COLUMN ${column} TEXT`);
+}
+function ensureHolderBootIdColumn(database, tableName) {
+	if (database.prepare(`PRAGMA table_info(${tableName})`).all().some((column) => column.name === "holder_boot_id")) return;
+	database.exec(`ALTER TABLE ${tableName} ADD COLUMN holder_boot_id TEXT`);
+}
+//#endregion
+//#region src/engine/rem/writer-census.ts
+function discoverRemWritersFromCallGraph(input) {
+	const executorSource = [...readImportClosure(input.entryPoints).values()].find((source) => /^(?:async\s+)?function applyWriterOperation\s*\(/mu.test(source));
+	if (executorSource === void 0) throw new Error("REM production mutation executor is not reachable from the entry points");
+	const start = executorSource.search(/^(?:async\s+)?function applyWriterOperation\s*\(/mu);
+	const end = executorSource.indexOf("\n}\n\nfunction ", start);
+	if (end < 0) throw new Error("REM production mutation executor boundary is incomplete");
+	const writers = /* @__PURE__ */ new Set();
+	for (const match of executorSource.slice(start, end + 2).matchAll(/case\s+"([A-Za-z]+)"\s*:/g)) {
+		const writer = match[1];
+		if (writer !== void 0) writers.add(writer);
+	}
+	return { writers: [...writers].map((writer) => ({ writer })) };
+}
+function readImportClosure(entryPoints) {
+	const pending = entryPoints.map((entryPoint) => resolve(entryPoint));
+	const sources = /* @__PURE__ */ new Map();
+	while (pending.length > 0) {
+		const path = pending.shift();
+		if (path === void 0 || sources.has(path)) continue;
+		if (!existsSync(path)) throw new Error(`REM call-graph entry does not exist: ${path}`);
+		const source = readFileSync(path, "utf8");
+		sources.set(path, source);
+		for (const specifier of readModuleSpecifiers(source)) {
+			const resolved = resolveSourceImport(path, specifier);
+			if (resolved !== void 0 && !sources.has(resolved)) pending.push(resolved);
+		}
+	}
+	return sources;
+}
+function readModuleSpecifiers(source) {
+	const specifiers = [];
+	for (const match of source.matchAll(/(?:from\s+|import\s*\()(["'])([^"']+)\1/g)) if (match[2] !== void 0) specifiers.push(match[2]);
+	return specifiers;
+}
+function resolveSourceImport(importer, specifier) {
+	let candidate;
+	if (specifier.startsWith("./") || specifier.startsWith("../")) candidate = resolve(dirname(importer), specifier);
+	else if (specifier.startsWith("@/")) {
+		const markerIndex = importer.indexOf("/packages/memory/src/");
+		if (markerIndex < 0) return void 0;
+		candidate = resolve(importer.slice(0, markerIndex + 21), specifier.slice(2));
+	} else return;
+	return (extname(candidate).length > 0 ? [candidate, candidate.replace(/\.js$/, ".ts")] : [`${candidate}.ts`, resolve(candidate, "index.ts")]).find((path) => existsSync(path));
+}
+//#endregion
+export { REM_ADDITIONAL_TRANSITION_PATTERN_SHA256, REM_AMBIGUOUS_PATTERN_SHA256, REM_BUILT_OPERATION_TYPES, REM_CURRENT_PROGRESSIVE_PATTERN_SHA256, REM_ENABLE_GATE_BINDINGS, REM_HISTORICAL_FACT_PATTERN_SHA256, REM_JOB_STATES, REM_OPERATION_TYPES, REM_PURE_NEGATION_PATTERN_SHA256, REM_ROW_HASH_FIELDS, REM_ROW_HASH_VERSION, REM_ROW_HASH_VERSION_LEGACY, REM_ROW_STATES, REM_TRANSITION_GRAMMAR_SHA256, REM_UPDATE_LOCALES, RemEnableGateError, adapterAViewFromRecord, arbitrateReplaceVerdicts, assertJobIdentity, buildRemCoverageAtoms, buildRemUpdateReferenceSet, buildReplaceEligibleClauses, canonicalizeRemConfiguration, classifyAllRemCensusLabels, classifyRemCensusLabel, classifyRemRow, composeRemNegatedCurrent, createRemRepository, decideRemClauseCarry, decideRemRetirementTargetFromReply, decideRemUpdateFromReply, decideRemUpdateRelationFromReply, decideRemUpdateVerification, decideReplaceCoverage, declareRemCalibrationThreshold, defineRemSafetyGuard, deriveRemConfigurationSha256, deriveRemReplayArtifactIdentity, deriveRemWriteIdentity, discoverRemWritersFromCallGraph, enumerateRemUpdateMembers, extractJsonFromResponse, getRemUpdateLocaleResource, hashRemMemoryRow, installRemSchema, isAdapterAVerdictReply, journalRemGenerationTransition, loadRemEnableGate, orderAdapterAPair, parseAdapterAChatVerdict, parseRemOperationType, parseRemOperationalConfiguration, parseReplaceClauseVerdict, parseReplaceCoverageAtoms, produceRemCensusArtifact, prospectiveProfileView, readRetainedRemCensusArtifact, recordNonRefusePairDecision, recordRemCandidateCapCounts, recordRemObservedVerdict, renderAdapterAChatPrompt, renderAdapterAPrompt, renderRemClauseCarryPrompt, renderRemRetirementTargetPrompt, renderRemUpdateJudgmentPrompt, renderRemUpdateRelationJudgmentPrompt, renderRemUpdateVerificationPrompt, renderReplaceClauseVerdictPrompt, renderReplaceCoveragePrompt, reportRemSimilarityCalibration, requireRemCoverageAccuracyFloor, requireRemOwnerDecisions, runRemStages, runRestateClassifierEntry, runVerdictClassifierEntry, splitExactClauses, summarizeRemBatchEvents, validateRemCalibrationCrossCheck, validateRemCensusLabelTuple, validateRemCensusOracleProvenance, validateRemCensusRouteCoverage, validateRemClauseCoverageArtifacts, validateRemEnableGateDigestKeys, validateRemGrammarChange, validateRemGuardCensus, validateRemProspectiveIdentity, validateRemReplayIdentityTuple, validateRemSubstantiveWaveEffects, writeRemTwoFacetTransaction };