@snoai/memory 0.0.0-stage → 1.0.1

package/dist/internal/store/maintenance.js

@@ -0,0 +1,1401 @@
+import { BACKUP_INTERVAL_MS, BACKUP_MIN_FREE_DISK_RATIO, FTS_MERGE_INTERVAL_MS, INTEGRITY_CHECK_INTERVAL_MS, MAINTENANCE_TICK_MS, PLANNER_STATISTICS_INTERVAL_MS, REM_TRIGGER_CHECK_INTERVAL_MS, USAGE_EVENT_RETENTION_INTERVAL_MS, USAGE_OUTBOX_INTERVAL_MS } from "../config/index.js";
+import { REM_SIDECAR_TOKEN_HEADER } from "../contract/routes.js";
+import "../engine/shared/utils.js";
+import "../../coding-skin.js";
+import "../config/settings.js";
+import "../../llm-client-BSYUAcUb.js";
+import "../model/llm-mode-routing.js";
+import { n as appendAuditEntryStrict, o as getAuditPath, t as appendAuditEntry } from "../../runtime-audit-log-BCeujlEp.js";
+import { getDiscoveryPath, getSnoStationMemStateDir } from "../contract/profile.js";
+import "../engine/shared/paths.js";
+import { defineRemSafetyGuard, requireRemOwnerDecisions } from "../engine/rem/index.js";
+import { n as state_vocabulary_default, r as attribute_dictionary_default } from "../../relation-dictionary-Cev1kyLe.js";
+import "../../memory-store-shared-DqpWJXZZ.js";
+import { n as loadSqliteVecExtension } from "../../unplaced-candidate-migration-CbQHzcEM.js";
+import { openSqliteDatabase } from "./sqlite-runtime.js";
+import "../../connection-C9YD5sgm.js";
+import "../../store-nPql26YM.js";
+import "../../embedding-provider-client-Q_hJonK9.js";
+import "../../retriever-ZoLvPRHq.js";
+import { t as recordMemoryTelemetryIncident } from "../../memory-telemetry-incidents-BWA9kcZx.js";
+import { z } from "zod";
+import "@snoai/chunking";
+import { createLogger } from "@snoai/utils/logger";
+import path from "node:path";
+import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, statfsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { runIntegrityCheck } from "@snoai/sqlite-crypto";
+import { withLogContext as withLogContext$1 } from "@snoai/utils/log-context";
+//#region src/store/backup.ts
+/** @file backup.ts
+* @purpose Exports, imports, and validates persisted memory data for backup workflows.
+* @boundary Memory store serialization, schema compatibility, and CLI operations.
+* @see store.ts, memory-management-cli.ts, schema.ts.
+*/
+const log$4 = createLogger("sno-station-mem:backup");
+const BACKUP_PREFIX = "sno-station-mem-";
+const BACKUP_SUFFIX = ".sqlite";
+const BACKUP_FILE_REGEX = /^sno-station-mem-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}-p\d+-[a-z0-9]+\.sqlite$/;
+/** Format `Date` as a unique UTC timestamp (colon-free for FS-safety). */
+function formatBackupTimestamp(now) {
+	return `${now.toISOString().replace(/[:.]/g, "-").replace(/Z$/, "")}-p${process.pid}-${process.hrtime.bigint().toString(36)}`;
+}
+/** Escapes a value for SQLite string-literal use in backup statements. */
+function quoteSqliteStringLiteral(value) {
+	return `'${value.replaceAll("'", "''")}'`;
+}
+/**
+* Validates backup file placement before SQLite is allowed to write outside the state directory.
+*/
+function assertSafeBackupPath(stateDir, filePath) {
+	const resolvedStateDir = realpathSync(stateDir);
+	const resolvedBackupPath = path.resolve(filePath);
+	const relativePath = path.relative(resolvedStateDir, resolvedBackupPath);
+	if (relativePath === "" || relativePath.startsWith("..") || path.isAbsolute(relativePath)) throw new Error(`Backup path escapes configured state directory: ${filePath}`);
+	if (!BACKUP_FILE_REGEX.test(path.basename(resolvedBackupPath))) throw new Error(`Unexpected backup filename: ${path.basename(resolvedBackupPath)}`);
+	return resolvedBackupPath;
+}
+/** Thrown when the volume cannot hold a backup even after old backups are removed. */
+var BackupSkippedLowDiskError = class extends Error {
+	neededBytes;
+	freeBytes;
+	reserveBytes;
+	constructor(neededBytes, freeBytes, reserveBytes) {
+		super(`backup skipped: needs ${neededBytes} bytes above a ${reserveBytes}-byte reserve, ${freeBytes} free`);
+		this.neededBytes = neededBytes;
+		this.freeBytes = freeBytes;
+		this.reserveBytes = reserveBytes;
+		this.name = "BackupSkippedLowDiskError";
+	}
+};
+function readVolumeSpace(dir) {
+	const info = statfsSync(dir);
+	return {
+		freeBytes: info.bavail * info.bsize,
+		totalBytes: info.blocks * info.bsize
+	};
+}
+/** Backup file names in the directory, oldest first (names sort by their UTC timestamp). */
+function listBackups(stateDir) {
+	return readdirSync(stateDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.startsWith(BACKUP_PREFIX) && entry.name.endsWith(BACKUP_SUFFIX)).map((entry) => entry.name).sort();
+}
+function removeBackups(stateDir, names, reason) {
+	for (const name of names) rmSync(path.join(stateDir, name), { force: true });
+	if (names.length > 0) log$4.debug("pruned old backups", {
+		removed: names.length,
+		reason
+	}, {
+		event_name: "sno_station_mem.backup.pruned.old.backups",
+		file: "packages/memory/src/store/backup.ts",
+		function: "removeBackups",
+		site_id: "backup.pruneOldBackups.1dca69b51b"
+	});
+}
+/**
+* Deletes the oldest backups until `neededBytes` fits above the volume's reserve. The newest backup
+* is never deleted here: a full disk must not cost the user their last good copy. Returns whether
+* the space now fits.
+*/
+function freeSpaceForBackup(stateDir, neededBytes, readDiskSpace) {
+	const backups = listBackups(stateDir);
+	let space = readDiskSpace(stateDir);
+	const reserve = space.totalBytes * BACKUP_MIN_FREE_DISK_RATIO;
+	while (space.freeBytes - neededBytes < reserve && backups.length > 1) {
+		const oldest = backups.shift();
+		if (oldest === void 0) break;
+		removeBackups(stateDir, [oldest], "low-disk");
+		space = readDiskSpace(stateDir);
+	}
+	return space.freeBytes - neededBytes >= reserve;
+}
+/** Size a fresh copy of the store can reach: the main file plus its unmerged write-ahead log. */
+function storeBytes(dbPath) {
+	const walPath = `${dbPath}-wal`;
+	return statSync(dbPath).size + (existsSync(walPath) ? statSync(walPath).size : 0);
+}
+/**
+* Whether a backup is due: none exists yet, or the newest is at least BACKUP_INTERVAL_MS old.
+* Read from the files so a restart never takes an extra backup.
+*/
+function isBackupDue(stateDir, now, intervalMs = BACKUP_INTERVAL_MS) {
+	if (!existsSync(stateDir)) return true;
+	const newest = listBackups(stateDir).at(-1);
+	if (newest === void 0) return true;
+	return now - statSync(path.join(stateDir, newest)).mtimeMs >= intervalMs;
+}
+/** Implements run backup as the local SQLite backup scheduling operation. */
+function runBackup(dbPath, stateDir, options = {}) {
+	const normalizedStateDir = stateDir.replaceAll("\\", path.sep);
+	mkdirSync(normalizedStateDir, { recursive: true });
+	const resolvedStateDir = realpathSync(normalizedStateDir);
+	const fileName = `${BACKUP_PREFIX}${formatBackupTimestamp(/* @__PURE__ */ new Date())}${BACKUP_SUFFIX}`;
+	const safeBackupPath = assertSafeBackupPath(resolvedStateDir, path.join(resolvedStateDir, fileName));
+	const tempBackupPath = `${safeBackupPath}.tmp`;
+	const readDiskSpace = options.readDiskSpace ?? readVolumeSpace;
+	const neededBytes = storeBytes(dbPath);
+	if (!freeSpaceForBackup(resolvedStateDir, neededBytes, readDiskSpace)) {
+		const space = readDiskSpace(resolvedStateDir);
+		throw new BackupSkippedLowDiskError(neededBytes, space.freeBytes, space.totalBytes * BACKUP_MIN_FREE_DISK_RATIO);
+	}
+	const sqlite = openSqliteDatabase(dbPath, {
+		readonly: true,
+		fileMustExist: true
+	});
+	loadSqliteVecExtension(sqlite.raw);
+	try {
+		sqlite.db.exec(`VACUUM INTO ${quoteSqliteStringLiteral(tempBackupPath)}`);
+	} catch (error) {
+		rmSync(tempBackupPath, { force: true });
+		throw error;
+	} finally {
+		sqlite.db.close();
+	}
+	renameSync(tempBackupPath, safeBackupPath);
+	const backups = listBackups(resolvedStateDir);
+	removeBackups(resolvedStateDir, backups.slice(0, Math.max(0, backups.length - 6)), "retention");
+	freeSpaceForBackup(resolvedStateDir, 0, readDiskSpace);
+	log$4.info("backup created", { backupPath: safeBackupPath }, {
+		event_name: "sno_station_mem.backup.backup.created",
+		file: "packages/memory/src/store/backup.ts",
+		function: "runBackup",
+		site_id: "backup.runBackup.ca114973f1"
+	});
+	return safeBackupPath;
+}
+//#endregion
+//#region src/sidecar/config.ts
+const REM_SIDECAR_HOST = "127.0.0.1";
+const REM_CORRELATION_ID_HEADER = "x-rem-correlation-id";
+const REM_RUN_PATH = "/rem/run";
+function getRemDiscoveryPath() {
+	return getDiscoveryPath();
+}
+"0".repeat(64), "0".repeat(64), "0".repeat(64), "0".repeat(64), "0".repeat(64), "0".repeat(64);
+//#endregion
+//#region src/sidecar/rem-entry-foundations.ts
+const sha256Schema = z.string().regex(/^[0-9a-f]{64}$/u);
+const finiteRecordSchema = z.record(z.string(), z.number().finite()).refine((value) => Object.keys(value).length > 0);
+const commonArtifactShape = {
+	schemaVersion: z.literal(1),
+	artifactId: z.string().min(1),
+	profileId: z.string().min(1),
+	configurationSha256: sha256Schema,
+	createdAt: z.string().datetime()
+};
+z.object({
+	...commonArtifactShape,
+	artifactId: z.literal("p5-production-config"),
+	result: z.enum(["pass", "fail"]),
+	servedModel: z.string().min(1),
+	resolvedParameters: z.record(z.string(), z.unknown()).refine((value) => Object.keys(value).length > 0),
+	readbackSource: z.enum(["wrapper", "immutable-profile"]),
+	immutableProfileSha256: sha256Schema.nullable(),
+	wrapperInvocationId: z.string().min(1).optional(),
+	wrapperReadbackSha256: sha256Schema.optional()
+}).strict();
+z.object({
+	...commonArtifactShape,
+	artifactId: z.literal("p6-monthly-non-regression"),
+	period: z.string().regex(/^\d{4}-\d{2}$/u),
+	minima: finiteRecordSchema,
+	measured: finiteRecordSchema,
+	result: z.enum(["pass", "fail"])
+}).strict();
+z.object({
+	...commonArtifactShape,
+	artifactId: z.literal("p6-monthly-non-regression"),
+	kind: z.literal("owner-waiver"),
+	result: z.literal("pass"),
+	waivedBy: z.string().min(1),
+	waiverReason: z.string().min(1)
+}).strict();
+z.object({
+	...commonArtifactShape,
+	artifactId: z.literal("p7-detector-gate-verdict"),
+	kind: z.literal("measured-pass"),
+	minima: finiteRecordSchema,
+	measured: finiteRecordSchema,
+	result: z.enum(["pass", "fail"])
+}).strict();
+z.object({
+	...commonArtifactShape,
+	artifactId: z.literal("p7-detector-gate-verdict"),
+	kind: z.literal("owner-waiver"),
+	result: z.literal("pass"),
+	waivedBy: z.string().min(1),
+	waiverReason: z.string().min(1)
+}).strict();
+z.object({
+	...commonArtifactShape,
+	artifactId: z.literal("population-routing"),
+	producedAtHead: z.string().regex(/^[0-9a-f]{40}$/u),
+	classifierSha256: sha256Schema,
+	fixtureSetSha256: sha256Schema,
+	derivationCommand: z.string().min(1),
+	invocationId: z.string().min(1),
+	observations: z.array(z.object({
+		fixtureId: z.string().min(1),
+		inputSha256: sha256Schema,
+		observedRoute: z.string().min(1),
+		observedVerdict: z.string().min(1)
+	}).strict())
+}).strict();
+z.object({
+	...commonArtifactShape,
+	artifactId: z.literal("population-routing"),
+	kind: z.literal("owner-waiver"),
+	result: z.literal("pass"),
+	waivedBy: z.string().min(1),
+	waiverReason: z.string().min(1)
+}).strict();
+defineRemSafetyGuard({ guardId: "guard.rem.ordered-wave-entry" }, requireRemOwnerDecisions);
+//#endregion
+//#region src/sidecar/rem-update-judgment-skill.ts
+/** @file rem-update-judgment-skill.ts
+* @purpose Loads the model-readable REM update judgment method shipped with the plugin.
+* @boundary Package-relative read of one trusted bundled skill.
+*/
+const REM_UPDATE_SKILL_PATH = path.join("skills", "judge-rem-memory-updates", "SKILL.md");
+const GROUP_CLOSURE_SKILL_PATH = path.join("skills", "judge-group-closure", "SKILL.md");
+function resolveSkillPath(skillPath) {
+	const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+	for (const root of [
+		path.resolve(moduleDir, ".."),
+		path.resolve(moduleDir, "../.."),
+		path.resolve(moduleDir, "../../..")
+	]) {
+		const candidate = path.join(root, skillPath);
+		if (existsSync(candidate)) return candidate;
+	}
+	throw new Error(`sno-station-mem REM update judgment skill is missing: ${skillPath}`);
+}
+const skillText = readFileSync(resolveSkillPath(REM_UPDATE_SKILL_PATH), "utf8");
+readFileSync(resolveSkillPath(GROUP_CLOSURE_SKILL_PATH), "utf8");
+function readSection(heading) {
+	const marker = `## ${heading}\n`;
+	const start = skillText.indexOf(marker);
+	if (start === -1) throw new Error(`REM update judgment skill is missing section: ${heading}`);
+	const bodyStart = start + marker.length;
+	const nextSection = skillText.indexOf("\n## ", bodyStart);
+	return skillText.slice(bodyStart, nextSection === -1 ? void 0 : nextSection).trim();
+}
+readSection("Relation Judgment"), readSection("Source Rewrite"), readSection("Rewrite Verification"), readSection("Clause Carry");
+createLogger("sno-station-mem:rem-sqlite-adapter");
+new AsyncLocalStorage();
+createLogger("sno-station-mem:rem-sidecar:batch");
+const retirementAttributeConfigSchema = z.object({ slugs: z.array(z.object({
+	slug: z.string(),
+	family: z.string().optional(),
+	cardinality: z.enum(["one", "many"]).optional()
+})) });
+const personRetirementAttributes = retirementAttributeConfigSchema.parse(attribute_dictionary_default).slugs;
+const stateRetirementAttributes = retirementAttributeConfigSchema.parse(state_vocabulary_default).slugs;
+const attributeFamilyBySlug = new Map(personRetirementAttributes.map((entry) => [entry.slug, entry.family]));
+for (const entry of stateRetirementAttributes) attributeFamilyBySlug.set(entry.slug, entry.slug.split(".", 1)[0]);
+new Set([...personRetirementAttributes, ...stateRetirementAttributes].filter((entry) => entry.cardinality === "one").map((entry) => entry.slug));
+const REM_CANDIDATE_PREDICATE_SQL = `lane = 'active'
+	AND length(trim(text)) > 0
+	AND category IN ('profile', 'episodic', 'state')
+	AND json_valid(metadata)
+	AND json_extract(metadata, '$.superseded_by') IS NULL`;
+function enumerateRemCandidateScopes(database) {
+	return database.prepare(`SELECT project_id AS scope, count(*) AS candidate_count
+			FROM nodix_memories
+			WHERE ${REM_CANDIDATE_PREDICATE_SQL}
+			GROUP BY project_id
+			ORDER BY project_id`).all().map((row) => ({
+		scope: row.scope,
+		candidateCount: row.candidate_count
+	}));
+}
+//#endregion
+//#region src/sidecar/rem-trigger-state.ts
+/** @file rem-trigger-state.ts
+* @purpose Persists the automatic REM scheduler's strict per-scope state.
+* @boundary One atomically replaced JSON file under the sno-station-mem state directory.
+*/
+const remTriggerScopeStateSchema = z.object({
+	last_pass_at: z.string().datetime(),
+	schedule_zone: z.string().min(1).refine(isValidScheduleZone, "invalid IANA time zone"),
+	last_covered_count: z.number().int().nonnegative(),
+	last_volume_pass_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/u).nullable(),
+	missed_window: z.object({
+		due_at: z.string().datetime(),
+		trigger: z.enum(["daily", "volume"]),
+		recorded_at: z.string().datetime()
+	}).strict().nullable().default(null),
+	attempts: z.object({
+		identity: z.string().min(1).nullable(),
+		count: z.number().int().min(0).max(3)
+	}).strict()
+}).strict();
+const remTriggerStateDocumentSchema = z.object({
+	version: z.literal(1),
+	scopes: z.record(z.string().min(1), remTriggerScopeStateSchema)
+}).strict();
+var RemTriggerStateError = class extends Error {
+	statePath;
+	constructor(statePath, cause) {
+		super(`REM trigger state at ${statePath} is invalid or unreadable: ${errorMessage$1(cause)}`, { cause: cause instanceof Error ? cause : void 0 });
+		this.statePath = statePath;
+		this.name = "RemTriggerStateError";
+	}
+};
+function remTriggerStatePath(stateDir) {
+	return path.join(stateDir, "rem-trigger-state.json");
+}
+async function loadRemTriggerState(stateDir) {
+	const statePath = remTriggerStatePath(stateDir);
+	let raw;
+	try {
+		raw = await readFile(statePath, "utf8");
+	} catch (error) {
+		if (isNodeError$1(error) && error.code === "ENOENT") return {
+			version: 1,
+			scopes: {}
+		};
+		throw new RemTriggerStateError(statePath, error);
+	}
+	try {
+		return remTriggerStateDocumentSchema.parse(JSON.parse(raw));
+	} catch (error) {
+		throw new RemTriggerStateError(statePath, error);
+	}
+}
+function ensureRemTriggerScope(state, input) {
+	const existing = state.scopes[input.scope];
+	if (existing !== void 0) return {
+		state,
+		scopeState: existing,
+		initialized: false
+	};
+	if (input.scope.trim().length === 0) throw new Error("REM trigger scope is required");
+	if (!Number.isInteger(input.candidateCount) || input.candidateCount < 0) throw new Error("REM trigger candidate count must be a nonnegative integer");
+	if (Number.isNaN(input.now.getTime())) throw new Error("REM trigger initialization time is invalid");
+	const scheduleZone = (input.resolveScheduleZone ?? resolveHostScheduleZone)();
+	if (!isValidScheduleZone(scheduleZone)) throw new Error(`invalid REM schedule zone: ${scheduleZone}`);
+	const scopeState = {
+		last_pass_at: input.now.toISOString(),
+		schedule_zone: scheduleZone,
+		last_covered_count: input.candidateCount,
+		last_volume_pass_date: null,
+		missed_window: null,
+		attempts: {
+			identity: null,
+			count: 0
+		}
+	};
+	return {
+		state: {
+			version: 1,
+			scopes: {
+				...state.scopes,
+				[input.scope]: scopeState
+			}
+		},
+		scopeState,
+		initialized: true
+	};
+}
+async function writeRemTriggerStateAtomic$1(stateDir, state) {
+	const validated = remTriggerStateDocumentSchema.parse(state);
+	await mkdir(stateDir, {
+		recursive: true,
+		mode: 448
+	});
+	const statePath = remTriggerStatePath(stateDir);
+	const temporaryPath = `${statePath}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		const handle = await open(temporaryPath, "wx", 384);
+		try {
+			await handle.writeFile(JSON.stringify(validated), "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		await rename(temporaryPath, statePath);
+		await syncDirectory(stateDir);
+	} catch (error) {
+		await rm(temporaryPath, { force: true });
+		throw error;
+	}
+}
+function resolveHostScheduleZone() {
+	return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function isValidScheduleZone(value) {
+	if (value.trim().length === 0) return false;
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone: value }).format(0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function syncDirectory(directory) {
+	if (process.platform === "win32") return;
+	const handle = await open(directory, "r");
+	try {
+		await handle.sync();
+	} finally {
+		await handle.close();
+	}
+}
+function isNodeError$1(error) {
+	return error instanceof Error && "code" in error;
+}
+function errorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+const REM_COMPLETION_AUDIT_TAIL_BYTES = 16777216;
+const log$1 = createLogger("sno-station-mem:rem-trigger");
+function remNeedsHost(mode, modelCalls) {
+	return Object.keys(modelCalls).some((id) => id.startsWith("REM") && modelCalls[id][mode] === "host");
+}
+const discoverySchema = z.object({
+	pid: z.number().int().positive(),
+	port: z.number().int().min(1).max(65535),
+	token: z.string().min(1)
+}).strict();
+const idleEvaluations = /* @__PURE__ */ new Map();
+async function evaluateRemAutomaticTriggers(input) {
+	const now = input.now ?? /* @__PURE__ */ new Date();
+	if (!Number.isInteger(input.volumeThreshold ?? 100) || (input.volumeThreshold ?? 100) < 1) throw new Error("REM volume threshold must be a positive integer");
+	const auditStateDir = input.auditStateDir ?? input.stateDir;
+	if (Number.isNaN(now.getTime())) throw new Error("REM trigger evaluation time is invalid");
+	if (input.requestedOperations.length === 0) {
+		await recordDecision(auditStateDir, void 0, "skipped", {
+			row: "automatic-trigger-skipped",
+			reason: "product-mode-disabled"
+		});
+		return {
+			evaluations: 0,
+			dispatches: 0
+		};
+	}
+	if (input.mode && remNeedsHost(input.mode, input.modelCalls) && !input.hasConnectedHost?.()) {
+		await recordDecision(auditStateDir, void 0, "skipped", {
+			row: "automatic-trigger-skipped",
+			reason: "skipped: no host model connected"
+		});
+		return {
+			evaluations: 0,
+			dispatches: 0
+		};
+	}
+	let scopes;
+	try {
+		scopes = enumerateRemCandidateScopes(input.database);
+	} catch (error) {
+		await recordDecision(auditStateDir, void 0, "error", {
+			row: "enumeration-failed",
+			cause: errorMessage(error)
+		});
+		return {
+			evaluations: 1,
+			dispatches: 0
+		};
+	}
+	if (scopes.length === 0) {
+		await recordDecision(auditStateDir, void 0, "ok", { row: "no-scopes" });
+		return {
+			evaluations: 1,
+			dispatches: 0
+		};
+	}
+	let state;
+	let lostState = false;
+	try {
+		state = await loadRemTriggerState(input.stateDir);
+	} catch (error) {
+		for (const { scope, candidateCount } of scopes) {
+			const consecutiveIdle = (idleEvaluations.get(scope) ?? 0) + 1;
+			idleEvaluations.set(scope, consecutiveIdle);
+			await recordDecision(auditStateDir, scope, "error", {
+				row: "state-unreadable",
+				candidate_count: candidateCount,
+				cause: errorMessage(error),
+				consecutive_idle: consecutiveIdle
+			});
+		}
+		log$1.error("REM trigger state unavailable; continuing with due work", { cause: errorMessage(error) }, {
+			event_name: "memory.rem.trigger.state.unavailable",
+			file: "packages/memory/src/sidecar/rem-trigger.ts",
+			function: "evaluateRemAutomaticTriggers",
+			site_id: "memory.rem.trigger.state.unavailable"
+		});
+		state = {
+			version: 1,
+			scopes: {}
+		};
+		lostState = true;
+	}
+	state = await applyCompletedBaselines(auditStateDir, input.stateDir, state);
+	let dispatches = 0;
+	for (const { scope, candidateCount } of scopes) try {
+		const ensured = ensureRemTriggerScope(state, {
+			scope,
+			now: lostState ? previousDay(now) : now,
+			candidateCount,
+			resolveScheduleZone: input.resolveScheduleZone
+		});
+		state = ensured.state;
+		if (ensured.initialized) await writeRemTriggerStateAtomic(input.stateDir, state);
+		const scopeResult = await evaluateScope(input, auditStateDir, state, scope, candidateCount, now);
+		state = scopeResult.state;
+		dispatches += scopeResult.dispatched ? 1 : 0;
+	} catch (error) {
+		log$1.error("REM automatic scope evaluation failed", {
+			scope,
+			error
+		}, {
+			event_name: "sno_station_mem.rem-trigger.rem.automatic.scope.evaluation.failed",
+			file: "packages/memory/src/sidecar/rem-trigger.ts",
+			function: "evaluateRemAutomaticTriggers",
+			site_id: "rem-trigger.evaluateRemAutomaticTriggers.1d59077a5c"
+		});
+		try {
+			await recordDecision(auditStateDir, scope, "error", {
+				row: "scope-evaluation-failed",
+				cause: errorMessage(error)
+			});
+		} catch (auditError) {
+			log$1.warn("REM automatic scope failure audit failed", {
+				scope,
+				error: auditError
+			}, {
+				event_name: "sno_station_mem.rem-trigger.rem.automatic.scope.failure.audit.failed",
+				file: "packages/memory/src/sidecar/rem-trigger.ts",
+				function: "evaluateRemAutomaticTriggers",
+				site_id: "rem-trigger.evaluateRemAutomaticTriggers.ebe1cdd204"
+			});
+		}
+		try {
+			state = await loadRemTriggerState(input.stateDir);
+		} catch (stateError) {
+			log$1.warn("REM automatic trigger state reload failed", {
+				scope,
+				error: stateError
+			}, {
+				event_name: "sno_station_mem.rem-trigger.rem.automatic.trigger.state.reload.failed",
+				file: "packages/memory/src/sidecar/rem-trigger.ts",
+				function: "evaluateRemAutomaticTriggers",
+				site_id: "rem-trigger.evaluateRemAutomaticTriggers.46669e66ff"
+			});
+			break;
+		}
+	}
+	return {
+		evaluations: scopes.length,
+		dispatches
+	};
+}
+function previousDay(now) {
+	const day = new Date(now);
+	day.setUTCDate(day.getUTCDate() - 1);
+	return day;
+}
+async function writeRemTriggerStateAtomic(stateDir, state) {
+	try {
+		await writeRemTriggerStateAtomic$1(stateDir, state);
+	} catch (error) {
+		log$1.error("REM trigger state write failed; continuing dispatch", { cause: errorMessage(error) }, {
+			event_name: "memory.rem.trigger.state.write.failed",
+			file: "packages/memory/src/sidecar/rem-trigger.ts",
+			function: "evaluateRemAutomaticTriggers",
+			site_id: "memory.rem.trigger.state.write.failed"
+		});
+	}
+}
+async function evaluateScope(input, auditStateDir, state, scope, candidateCount, now) {
+	const scopeState = requiredScopeState(state, scope);
+	const zone = scopeState.schedule_zone;
+	const nextDue = nextDailyDue(scopeState);
+	const localDate = localDateAt(now, zone);
+	const growth = candidateCount - scopeState.last_covered_count;
+	const scheduledDue = computeRemDailyDue(scopeState.last_pass_at, zone);
+	const pendingVolumeToday = scopeState.attempts.identity === remAutomaticCorrelationId("volume", scope, localDate);
+	const pendingDailyToday = localDateAt(scheduledDue, zone) === localDate && scopeState.attempts.identity === remAutomaticCorrelationId("daily", scope, scheduledDue.toISOString());
+	const dailyDue = now.getTime() >= nextDue.getTime() && !pendingVolumeToday;
+	const volumeDue = growth >= (input.volumeThreshold ?? 100) && scopeState.last_volume_pass_date !== localDate && !pendingDailyToday;
+	if (!dailyDue && !volumeDue) {
+		const consecutiveIdle = (idleEvaluations.get(scope) ?? 0) + 1;
+		idleEvaluations.set(scope, consecutiveIdle);
+		await recordDecision(auditStateDir, scope, "ok", {
+			row: "waiting-for-schedule",
+			next_due: nextDue.toISOString(),
+			milliseconds_until_due: Math.max(0, nextDue.getTime() - now.getTime()),
+			growth: growthDetails(candidateCount, scopeState.last_covered_count, input.volumeThreshold ?? 100),
+			consecutive_idle: consecutiveIdle
+		});
+		return {
+			state,
+			dispatched: false
+		};
+	}
+	const trigger = dailyDue ? "daily" : "volume";
+	if (input.tickEnabled === false) {
+		const nextState = replaceScopeState(state, scope, {
+			...scopeState,
+			missed_window: {
+				due_at: dailyDue ? nextDue.toISOString() : now.toISOString(),
+				trigger,
+				recorded_at: now.toISOString()
+			}
+		});
+		await writeRemTriggerStateAtomic(input.stateDir, nextState);
+		return {
+			state: nextState,
+			dispatched: false
+		};
+	}
+	const correlationId = remAutomaticCorrelationId(trigger, scope, trigger === "daily" ? nextDue.toISOString() : localDate);
+	const priorAttempts = scopeState.attempts.identity === correlationId ? scopeState.attempts.count : 0;
+	await recordDecision(auditStateDir, scope, "ok", {
+		row: "dispatch",
+		trigger,
+		next_due: nextDue.toISOString(),
+		pass_at: now.toISOString(),
+		local_date: localDate,
+		growth: growthDetails(candidateCount, scopeState.last_covered_count, input.volumeThreshold ?? 100),
+		correlation_id: correlationId,
+		consecutive_idle: 0
+	});
+	idleEvaluations.set(scope, 0);
+	let nextState = replaceScopeState(state, scope, {
+		...scopeState,
+		attempts: {
+			identity: correlationId,
+			count: Math.min(priorAttempts + 1, 3)
+		}
+	});
+	await writeRemTriggerStateAtomic(input.stateDir, nextState);
+	let cause;
+	try {
+		await dispatchRemWave(input, scope, correlationId);
+	} catch (error) {
+		cause = errorMessage(error);
+	}
+	if (cause === void 0) {
+		nextState = replaceScopeState(nextState, scope, {
+			...requiredScopeState(nextState, scope),
+			missed_window: null
+		});
+		await writeRemTriggerStateAtomic(input.stateDir, nextState);
+		return {
+			state: nextState,
+			dispatched: true
+		};
+	}
+	await appendAuditEntryStrict(auditStateDir, {
+		event: "rem_failed",
+		resultStatus: "error",
+		scope,
+		details: {
+			outcome: "dispatch-failed",
+			cause,
+			correlation_id: correlationId,
+			source: "gateway-trigger"
+		}
+	});
+	return {
+		state: nextState,
+		dispatched: true
+	};
+}
+async function dispatchRemWave(input, scope, correlationId) {
+	const started = performance.now();
+	const discovery = discoverySchema.parse(JSON.parse(await readFile(input.discoveryPath ?? getRemDiscoveryPath(), "utf8")));
+	const response = await fetch(`http://${REM_SIDECAR_HOST}:${discovery.port}${REM_RUN_PATH}`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			[REM_SIDECAR_TOKEN_HEADER]: discovery.token,
+			[REM_CORRELATION_ID_HEADER]: correlationId
+		},
+		body: JSON.stringify({
+			types: input.requestedOperations,
+			scope
+		}),
+		signal: AbortSignal.timeout(input.dispatchTimeoutMs ?? 1e4)
+	});
+	if (response.status !== 202) throw new Error(`REM sidecar returned HTTP ${response.status}`);
+	const body = z.object({
+		job_id: z.string().min(1),
+		waveId: z.string().min(1)
+	}).passthrough().parse(await response.json());
+	if (body.job_id !== body.waveId) throw new Error("REM sidecar confirmation identities disagree");
+	withLogContext$1({
+		operation_id: body.job_id,
+		job_id: body.job_id,
+		session_reference: scope,
+		external_reference: correlationId
+	}, () => {
+		log$1.info("REM dispatch accepted", {
+			outcome: "success",
+			job_id: body.job_id,
+			status: response.status,
+			duration_ms: performance.now() - started
+		}, {
+			event_name: "sidecar.trigger.dispatch.accepted",
+			file: "packages/memory/src/sidecar/rem-trigger.ts",
+			function: "dispatchRemWave",
+			site_id: "sidecar.trigger.dispatch.accepted"
+		});
+	});
+}
+async function applyCompletedBaselines(auditStateDir, triggerStateDir, state) {
+	let content;
+	try {
+		content = await readAuditTail(getAuditPath(auditStateDir));
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return state;
+		log$1.warn("REM completion audit could not be read", {
+			error,
+			outcome: "skipped",
+			reason_code: "audit_read_failed"
+		}, {
+			event_name: "sidecar.trigger.audit_read.failed",
+			file: "packages/memory/src/sidecar/rem-trigger.ts",
+			function: "applyCompletedBaselines",
+			site_id: "sidecar.trigger.audit_read.failed"
+		});
+		return state;
+	}
+	const dispatched = /* @__PURE__ */ new Map();
+	let nextState = state;
+	let malformedCount = 0;
+	for (const line of content.split("\n")) {
+		if (line.trim() === "") continue;
+		try {
+			const entry = JSON.parse(line);
+			const details = asRecord(entry["details"]);
+			const correlationId = details?.["correlation_id"];
+			const scope = entry["scope"];
+			if (entry["event"] === "rem_trigger_evaluated" && details?.["row"] === "dispatch" && typeof correlationId === "string" && typeof scope === "string") {
+				const trigger = details["trigger"];
+				const passAt = details["pass_at"];
+				const localDate = details["local_date"];
+				dispatched.set(correlationId, {
+					scope,
+					...trigger === "daily" || trigger === "volume" ? { trigger } : {},
+					...typeof passAt === "string" ? { passAt } : {},
+					...typeof localDate === "string" ? { localDate } : {}
+				});
+				continue;
+			}
+			if (entry["event"] === "rem_skipped" && typeof correlationId === "string") {
+				const skipped = dispatched.get(correlationId);
+				if (skipped && nextState.scopes[skipped.scope]?.attempts.identity === correlationId) nextState = replaceScopeState(nextState, skipped.scope, {
+					...requiredScopeState(nextState, skipped.scope),
+					attempts: {
+						identity: null,
+						count: 0
+					}
+				});
+				continue;
+			}
+			if (entry["event"] !== "rem_completed" || typeof correlationId !== "string") continue;
+			const dispatch = dispatched.get(correlationId);
+			if (dispatch === void 0 || state.scopes[dispatch.scope] === void 0 || entry["scope"] !== dispatch.scope) continue;
+			const currentScopeState = requiredScopeState(nextState, dispatch.scope);
+			let completedScopeState = {
+				...currentScopeState,
+				...dispatch.trigger === "daily" && isValidInstant(dispatch.passAt) ? { last_pass_at: dispatch.passAt } : {},
+				...dispatch.trigger === "daily" && isLocalDate(dispatch.localDate) ? { last_volume_pass_date: dispatch.localDate } : {},
+				...dispatch.trigger === "volume" && isLocalDate(dispatch.localDate) ? { last_volume_pass_date: dispatch.localDate } : {},
+				...currentScopeState.attempts.identity === correlationId ? { attempts: {
+					identity: null,
+					count: 0
+				} } : {}
+			};
+			const measured = asRecord(asRecord(details?.["stats"])?.["measured"]);
+			const rowsConsidered = measured?.["rows_considered"];
+			if (measured?.["pair_cap_binding"] === false && Number.isInteger(rowsConsidered) && Number(rowsConsidered) >= 0) completedScopeState = {
+				...completedScopeState,
+				last_covered_count: Number(rowsConsidered)
+			};
+			if (JSON.stringify(completedScopeState) === JSON.stringify(currentScopeState)) continue;
+			nextState = replaceScopeState(nextState, dispatch.scope, completedScopeState);
+		} catch {
+			malformedCount += 1;
+		}
+	}
+	if (malformedCount > 0) log$1.warn("Malformed REM audit records skipped", {
+		malformed_count: malformedCount,
+		outcome: "partial"
+	}, {
+		event_name: "sidecar.trigger.audit_records.skipped",
+		file: "packages/memory/src/sidecar/rem-trigger.ts",
+		function: "applyCompletedBaselines",
+		site_id: "sidecar.trigger.audit_records.skipped"
+	});
+	if (nextState !== state) await writeRemTriggerStateAtomic(triggerStateDir, nextState);
+	return nextState;
+}
+async function readAuditTail(auditPath) {
+	const handle = await open(auditPath, "r");
+	try {
+		const size = (await handle.stat()).size;
+		const bytesToRead = Math.min(size, REM_COMPLETION_AUDIT_TAIL_BYTES);
+		if (bytesToRead === 0) return "";
+		const buffer = Buffer.alloc(bytesToRead);
+		const { bytesRead } = await handle.read(buffer, 0, bytesToRead, size - bytesToRead);
+		let content = buffer.subarray(0, bytesRead).toString("utf8");
+		if (size > bytesToRead) {
+			const firstLineEnd = content.indexOf("\n");
+			content = firstLineEnd === -1 ? "" : content.slice(firstLineEnd + 1);
+		}
+		return content;
+	} finally {
+		await handle.close();
+	}
+}
+function remAutomaticCorrelationId(trigger, scope, triggerKey) {
+	return `rem-auto-${trigger}-${createHash("sha256").update(JSON.stringify([
+		"rem-automatic-v1",
+		trigger,
+		scope,
+		triggerKey
+	])).digest("hex")}`;
+}
+/** The daily due time, pushed to the schedule after the last used-up local day. */
+function nextDailyDue(scopeState) {
+	const scheduled = computeRemDailyDue(scopeState.last_pass_at, scopeState.schedule_zone);
+	const volumeDate = scopeState.last_volume_pass_date;
+	if (volumeDate === null) return scheduled;
+	const parsed = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(volumeDate);
+	if (parsed === null) return scheduled;
+	const following = addCalendarDays({
+		year: Number(parsed[1]),
+		month: Number(parsed[2]),
+		day: Number(parsed[3])
+	}, 1);
+	const afterVolume = zonedInstant(scopeState.schedule_zone, following.year, following.month, following.day);
+	return afterVolume.getTime() > scheduled.getTime() ? afterVolume : scheduled;
+}
+function computeRemDailyDue(lastPassAt, scheduleZone) {
+	const lastPass = new Date(lastPassAt);
+	if (Number.isNaN(lastPass.getTime())) throw new Error("REM last pass time is invalid");
+	const localDate = localDateParts(lastPass, scheduleZone);
+	let due = zonedInstant(scheduleZone, localDate.year, localDate.month, localDate.day);
+	if (due.getTime() <= lastPass.getTime()) {
+		const nextDate = addCalendarDays(localDate, 1);
+		due = zonedInstant(scheduleZone, nextDate.year, nextDate.month, nextDate.day);
+	}
+	return due;
+}
+function zonedInstant(zone, year, month, day) {
+	const target = Date.UTC(year, month - 1, day, 3, 0, 0, 0);
+	let instant = target;
+	let firstExistingAfter;
+	for (let iteration = 0; iteration < 5; iteration++) {
+		const parts = zonedDateTimeParts(new Date(instant), zone);
+		const represented = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+		const adjustment = target - represented;
+		if (adjustment === 0) return new Date(instant);
+		if (represented > target && represented < (firstExistingAfter?.represented ?? Number.POSITIVE_INFINITY)) firstExistingAfter = {
+			instant,
+			represented
+		};
+		instant += adjustment;
+	}
+	if (firstExistingAfter !== void 0) return new Date(firstExistingAfter.instant);
+	throw new Error(`REM scheduled instant cannot be resolved in zone ${zone}`);
+}
+function localDateAt(instant, zone) {
+	const parts = localDateParts(instant, zone);
+	return `${parts.year.toString().padStart(4, "0")}-${parts.month.toString().padStart(2, "0")}-${parts.day.toString().padStart(2, "0")}`;
+}
+function localDateParts(instant, zone) {
+	const parts = zonedDateTimeParts(instant, zone);
+	return {
+		year: parts.year,
+		month: parts.month,
+		day: parts.day
+	};
+}
+function zonedDateTimeParts(instant, zone) {
+	const values = {};
+	const formatter = new Intl.DateTimeFormat("en-CA", {
+		timeZone: zone,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hourCycle: "h23"
+	});
+	for (const part of formatter.formatToParts(instant)) if (part.type !== "literal") values[part.type] = Number(part.value);
+	const year = values["year"];
+	const month = values["month"];
+	const day = values["day"];
+	const hour = values["hour"];
+	const minute = values["minute"];
+	const second = values["second"];
+	if ([
+		year,
+		month,
+		day,
+		hour,
+		minute,
+		second
+	].some((value) => value === void 0)) throw new Error(`REM schedule zone ${zone} did not produce complete date parts`);
+	return {
+		year: Number(year),
+		month: Number(month),
+		day: Number(day),
+		hour: Number(hour),
+		minute: Number(minute),
+		second: Number(second)
+	};
+}
+function addCalendarDays(date, days) {
+	const instant = new Date(Date.UTC(date.year, date.month - 1, date.day + days));
+	return {
+		year: instant.getUTCFullYear(),
+		month: instant.getUTCMonth() + 1,
+		day: instant.getUTCDate()
+	};
+}
+function growthDetails(candidateCount, coveredCount, threshold) {
+	const growth = candidateCount - coveredCount;
+	return {
+		candidate_count: candidateCount,
+		last_covered_count: coveredCount,
+		delta: growth,
+		threshold,
+		remaining: Math.max(0, threshold - growth)
+	};
+}
+async function recordDecision(stateDir, scope, resultStatus, details) {
+	await appendAuditEntryStrict(stateDir, {
+		event: "rem_trigger_evaluated",
+		resultStatus,
+		...scope === void 0 ? {} : { scope },
+		details
+	});
+}
+function requiredScopeState(state, scope) {
+	const scopeState = state.scopes[scope];
+	if (scopeState === void 0) throw new Error(`REM trigger state missing scope ${scope}`);
+	return scopeState;
+}
+function replaceScopeState(state, scope, scopeState) {
+	return {
+		version: 1,
+		scopes: {
+			...state.scopes,
+			[scope]: scopeState
+		}
+	};
+}
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function isValidInstant(value) {
+	return value !== void 0 && !Number.isNaN(new Date(value).getTime());
+}
+function isLocalDate(value) {
+	return value !== void 0 && /^\d{4}-\d{2}-\d{2}$/u.test(value);
+}
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/store/maintenance.ts
+/** @file maintenance.ts
+* @purpose Ordered maintenance pass: integrity check, outbox drain, usage-event retention, FTS
+*   merge, planner statistics, backup, REM trigger check. Each job runs on its own interval.
+* @boundary Owns the gateway maintenance timer; integrity failures are logged without blocking storage.
+* @see backup.ts, memory-telemetry-outbox.ts, sqlite-runtime.ts.
+*/
+const log = createLogger("sno-station-mem:maintenance");
+const DAY_MS = 864e5;
+/**
+* Usage events ('recall'/'inject') older than this are pruned from the
+* `nodix_memory_events` ledger. MUST stay >= the purge-safety recall lookback
+* (RECENT_RECALL_WINDOW_MS, 30 d) — coupled by a unit test — so retention can
+* never erase evidence the cascade-purge preview depends on. Lifecycle events
+* are never pruned (database-enforced by the guarded delete trigger).
+*/
+const MEMORY_EVENTS_USAGE_RETENTION_MS = 90 * DAY_MS;
+/** Quarantined outbox rows older than this are deleted by the maintenance pass. */
+const OUTBOX_QUARANTINE_RETENTION_MS = 30 * DAY_MS;
+/** The first tick runs shortly after boot, so every job gets near-boot coverage. */
+const MAINTENANCE_FIRST_TICK_DELAY_MS = 6e4;
+/** Each job's own cadence; see the MAINTENANCE section of config/index.ts. */
+const MAINTENANCE_INTERVALS = {
+	integrity: INTEGRITY_CHECK_INTERVAL_MS,
+	"usage-outbox": USAGE_OUTBOX_INTERVAL_MS,
+	"usage-retention": USAGE_EVENT_RETENTION_INTERVAL_MS,
+	"fts-merge": FTS_MERGE_INTERVAL_MS,
+	"planner-statistics": PLANNER_STATISTICS_INTERVAL_MS,
+	backup: BACKUP_INTERVAL_MS,
+	"rem-trigger": REM_TRIGGER_CHECK_INTERVAL_MS
+};
+const ALL_MAINTENANCE_JOBS = new Set(Object.keys(MAINTENANCE_INTERVALS));
+/** Every job on one interval — what the sidecar's maintenance-interval override asks for. */
+function uniformMaintenanceIntervals(intervalMs) {
+	return Object.fromEntries([...ALL_MAINTENANCE_JOBS].map((job) => [job, intervalMs]));
+}
+const OUTBOX_DRAIN_BUDGET_MS = 3e4;
+const RETENTION_DELETE_BATCH = 5e3;
+const RETENTION_PRUNE_BUDGET_MS = 5e3;
+const FTS_MERGE_MAX_ITERATIONS = 10;
+function integrityMessages(rawDb, table) {
+	const pragma = table ? `integrity_check('${table}')` : "integrity_check";
+	return rawDb.pragma(pragma).map((row) => row["integrity_check"]).filter((value) => typeof value === "string");
+}
+function isCleanIntegrityResult(messages) {
+	return messages.length === 1 && messages[0] === "ok";
+}
+function hashInventoryRows(hash, rawDb, table) {
+	hash.update(`${table}\0`);
+	const rows = rawDb.prepare(`SELECT rowid, * FROM ${table} ORDER BY rowid`).iterate();
+	for (const row of rows) hash.update(JSON.stringify(row)).update("\0");
+}
+function sourceInventory(rawDb) {
+	const hash = createHash("sha256");
+	hashInventoryRows(hash, rawDb, "nodix_memories");
+	hashInventoryRows(hash, rawDb, "nodix_memory_chunks");
+	return hash.digest("hex");
+}
+function isDerivedFtsOnlyFailure(rawDb) {
+	const fullMessages = integrityMessages(rawDb);
+	if (isCleanIntegrityResult(fullMessages) || fullMessages.some((message) => !/fts5:.*nodix_memory_chunks_fts/i.test(message))) return false;
+	if (!isCleanIntegrityResult(integrityMessages(rawDb, "nodix_memories"))) return false;
+	if (!isCleanIntegrityResult(integrityMessages(rawDb, "nodix_memory_chunks"))) return false;
+	try {
+		rawDb.exec("INSERT INTO nodix_memory_chunks_fts(nodix_memory_chunks_fts, rank) VALUES('integrity-check', 1)");
+		return false;
+	} catch {
+		return true;
+	}
+}
+function recordIntegrityAudit(stateDir, decision, resultStatus, details) {
+	appendAuditEntry(stateDir, {
+		event: "storage_integrity",
+		resultStatus,
+		decision,
+		details
+	});
+}
+function tryRecoverDerivedFts(deps) {
+	return deps.store.sqlite.runRecoveryOperation((rawDb) => recoverDerivedFts(deps, rawDb));
+}
+function recoverDerivedFts(deps, rawDb) {
+	let inventoryBefore;
+	try {
+		if (!isDerivedFtsOnlyFailure(rawDb)) {
+			recordIntegrityAudit(deps.stateDir, "retained", "error", { reason: "integrity failure is not provably confined to the derived FTS index" });
+			return false;
+		}
+		inventoryBefore = sourceInventory(rawDb);
+	} catch (error) {
+		recordIntegrityAudit(deps.stateDir, "retained", "error", { reason: error instanceof Error ? error.message : String(error) });
+		return false;
+	}
+	recordIntegrityAudit(deps.stateDir, "rebuild_started", "ok");
+	log.warn("rebuilding derived FTS index after verified derived-only integrity failure", void 0, {
+		event_name: "sno_station_mem.maintenance.rebuilding.derived.fts.index.after.verified.derived.only.integrity.fai",
+		file: "packages/memory/src/store/maintenance.ts",
+		function: "recoverDerivedFts",
+		site_id: "maintenance.recoverDerivedFts.753697bd94"
+	});
+	try {
+		rawDb.exec("INSERT INTO nodix_memory_chunks_fts(nodix_memory_chunks_fts) VALUES('rebuild')");
+		if (sourceInventory(rawDb) !== inventoryBefore) throw new Error("source inventory changed during derived FTS rebuild");
+		runIntegrityCheck(rawDb);
+		rawDb.exec("INSERT INTO nodix_memory_chunks_fts(nodix_memory_chunks_fts, rank) VALUES('integrity-check', 1)");
+		recordIntegrityAudit(deps.stateDir, "recovered", "ok");
+		log.info("derived FTS index rebuilt and integrity reverified", void 0, {
+			event_name: "sno_station_mem.maintenance.derived.fts.index.rebuilt.and.integrity.reverified",
+			file: "packages/memory/src/store/maintenance.ts",
+			function: "recoverDerivedFts",
+			site_id: "maintenance.recoverDerivedFts.2cf5f62053"
+		});
+		return true;
+	} catch (error) {
+		recordIntegrityAudit(deps.stateDir, "retained", "error", { reason: error instanceof Error ? error.message : String(error) });
+		log.error("derived FTS recovery failed; storage continues serving", { error }, {
+			event_name: "memory.storage.fts.recovery.failed",
+			file: "packages/memory/src/store/maintenance.ts",
+			function: "recoverDerivedFts",
+			site_id: "maintenance.recoverDerivedFts.c07ad948a2"
+		});
+		return false;
+	}
+}
+/** Records an integrity failure without blocking subsequent SQL. */
+function recordIntegrityFailure(deps, error) {
+	const message = error instanceof Error ? error.message : String(error);
+	try {
+		recordMemoryTelemetryIncident(deps.store.sqlite, {
+			incidentType: "storage_integrity_check_failed",
+			severity: "error",
+			message: "database integrity check failed; storage continues serving",
+			payload: {
+				error_code: "integrity_check_failed",
+				last_error: message.slice(0, 500)
+			}
+		});
+	} catch {}
+	log.error("storage continues serving after integrity failure", { error: message }, {
+		event_name: "memory.storage.integrity.failed",
+		file: "packages/memory/src/store/maintenance.ts",
+		function: "recordIntegrityFailure",
+		site_id: "maintenance.failClosed.dd7955e647"
+	});
+}
+/**
+* Bounded catch-up: a backlog left by a maintenance gap or a first-time
+* retention rollout can be far larger than one tick's budget. Deleting it
+* all synchronously would block the gateway event loop for minutes (host
+* adversarial review 2026-07-13). Leave the remainder for later ticks —
+* safe, since usage-event retention is a hygiene job, not a safety
+* invariant (the purge-safety recall lookback only needs the last 30 days,
+* well inside this 90-day window either way).
+*/
+function pruneExpiredUsageEvents(store, now, budgetMs) {
+	const cutoff = now - MEMORY_EVENTS_USAGE_RETENTION_MS;
+	const statement = store.sqlite.prepare(`DELETE FROM nodix_memory_events
+		 WHERE id IN (
+		   SELECT id FROM nodix_memory_events
+		   WHERE event_type IN ('recall', 'inject') AND timestamp_ms < ?
+		   LIMIT ${RETENTION_DELETE_BATCH}
+		 )`);
+	const deadline = Date.now() + budgetMs;
+	let pruned = 0;
+	do {
+		const changes = statement.run(cutoff).changes ?? 0;
+		pruned += changes;
+		if (changes === 0) break;
+	} while (Date.now() < deadline);
+	return pruned;
+}
+function mergeFtsSegments(store) {
+	if (!store.hasFtsSupport) return;
+	const statement = store.sqlite.prepare("INSERT INTO nodix_memory_chunks_fts(nodix_memory_chunks_fts, rank) VALUES('merge', 500)");
+	for (let i = 0; i < FTS_MERGE_MAX_ITERATIONS; i++) if ((statement.run().changes ?? 0) === 0) break;
+}
+/** Full integrity check and optional repair; reads and writes stay available. */
+function sweepIntegrity(deps, report) {
+	const started = Date.now();
+	try {
+		const sweep = deps.integrityCheck ?? runIntegrityCheck;
+		deps.store.sqlite.runRecoveryOperation((raw) => raw.transaction(() => {
+			if (deps.store.hasFtsSupport) raw.prepare("SELECT rowid FROM nodix_memory_chunks_fts LIMIT 1").get();
+			sweep(raw);
+		}).deferred());
+	} catch (error) {
+		recordIntegrityFailure(deps, error);
+		report.integrityRecovery = tryRecoverDerivedFts(deps) ? "recovered" : "retained";
+	} finally {
+		report.integrityMs = Date.now() - started;
+	}
+}
+/** Runs the requested maintenance jobs independently. */
+function runMaintenancePass(deps, due = ALL_MAINTENANCE_JOBS, backupIntervalMs = BACKUP_INTERVAL_MS) {
+	const report = {
+		aborted: false,
+		integrityRecovery: "none",
+		integrityMs: 0,
+		outboxFlushed: 0,
+		quarantinePruned: 0,
+		usageEventsPruned: 0,
+		backupPath: void 0
+	};
+	if (deps.store.closed) {
+		report.aborted = true;
+		log.info("stopping maintenance for closed or replaced runtime", { dbPath: deps.dbPath }, {
+			event_name: "sno_station_mem.maintenance.stopping.maintenance.for.closed.or.replaced.runtime",
+			file: "packages/memory/src/store/maintenance.ts",
+			function: "runMaintenancePass",
+			site_id: "maintenance.runMaintenancePass.747b7cbef0"
+		});
+		return report;
+	}
+	deps.store.db.retrySetup();
+	deps.store.hasFtsSupport = deps.store.sqlite.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'nodix_memory_chunks_fts' LIMIT 1").get() !== void 0;
+	const now = Date.now();
+	if (due.has("integrity")) sweepIntegrity(deps, report);
+	if (deps.usageOutbox && due.has("usage-outbox")) try {
+		report.outboxFlushed = deps.usageOutbox.drainPending(OUTBOX_DRAIN_BUDGET_MS).inserted;
+		report.quarantinePruned = deps.usageOutbox.pruneQuarantined(now - OUTBOX_QUARANTINE_RETENTION_MS);
+	} catch (error) {
+		log.warn("outbox maintenance failed", { error }, {
+			event_name: "sno_station_mem.maintenance.outbox.maintenance.failed",
+			file: "packages/memory/src/store/maintenance.ts",
+			function: "runMaintenancePass",
+			site_id: "maintenance.runMaintenancePass.c72575daaa"
+		});
+	}
+	if (due.has("usage-retention")) try {
+		report.usageEventsPruned = pruneExpiredUsageEvents(deps.store, now, deps.retentionPruneBudgetMs ?? RETENTION_PRUNE_BUDGET_MS);
+	} catch (error) {
+		log.warn("usage-event retention failed", { error }, {
+			event_name: "sno_station_mem.maintenance.usage.event.retention.failed",
+			file: "packages/memory/src/store/maintenance.ts",
+			function: "runMaintenancePass",
+			site_id: "maintenance.runMaintenancePass.ef7a1e225c"
+		});
+	}
+	if (due.has("fts-merge")) try {
+		mergeFtsSegments(deps.store);
+	} catch (error) {
+		log.warn("fts merge failed", { error }, {
+			event_name: "sno_station_mem.maintenance.fts.merge.failed",
+			file: "packages/memory/src/store/maintenance.ts",
+			function: "runMaintenancePass",
+			site_id: "maintenance.runMaintenancePass.90f01cc543"
+		});
+	}
+	if (due.has("planner-statistics")) try {
+		deps.store.sqlite.exec("PRAGMA analysis_limit=400");
+		deps.store.sqlite.exec("PRAGMA optimize");
+	} catch (error) {
+		log.warn("pragma optimize failed", { error }, {
+			event_name: "sno_station_mem.maintenance.pragma.optimize.failed",
+			file: "packages/memory/src/store/maintenance.ts",
+			function: "runMaintenancePass",
+			site_id: "maintenance.runMaintenancePass.3a7c9e73cf"
+		});
+	}
+	if (due.has("backup")) try {
+		if (isBackupDue(deps.backupDir, now, backupIntervalMs)) report.backupPath = runBackup(deps.dbPath, deps.backupDir);
+	} catch (error) {
+		log.warn("periodic backup failed", { error }, {
+			event_name: "sno_station_mem.maintenance.periodic.backup.failed",
+			file: "packages/memory/src/store/maintenance.ts",
+			function: "runMaintenancePass",
+			site_id: "maintenance.runMaintenancePass.11beb09895"
+		});
+	}
+	log.info("maintenance pass complete", {
+		integrityMs: report.integrityMs,
+		outboxFlushed: report.outboxFlushed,
+		quarantinePruned: report.quarantinePruned,
+		usageEventsPruned: report.usageEventsPruned
+	}, {
+		event_name: "sno_station_mem.maintenance.maintenance.pass.complete",
+		file: "packages/memory/src/store/maintenance.ts",
+		function: "runMaintenancePass",
+		site_id: "maintenance.runMaintenancePass.6a1e15dc18"
+	});
+	return report;
+}
+/**
+* Gateway maintenance schedule: first tick MAINTENANCE_FIRST_TICK_DELAY_MS after boot, then every
+* tickMs. Each tick runs the jobs whose own interval has elapsed since they last ran; the first
+* tick runs all of them. Stops when its store closes.
+*/
+function startMaintenanceTimer(deps, tickMs = MAINTENANCE_TICK_MS, firstTickDelayMs = MAINTENANCE_FIRST_TICK_DELAY_MS, intervals = MAINTENANCE_INTERVALS) {
+	let interval = null;
+	let firstTick = null;
+	let inFlight = false;
+	let stopped = false;
+	const lastRun = /* @__PURE__ */ new Map();
+	const slackMs = tickMs / 2;
+	const dueJobs = (now) => {
+		const due = /* @__PURE__ */ new Set();
+		for (const job of ALL_MAINTENANCE_JOBS) {
+			const last = lastRun.get(job);
+			if (job === "backup" || last === void 0 || now - last >= intervals[job] - slackMs) due.add(job);
+		}
+		return due;
+	};
+	const stop = () => {
+		stopped = true;
+		if (firstTick) {
+			clearTimeout(firstTick);
+			firstTick = null;
+		}
+		if (interval) {
+			clearInterval(interval);
+			interval = null;
+		}
+	};
+	const tick = () => {
+		if (inFlight) {
+			log.warn("skipping maintenance tick: previous pass still in flight", void 0, {
+				event_name: "sno_station_mem.maintenance.skipping.maintenance.tick.previous.pass.still.in.flight",
+				file: "packages/memory/src/store/maintenance.ts",
+				function: "tick",
+				site_id: "maintenance.tick.e111b66415"
+			});
+			return;
+		}
+		if (deps.store.closed) {
+			log.info("stopping maintenance for closed or replaced runtime", { dbPath: deps.dbPath }, {
+				event_name: "sno_station_mem.maintenance.stopping.maintenance.for.closed.or.replaced.runtime",
+				file: "packages/memory/src/store/maintenance.ts",
+				function: "tick",
+				site_id: "maintenance.tick.6bd3e0102c"
+			});
+			stop();
+			return;
+		}
+		inFlight = true;
+		const now = Date.now();
+		const due = dueJobs(now);
+		for (const job of due) lastRun.set(job, now);
+		(async () => {
+			try {
+				if (runMaintenancePass(deps, due, intervals.backup - slackMs).aborted) {
+					stop();
+					return;
+				}
+				if (!due.has("rem-trigger")) return;
+				await evaluateRemAutomaticTriggers({
+					database: deps.store.sqlite,
+					stateDir: deps.stateDir,
+					auditStateDir: getSnoStationMemStateDir(),
+					requestedOperations: deps.remSettings.requestedOperations,
+					tickEnabled: deps.remSettings.tickEnabled,
+					modelCalls: deps.modelCalls,
+					mode: deps.mode,
+					hasConnectedHost: deps.hasConnectedHost,
+					now: deps.remClock,
+					volumeThreshold: deps.remVolumeThreshold
+				});
+			} catch (error) {
+				log.warn("maintenance pass threw", { error }, {
+					event_name: "sno_station_mem.maintenance.maintenance.pass.threw",
+					file: "packages/memory/src/store/maintenance.ts",
+					function: "<anonymous callback>",
+					site_id: "maintenance.<anonymous callback>.f90713a2e3"
+				});
+			} finally {
+				inFlight = false;
+			}
+		})();
+	};
+	firstTick = setTimeout(() => {
+		firstTick = null;
+		tick();
+		if (stopped) return;
+		interval = setInterval(tick, tickMs);
+		interval.unref?.();
+	}, firstTickDelayMs);
+	firstTick.unref?.();
+	log.debug("maintenance timer started", {
+		tickMs,
+		intervals
+	}, {
+		event_name: "sno_station_mem.maintenance.maintenance.timer.started",
+		file: "packages/memory/src/store/maintenance.ts",
+		function: "startMaintenanceTimer",
+		site_id: "maintenance.startMaintenanceTimer.06c1e98584"
+	});
+	return { stop };
+}
+//#endregion
+export { MAINTENANCE_FIRST_TICK_DELAY_MS, MAINTENANCE_INTERVALS, MEMORY_EVENTS_USAGE_RETENTION_MS, OUTBOX_QUARANTINE_RETENTION_MS, runMaintenancePass, startMaintenanceTimer, uniformMaintenanceIntervals };