@snoai/memory 0.0.0-stage → 1.0.0

package/dist/server-BPAY4NTG.js

@@ -0,0 +1,1410 @@
+import { $ as appendAuditEntryStrict, Ct as ModelCallRefusedError, H as parseRemOperationType, V as REM_BUILT_OPERATION_TYPES, at as readJsonlLines, tt as getAuditPath } from "./rem-batch-executor-Cbm5gfSe.js";
+import { a as MEMORY_ROUTES, n as MEMORY_DEFAULT_SKIN_ID, o as MEMORY_SKIN_HEADER, r as MEMORY_ERROR_STATUS, s as memoryMethod } from "./routes-Ce7SQKec.js";
+import { C as getSidecarSocketPath, _ as readRemOperationalConfig, b as getDiscoveryPath, c as REM_SIDECAR_ORIGIN, d as getRemChassisJournalPath, f as getRemDiscoveryPath, i as REM_JOBS_PATH_PREFIX, p as getRemJobJournalPath, r as REM_CORRELATION_ID_HEADER, rr as MEMORY_SHUTDOWN_TIMEOUT_MS, s as REM_SIDECAR_HOST, u as REM_SOURCE, v as readRemTestHoldMs, w as getSnoStationMemStateDir, x as getPrincipal, y as SettingsUnavailableError } from "./config-tSrvLXgV.js";
+import { n as remNeedsHost, r as ContractError } from "./rem-trigger-BTxkcjgT.js";
+import { setImmediate } from "node:timers/promises";
+import { createLogger, currentLogContext, effectiveLogLevel, emitDiagnostic } from "@snoai/utils/logger";
+import path from "node:path";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { z } from "zod";
+import { randomBytes, randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { withLogContext as withLogContext$1 } from "@snoai/utils/log-context";
+import { createServer } from "node:http";
+import { createConnection, createServer as createServer$1 } from "node:net";
+import locking from "fs-ext";
+//#region src/contract/discovery.ts
+const discoverySchema = z.strictObject({
+	pid: z.number().int().positive(),
+	port: z.number().int().min(1).max(65535),
+	token: z.string().regex(/^[a-f0-9]{64}$/)
+});
+async function readDiscovery() {
+	let text;
+	try {
+		text = await readFile(getDiscoveryPath(), "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return void 0;
+		throw new ContractError("sidecar-unreachable");
+	}
+	try {
+		return discoverySchema.parse(JSON.parse(text));
+	} catch {
+		throw new ContractError("sidecar-unreachable");
+	}
+}
+//#endregion
+//#region src/sidecar/request-body.ts
+var PayloadTooLargeError = class extends Error {
+	constructor() {
+		super("payload_too_large");
+	}
+};
+function readRequestBody(request, signal) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let bytes = 0;
+		const cleanup = () => {
+			request.off("data", onData);
+			request.off("end", onEnd);
+			request.off("error", onError);
+			request.off("aborted", onAborted);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		const onError = (error) => {
+			cleanup();
+			request.resume();
+			reject(error);
+		};
+		const onAbort = () => onError(signal?.reason);
+		const onAborted = () => onError(/* @__PURE__ */ new Error("request_aborted"));
+		const onEnd = () => {
+			cleanup();
+			resolve(Buffer.concat(chunks).toString("utf8"));
+		};
+		const onData = (chunk) => {
+			const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+			bytes += buffer.length;
+			if (bytes > 8388608) {
+				onError(new PayloadTooLargeError());
+				return;
+			}
+			chunks.push(buffer);
+		};
+		request.on("data", onData);
+		request.once("end", onEnd);
+		request.once("error", onError);
+		request.once("aborted", onAborted);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		if (signal?.aborted) onAbort();
+	});
+}
+//#endregion
+//#region src/sidecar/memory-routes.ts
+const log$2 = createLogger("sno-station-mem:memory-routes");
+async function serveMemoryRoute(request, response, pathname, openPool, activeTasks) {
+	const method = memoryMethod(pathname);
+	if (!method || request.method !== "POST") return false;
+	const skinId = request.headers[MEMORY_SKIN_HEADER];
+	let timer;
+	const controller = new AbortController();
+	const abort = () => controller.abort(new ContractError("timeout"));
+	let rejectDeadline;
+	if (method !== "capture") response.once("close", abort);
+	try {
+		const deadline = new Promise((_, reject) => {
+			rejectDeadline = () => reject(controller.signal.reason);
+			controller.signal.addEventListener("abort", rejectDeadline, { once: true });
+			timer = setTimeout(abort, MEMORY_ROUTES[method].timeoutMs);
+		});
+		const task = (async () => {
+			const body = await readBody(request, controller.signal);
+			controller.signal.throwIfAborted();
+			const pool = await openPool();
+			controller.signal.throwIfAborted();
+			return pool.invoke(method, body, typeof skinId === "string" && skinId.trim() ? skinId : MEMORY_DEFAULT_SKIN_ID, controller.signal);
+		})();
+		const boundedTask = Promise.race([task, deadline]);
+		const completion = Object.assign(task.then(() => void 0, () => void 0), {
+			label: currentLogContext().operation_id ?? method,
+			method
+		});
+		activeTasks.add(completion);
+		completion.finally(() => activeTasks.delete(completion));
+		const result = await boundedTask;
+		response.writeHead(200, { "content-type": "application/json" });
+		response.end(JSON.stringify(result));
+	} catch (error) {
+		if (error instanceof SettingsUnavailableError) {
+			response.writeHead(503, { "content-type": "application/json" });
+			response.end(JSON.stringify({
+				degraded: true,
+				error: error.message,
+				reason: error.message
+			}));
+			return true;
+		}
+		log$2.error("Memory engine request failed", {
+			method,
+			skinId,
+			error,
+			error_message: error instanceof Error ? error.message : String(error),
+			error_stack: error instanceof Error ? error.stack : void 0
+		}, {
+			event_name: "memory.sidecar.request.failed",
+			file: "packages/memory/src/sidecar/memory-routes.ts",
+			function: "serveMemoryRoute",
+			site_id: "memory.sidecar.request.failed"
+		});
+		if (error instanceof PayloadTooLargeError) {
+			response.writeHead(413, { "content-type": "application/json" });
+			response.end(JSON.stringify({ error: "payload_too_large" }));
+			return true;
+		}
+		const reason = error instanceof ContractError ? error.reason : "engine-failed";
+		const status = MEMORY_ERROR_STATUS[reason];
+		if (!response.headersSent) response.writeHead(status, { "content-type": "application/json" });
+		response.end(JSON.stringify({
+			degraded: true,
+			reason
+		}));
+	} finally {
+		clearTimeout(timer);
+		response.off("close", abort);
+		if (rejectDeadline) controller.signal.removeEventListener("abort", rejectDeadline);
+	}
+	return true;
+}
+async function readBody(request, signal) {
+	const body = await readRequestBody(request, signal);
+	try {
+		return JSON.parse(body);
+	} catch {
+		throw new ContractError("invalid-input");
+	}
+}
+//#endregion
+//#region src/sidecar/rem-chassis-journal.ts
+/** @file rem-chassis-journal.ts
+* @purpose Persists reason-bearing REM chassis stage outcomes as append-only JSONL.
+* @boundary Sidecar runner journal only; job-state transitions remain in RemJobStore.
+*/
+var RemChassisJournal = class {
+	journalPath;
+	operationQueue = Promise.resolve();
+	constructor(journalPath) {
+		this.journalPath = journalPath;
+	}
+	appendJournal(jobId, jobType, entry) {
+		return this.queueAppend(jobId, jobType, entry);
+	}
+	appendJournalWithCorrelation(jobId, jobType, correlationId, entry) {
+		return this.queueAppend(jobId, jobType, entry, correlationId);
+	}
+	queueAppend(jobId, jobType, entry, correlationId) {
+		const result = this.operationQueue.then(() => this.append(jobId, jobType, entry, correlationId));
+		this.operationQueue = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	async append(jobId, jobType, entry, correlationId) {
+		const parent = path.dirname(this.journalPath);
+		await mkdir(parent, { recursive: true });
+		const journalAlreadyExisted = existsSync(this.journalPath);
+		const handle = await open(this.journalPath, "a");
+		try {
+			const record = {
+				job_id: jobId,
+				job_type: jobType,
+				...correlationId === void 0 ? {} : { correlation_id: correlationId },
+				stage: entry.stage,
+				outcome: entry.outcome,
+				pairs_scanned: entry.pairsScanned,
+				verdicts: entry.verdicts,
+				actions_applied: entry.actionsApplied,
+				...entry.reason === void 0 ? {} : { reason: entry.reason },
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			await handle.writeFile(`${JSON.stringify(record)}\n`, "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		if (!journalAlreadyExisted) await syncDirectory$2(parent);
+	}
+};
+async function syncDirectory$2(directory) {
+	if (process.platform === "win32") return;
+	const handle = await open(directory, "r");
+	try {
+		await handle.sync();
+	} finally {
+		await handle.close();
+	}
+}
+//#endregion
+//#region src/sidecar/rem-job-store.ts
+/** @file rem-job-store.ts
+* @purpose Persists append-only REM job state transitions.
+* @boundary Durable local JSONL journal used by the standalone REM sidecar.
+*/
+const log$1 = createLogger("sno-station-mem:rem-jobs");
+const remJobStateSchema = z.enum([
+	"queued",
+	"running",
+	"done",
+	"failed",
+	"skipped"
+]);
+const remJobMeasurementsSchema = z.object({
+	rows_considered: z.number().int().nonnegative(),
+	pairs_built: z.number().int().nonnegative().optional(),
+	pair_cap_binding: z.boolean().optional(),
+	model_calls: z.number().int().nonnegative(),
+	model_tokens: z.number().int().nonnegative(),
+	wall_ms: z.number().int().nonnegative()
+}).strict();
+const remJobStatsSchema = z.object({
+	operations: z.number().int().nonnegative(),
+	applied_count: z.number().int().nonnegative().optional(),
+	actionable_candidate_count: z.number().int().nonnegative().optional(),
+	applied_fraction: z.number().min(0).max(1).nullable().optional(),
+	scan: z.object({
+		scope: z.string().min(1),
+		candidate_count: z.number().int().nonnegative(),
+		stamped_skipped_count: z.number().int().nonnegative().optional(),
+		actionable_candidate_count: z.number().int().nonnegative().optional()
+	}).strict().optional(),
+	parse_failure_count: z.number().int().nonnegative().optional(),
+	top_refusal_reasons: z.array(z.string().min(1)).max(2).optional(),
+	measured: remJobMeasurementsSchema.optional(),
+	by_operation: z.array(z.object({
+		operation: z.string().min(1),
+		applied_count: z.number().int().nonnegative(),
+		actionable_candidate_count: z.number().int().nonnegative(),
+		candidate_count: z.number().int().nonnegative(),
+		parse_failure_count: z.number().int().nonnegative(),
+		top_refusal_reasons: z.array(z.string().min(1)).max(2),
+		measured: remJobMeasurementsSchema
+	}).strict()).min(1).optional()
+}).strict();
+function parseRemJobStats(value) {
+	const parsed = remJobStatsSchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+}
+const remWaveJobSchema = z.object({
+	payloadVersion: z.literal(1),
+	waveId: z.string().min(1),
+	correlationId: z.string().min(1),
+	scope: z.string().min(1),
+	requestedOperations: z.array(z.string().min(1)).min(1),
+	state: remJobStateSchema,
+	startedAt: z.string().datetime().nullable(),
+	finishedAt: z.string().datetime().nullable(),
+	stats: remJobStatsSchema,
+	error: z.string().min(1).optional()
+}).strict();
+const legacyJobSchema = z.object({
+	job_id: z.string().min(1),
+	state: remJobStateSchema,
+	type: z.string().min(1),
+	scope: z.string().min(1),
+	started_at: z.string().datetime().nullable(),
+	finished_at: z.string().datetime().nullable(),
+	stats: remJobStatsSchema,
+	error: z.string().min(1).optional(),
+	correlation_id: z.string().min(1)
+}).strict();
+const OPERATION_ORDER = [
+	"rem-replace",
+	"rem-update",
+	"rem-distill",
+	"rem-retire"
+];
+var RemJobStore = class RemJobStore {
+	journalPath;
+	onDurableTransition;
+	jobs = /* @__PURE__ */ new Map();
+	persistedJobs = /* @__PURE__ */ new Set();
+	mergeKeys = /* @__PURE__ */ new Map();
+	operationQueue = Promise.resolve();
+	constructor(journalPath, onDurableTransition) {
+		this.journalPath = journalPath;
+		this.onDurableTransition = onDurableTransition;
+	}
+	static async open(journalPath, onDurableTransition = () => void 0) {
+		const store = new RemJobStore(journalPath, onDurableTransition);
+		await store.migrateLegacyJournal().catch((error) => store.reportFailure(error));
+		await store.load();
+		return store;
+	}
+	isPersisted(jobId) {
+		return this.persistedJobs.has(jobId);
+	}
+	get(jobId) {
+		const job = this.jobs.get(jobId);
+		return job === void 0 ? void 0 : toRemJob(job);
+	}
+	nonTerminalJobs() {
+		return Array.from(this.jobs.values()).filter((job) => job.state === "queued" || job.state === "running").map(toRemJob);
+	}
+	async createQueued(type, scope, correlationId) {
+		return this.enqueue(async () => {
+			const requestedOperations = canonicalOperations(typeof type === "string" ? [type] : type);
+			if (requestedOperations.length === 0) throw new Error("REM wave requires at least one supported operation");
+			const mergeKey = `${correlationId}\0${scope}`;
+			const existingId = this.mergeKeys.get(mergeKey);
+			const existing = existingId === void 0 ? void 0 : this.jobs.get(existingId);
+			if (existing !== void 0 && existing.state === "queued") {
+				const mergedOperations = canonicalOperations([...existing.requestedOperations, ...requestedOperations]);
+				if (mergedOperations.length === existing.requestedOperations.length) return {
+					created: false,
+					job: toRemJob(existing)
+				};
+				const updated = remWaveJobSchema.parse({
+					...existing,
+					requestedOperations: mergedOperations
+				});
+				const durable = await this.persist(updated);
+				this.jobs.set(updated.waveId, updated);
+				if (durable) this.onDurableTransition(toRemJob(updated));
+				return {
+					created: false,
+					job: toRemJob(updated)
+				};
+			}
+			if (existing !== void 0 && existing.state !== "skipped" && requestedOperations.every((operation) => existing.requestedOperations.includes(operation))) return {
+				created: false,
+				job: toRemJob(existing)
+			};
+			const job = remWaveJobSchema.parse({
+				payloadVersion: 1,
+				waveId: `rem-wave-${randomUUID()}`,
+				correlationId,
+				scope,
+				requestedOperations,
+				state: "queued",
+				startedAt: null,
+				finishedAt: null,
+				stats: { operations: 0 }
+			});
+			const durable = await this.persist(job);
+			this.jobs.set(job.waveId, job);
+			this.mergeKeys.set(mergeKey, job.waveId);
+			const outward = toRemJob(job);
+			if (durable) this.onDurableTransition(outward);
+			return {
+				created: true,
+				job: outward
+			};
+		});
+	}
+	async transition(jobId, transition) {
+		return this.enqueue(async () => {
+			const current = this.jobs.get(jobId);
+			if (!current) throw new Error(`REM job not found: ${jobId}`);
+			const next = remWaveJobSchema.parse({
+				...current,
+				state: transition.state,
+				...transition.started_at === void 0 ? {} : { startedAt: transition.started_at },
+				...transition.finished_at === void 0 ? {} : { finishedAt: transition.finished_at },
+				...transition.stats === void 0 ? {} : { stats: transition.stats },
+				...transition.error === void 0 ? {} : { error: transition.error }
+			});
+			const durable = await this.persist(next);
+			this.jobs.set(jobId, next);
+			const outward = toRemJob(next);
+			if (durable) this.onDurableTransition(outward);
+			return outward;
+		});
+	}
+	async load() {
+		if (!existsSync(this.journalPath)) return;
+		const bytes = await readFile(this.journalPath);
+		const lines = bytes.toString("utf8").split("\n");
+		const endsWithNewline = bytes.length === 0 || bytes[bytes.length - 1] === 10;
+		for (const [index, line] of lines.entries()) {
+			if (!line) continue;
+			if (!endsWithNewline && index === lines.length - 1) {
+				const lastNewline = bytes.lastIndexOf(10);
+				await this.truncateJournal(lastNewline < 0 ? 0 : lastNewline + 1);
+				return;
+			}
+			try {
+				const parsed = JSON.parse(line);
+				const job = remWaveJobSchema.parse(parsed);
+				this.jobs.set(job.waveId, job);
+				this.mergeKeys.set(`${job.correlationId}\0${job.scope}`, job.waveId);
+			} catch (error) {
+				log$1.error("rem.journal.failed", {
+					path: this.journalPath,
+					line: index + 1,
+					error
+				}, {
+					event_name: "rem.journal.failed",
+					file: "packages/memory/src/sidecar/rem-job-store.ts",
+					function: "load",
+					site_id: "rem-job-store.load.invalid-line"
+				});
+			}
+		}
+	}
+	async migrateLegacyJournal() {
+		const legacyPath = path.join(path.dirname(this.journalPath), "rem-jobs.jsonl");
+		if (!existsSync(legacyPath)) return;
+		const latest = /* @__PURE__ */ new Map();
+		for await (const line of readJsonlLines(legacyPath)) try {
+			const parsed = JSON.parse(line);
+			const job = legacyJobSchema.parse(parsed);
+			latest.set(job.job_id, job);
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			this.reportFailure(reason);
+		}
+		const interrupted = [...latest.values()].filter((job) => job.state === "queued" || job.state === "running");
+		if (interrupted.length > 0) {
+			const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+			const handle = await open(legacyPath, "a");
+			try {
+				for (const job of interrupted) await handle.writeFile(`${JSON.stringify({
+					...job,
+					state: "failed",
+					finished_at: finishedAt,
+					error: "sidecar_upgrade_interrupted"
+				})}\n`, "utf8");
+				await handle.sync();
+			} finally {
+				await handle.close();
+			}
+		}
+		await rename(legacyPath, path.join(path.dirname(legacyPath), "rem-jobs.v0.jsonl"));
+	}
+	reportFailure(error) {
+		log$1.error("rem.journal.failed", {
+			error,
+			path: this.journalPath
+		}, {
+			event_name: "rem.journal.failed",
+			file: "packages/memory/src/sidecar/rem-job-store.ts",
+			function: "reportFailure",
+			site_id: "rem.journal.failed"
+		});
+	}
+	async persist(job) {
+		this.persistedJobs.delete(job.waveId);
+		await this.append(job);
+		this.persistedJobs.add(job.waveId);
+		return true;
+	}
+	async truncateJournal(length) {
+		const handle = await open(this.journalPath, "r+");
+		try {
+			await handle.truncate(length);
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+	}
+	async append(job) {
+		const parent = path.dirname(this.journalPath);
+		await mkdir(parent, { recursive: true });
+		const journalAlreadyExisted = existsSync(this.journalPath);
+		const handle = await open(this.journalPath, "a");
+		try {
+			await handle.writeFile(`${JSON.stringify(job)}\n`, "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		if (!journalAlreadyExisted) await syncDirectory$1(parent);
+	}
+	enqueue(operation) {
+		const result = this.operationQueue.then(operation);
+		this.operationQueue = result.then(() => void 0, () => void 0);
+		return result;
+	}
+};
+function canonicalOperations(operations) {
+	const unique = new Set(operations);
+	return OPERATION_ORDER.filter((operation) => unique.has(operation));
+}
+function toRemJob(job) {
+	return {
+		job_id: job.waveId,
+		state: job.state,
+		type: job.requestedOperations[0] ?? "rem-replace",
+		scope: job.scope,
+		started_at: job.startedAt,
+		finished_at: job.finishedAt,
+		stats: job.stats,
+		...job.error === void 0 ? {} : { error: job.error },
+		correlation_id: job.correlationId,
+		requested_operations: [...job.requestedOperations]
+	};
+}
+async function syncDirectory$1(directory) {
+	if (process.platform === "win32") return;
+	const handle = await open(directory, "r");
+	try {
+		await handle.sync();
+	} finally {
+		await handle.close();
+	}
+}
+//#endregion
+//#region src/sidecar/server.ts
+/** @file server.ts
+* @purpose Runs the loopback HTTP surface and empty asynchronous REM executor.
+* @boundary Sno CLI requests, durable REM job state, and the existing local audit writer.
+*/
+const log = createLogger("sno-station-mem:rem-sidecar");
+const runRequestSchema = z.union([z.object({
+	type: z.string().min(1),
+	scope: z.string().trim().min(1)
+}).strict(), z.object({
+	types: z.array(z.string().min(1)).min(1),
+	scope: z.string().trim().min(1)
+}).strict()]);
+var HttpError = class extends Error {
+	status;
+	code;
+	constructor(status, code) {
+		super(code);
+		this.status = status;
+		this.code = code;
+	}
+};
+var DuplicateSidecarError = class extends Error {};
+async function socketIsLive(socketPath) {
+	return new Promise((resolve, reject) => {
+		const socket = createConnection(socketPath);
+		socket.once("connect", () => {
+			socket.destroy();
+			resolve(true);
+		});
+		socket.once("error", (error) => {
+			socket.destroy();
+			if ("code" in error && (error.code === "ECONNREFUSED" || error.code === "ENOENT")) resolve(false);
+			else reject(error);
+		});
+	});
+}
+async function bindSidecarSocket() {
+	const socketPath = getSidecarSocketPath();
+	await mkdir(path.dirname(socketPath), {
+		recursive: true,
+		mode: 448
+	});
+	const directory = await open(path.dirname(socketPath), "r");
+	try {
+		for (;;) try {
+			locking.flockSync(directory.fd, "exnb");
+			break;
+		} catch (error) {
+			if (!(error instanceof Error && "code" in error && error.code === "EAGAIN")) throw error;
+			await setImmediate();
+		}
+		const guard = createServer$1((socket) => socket.destroy());
+		for (;;) try {
+			await new Promise((resolve, reject) => {
+				guard.once("error", reject);
+				guard.listen(socketPath, () => {
+					guard.removeListener("error", reject);
+					resolve();
+				});
+			});
+			return guard;
+		} catch (error) {
+			if (!(error instanceof Error && "code" in error && error.code === "EADDRINUSE")) throw error;
+			if (await socketIsLive(socketPath)) {
+				const discovery = await readDiscovery().catch(() => void 0);
+				emitDiagnostic("info", "sidecar.duplicate.exit", { pid: discovery?.pid }, {
+					event_name: "sidecar.duplicate.exit",
+					file: "packages/memory/src/sidecar/server.ts",
+					function: "bindSidecarSocket",
+					site_id: "sidecar.duplicate.exit"
+				});
+				throw new DuplicateSidecarError();
+			}
+			await rm(socketPath, { force: true });
+		}
+	} finally {
+		await directory.close();
+	}
+}
+async function startRemSidecar() {
+	const guard = await bindSidecarSocket();
+	const exitCleanup = () => {
+		guard.close();
+	};
+	process.once("exit", exitCleanup);
+	const releaseGuard = async () => {
+		await new Promise((resolve) => guard.close(() => resolve()));
+		process.removeListener("exit", exitCleanup);
+	};
+	try {
+		const sidecar = await startOwnedRemSidecar();
+		return {
+			port: sidecar.port,
+			async stop() {
+				let drained;
+				try {
+					({drained} = await sidecar.stop());
+				} finally {
+					if (drained) drained.then(releaseGuard);
+					else await releaseGuard();
+				}
+			}
+		};
+	} catch (error) {
+		await releaseGuard();
+		throw error;
+	}
+}
+async function startOwnedRemSidecar() {
+	let stopping = false;
+	let currentMemory;
+	let openingMemory;
+	let settingsError;
+	const memory = {
+		current: () => currentMemory,
+		async open() {
+			if (currentMemory) return currentMemory;
+			if (settingsError) throw settingsError;
+			openingMemory ??= import("./memory-runtime-BZtREuwW.js").then((module) => module.MemoryRuntimePool.open()).then((pool) => {
+				currentMemory = pool;
+				if (stopping) pool.stopTimers();
+				return pool;
+			}).catch((error) => {
+				if (error instanceof SettingsUnavailableError) settingsError = error;
+				throw error;
+			}).finally(() => {
+				openingMemory = void 0;
+			});
+			return openingMemory;
+		}
+	};
+	const token = randomBytes(32).toString("hex");
+	const holdMs = readRemTestHoldMs();
+	const chassisJournal = new RemChassisJournal(getRemChassisJournalPath());
+	const onDurableTransition = (job) => {
+		log.info("job_transition_durable", {
+			event: "job_transition_durable",
+			job_id: job.job_id,
+			state: job.state,
+			correlation_id: job.correlation_id,
+			durable: true
+		}, {
+			event_name: "sno_station_mem.server.job.transition.durable",
+			file: "packages/memory/src/sidecar/server.ts",
+			function: "<anonymous callback>",
+			site_id: "server.<anonymous callback>.5eb5a60e6b"
+		});
+	};
+	const store = RemJobStore.open(getRemJobJournalPath(), onDurableTransition);
+	const pendingTimers = /* @__PURE__ */ new Map();
+	const startPendingStarts = () => {
+		for (const start of pendingTimers.values()) start();
+	};
+	const activeTasks = /* @__PURE__ */ new Set();
+	const pendingRequests = /* @__PURE__ */ new Set();
+	const server = createServer((request, response) => {
+		const started = performance.now();
+		const operationId = `rem-http-${randomUUID()}`;
+		const context = {};
+		const requestLabel = `${operationId} ${request.method} ${requestPath(request)}`;
+		pendingRequests.add(requestLabel);
+		let requestLogged = false;
+		const recordRequest = (cancelled = false) => {
+			if (requestLogged) return;
+			requestLogged = true;
+			pendingRequests.delete(requestLabel);
+			let outcome = "success";
+			if (cancelled) outcome = "cancelled";
+			else if (response.statusCode >= 500) outcome = "failed";
+			else if (response.statusCode >= 400) outcome = "refused";
+			withLogContext$1({
+				operation_id: operationId,
+				job_id: context.job_id,
+				external_reference: context.correlation_id
+			}, () => {
+				log[outcome === "failed" ? "error" : "info"]("http_request", {
+					outcome,
+					method: request.method ?? "UNKNOWN",
+					path: requestPath(request),
+					status: response.statusCode,
+					duration_ms: Math.max(0, Math.round(performance.now() - started)),
+					...context
+				}, {
+					event_name: "sno_station_mem.server.http.request",
+					file: "packages/memory/src/sidecar/server.ts",
+					function: "recordRequest",
+					site_id: "server.<anonymous callback>.47c4662916"
+				});
+			});
+		};
+		response.once("finish", () => recordRequest());
+		response.once("close", () => recordRequest(!response.writableFinished));
+		withLogContext$1({ operation_id: operationId }, () => routeRequest(request, response, store, chassisJournal, holdMs, pendingTimers, activeTasks, context, memory, () => stopping).catch((error) => {
+			if (error instanceof SettingsUnavailableError) {
+				context.error_code = error.message;
+				if (!response.headersSent) sendJson(response, 503, { error: error.message });
+				else response.end();
+				return;
+			}
+			let httpError = new HttpError(500, "internal_error");
+			if (error instanceof HttpError) httpError = error;
+			else if (error instanceof PayloadTooLargeError) httpError = new HttpError(413, "payload_too_large");
+			context.error_code = httpError.code;
+			log.error("request_failed", { error }, {
+				event_name: "sno_station_mem.server.request.failed",
+				file: "packages/memory/src/sidecar/server.ts",
+				function: "<anonymous callback>",
+				site_id: "server.<anonymous callback>.a7a2656a08"
+			});
+			if (!response.headersSent) sendJson(response, httpError.status, { error: httpError.code });
+			else response.end();
+		}));
+	});
+	const jobs = await store;
+	const recoveryJobs = jobs.nonTerminalJobs();
+	await listen(server);
+	const address = server.address();
+	if (!address || typeof address === "string") {
+		server.close();
+		throw new Error("REM sidecar did not bind a TCP address");
+	}
+	const discoveryPath = getRemDiscoveryPath();
+	const discovery = {
+		port: address.port,
+		token,
+		pid: process.pid
+	};
+	let discoveryTimer;
+	let discoveryAttempt = 0;
+	const publishDiscovery = async () => {
+		discoveryAttempt++;
+		try {
+			await writeDiscovery(discoveryPath, discovery);
+			if (discoveryAttempt > 1) log.info("sidecar.discovery.published", { attempt: discoveryAttempt }, {
+				event_name: "sidecar.discovery.published",
+				file: "packages/memory/src/sidecar/server.ts",
+				function: "publishDiscovery",
+				site_id: "sidecar.discovery.published"
+			});
+		} catch (error) {
+			log.error("sidecar.discovery.failed", {
+				attempt: discoveryAttempt,
+				error
+			}, {
+				event_name: "sidecar.discovery.failed",
+				file: "packages/memory/src/sidecar/server.ts",
+				function: "publishDiscovery",
+				site_id: "sidecar.discovery.failed"
+			});
+			if (!stopping) discoveryTimer = setTimeout(() => {
+				discoveryPublication = publishDiscovery();
+			}, 5e3);
+		}
+	};
+	let discoveryPublication = publishDiscovery();
+	await discoveryPublication;
+	memory.open().catch((error) => {
+		if (!(error instanceof SettingsUnavailableError)) reportSidecarFailure("memory startup", error);
+	});
+	const recovery = (async () => {
+		const jobIds = await recoverInterruptedJobs(jobs, await readCompletedJobStats(new Set(recoveryJobs.map((job) => job.job_id))), recoveryJobs);
+		for (const jobId of jobIds) await runChassisJob(jobs, chassisJournal, jobId, 0, await memory.open());
+	})().catch((error) => reportSidecarFailure("recovery", error));
+	activeTasks.add(Object.assign(recovery, { label: "rem-recovery" }));
+	recovery.finally(() => activeTasks.delete(recovery));
+	const exitCleanup = () => {
+		removeOwnedDiscoverySync(discoveryPath, token);
+	};
+	process.once("exit", exitCleanup);
+	log.info("started", {
+		host: REM_SIDECAR_HOST,
+		port: address.port,
+		pid: process.pid
+	}, {
+		event_name: "sno_station_mem.server.started",
+		file: "packages/memory/src/sidecar/server.ts",
+		function: "startLockedRemSidecar",
+		site_id: "server.startLockedRemSidecar.96a92b085b"
+	});
+	return {
+		port: address.port,
+		async stop() {
+			const started = performance.now();
+			let cleanedUp = false;
+			let phase = "http_requests";
+			let timer;
+			stopping = true;
+			clearTimeout(discoveryTimer);
+			process.removeListener("exit", exitCleanup);
+			try {
+				startPendingStarts();
+				currentMemory?.stopTimers();
+				const cleanup = (async () => {
+					await closeServer(server);
+					startPendingStarts();
+					phase = "active_tasks";
+					await Promise.allSettled(activeTasks);
+					phase = "runtime_open";
+					await openingMemory?.catch(() => void 0);
+					phase = "runtime_close";
+					await currentMemory?.close();
+					phase = "discovery";
+					await discoveryPublication;
+					return true;
+				})();
+				cleanedUp = await Promise.race([cleanup, new Promise((resolve) => {
+					timer = setTimeout(() => {
+						log.error("sidecar.shutdown.timeout", {
+							phase,
+							active_tasks: activeTasks.size,
+							pending_requests: [...pendingRequests],
+							running_tasks: [...activeTasks].map((task) => task.label ?? "rem")
+						}, {
+							event_name: "sidecar.shutdown.timeout",
+							file: "packages/memory/src/sidecar/server.ts",
+							function: "startRemSidecar.stop",
+							site_id: "sidecar.shutdown.timeout"
+						});
+						for (const task of activeTasks) withLogContext$1({ operation_id: task.label }, () => {
+							log.error("sidecar.shutdown.task.running", { method: task.method ?? "rem" }, {
+								event_name: "sidecar.shutdown.task.running",
+								file: "packages/memory/src/sidecar/server.ts",
+								function: "startRemSidecar.stop",
+								site_id: "sidecar.shutdown.task.running"
+							});
+						});
+						server.closeAllConnections();
+						currentMemory?.stopTimers();
+						resolve(false);
+					}, MEMORY_SHUTDOWN_TIMEOUT_MS);
+				})]);
+			} finally {
+				clearTimeout(timer);
+				await discoveryPublication;
+				await removeOwnedDiscovery(discoveryPath, token);
+				log[cleanedUp ? "info" : "error"]("REM sidecar cleanup completed", {
+					outcome: cleanedUp ? "success" : "failed",
+					duration_ms: performance.now() - started,
+					active_tasks: activeTasks.size
+				}, {
+					event_name: "sidecar.shutdown.completed",
+					file: "packages/memory/src/sidecar/server.ts",
+					function: "startRemSidecar.stop",
+					site_id: "sidecar.shutdown.completed"
+				});
+			}
+			return cleanedUp ? {} : { drained: Promise.allSettled(activeTasks).then(() => void 0) };
+		}
+	};
+}
+async function routeRequest(request, response, pendingStore, chassisJournal, holdMs, pendingTimers, activeTasks, context, memory, isStopping) {
+	const url = new URL(request.url ?? "/healthz", REM_SIDECAR_ORIGIN);
+	if (request.method === "GET" && url.pathname === "/healthz") {
+		try {
+			const runtime = await memory.open();
+			sendJson(response, 200, {
+				status: runtime.modelPreparationError ? "degraded" : "ok",
+				...runtime.modelPreparationError && { error: runtime.modelPreparationError },
+				log_level: effectiveLogLevel(),
+				principal: getPrincipal(),
+				storePath: runtime.storePath,
+				accessCounters: runtime.counters
+			});
+		} catch (error) {
+			if (!(error instanceof SettingsUnavailableError)) throw error;
+			sendJson(response, 503, {
+				status: "error",
+				error: error.message
+			});
+		}
+		return;
+	}
+	if (url.pathname.startsWith("/v1/")) {
+		if (await serveMemoryRoute(request, response, url.pathname, () => memory.open(), activeTasks)) return;
+	}
+	if (request.method === "POST" && url.pathname === "/rem/run") {
+		const correlationId = readCorrelationId(request) ?? `rem-corr-${randomUUID()}`;
+		context.correlation_id = correlationId;
+		const raw = await readJsonBody(request);
+		const parsedInput = runRequestSchema.safeParse(raw);
+		if (!parsedInput.success) throw new HttpError(400, "invalid_request");
+		const input = parsedInput.data;
+		const types = "types" in input ? input.types : [input.type];
+		const requestedTypes = types.filter((type) => REM_BUILT_OPERATION_TYPES.some((operation) => operation === type));
+		const unknownTypes = types.filter((type) => !requestedTypes.includes(type));
+		if (unknownTypes.length) {
+			reportSidecarFailure("unsupported_rem_type", new Error(unknownTypes.join(",")));
+			context.error_code = "unsupported_rem_type";
+			sendJson(response, 400, {
+				error: "unsupported_rem_type",
+				unknownTypes
+			});
+			return;
+		}
+		const store = await pendingStore;
+		const runtime = await memory.open();
+		if (remNeedsHost(runtime.config.mode, runtime.settings.modelCalls) && !runtime.connectedRemPort()) {
+			context.error_code = "no host model connected";
+			sendJson(response, 503, { error: "no host model connected" });
+			return;
+		}
+		let allocation;
+		try {
+			allocation = await store.createQueued(requestedTypes, input.scope, correlationId);
+		} catch (error) {
+			if (errorMessage(error) === "wave_closed") {
+				context.error_code = "wave_closed";
+				sendJson(response, 409, { error: "wave_closed" });
+				return;
+			}
+			throw error;
+		}
+		const { created, job } = allocation;
+		context.job_id = job.job_id;
+		log.info("job_allocated", {
+			created,
+			event: "job_allocated",
+			job_id: job.job_id,
+			type: job.type,
+			scope: job.scope,
+			correlation_id: job.correlation_id
+		}, {
+			event_name: "sno_station_mem.server.job.allocated",
+			file: "packages/memory/src/sidecar/server.ts",
+			function: "routeRequest",
+			site_id: "server.routeRequest.0ea180a77c"
+		});
+		if (created) {
+			const delayMs = "types" in input ? 0 : 100;
+			const { promise: task, resolve, reject } = Promise.withResolvers();
+			activeTasks.add(Object.assign(task, { label: job.job_id }));
+			task.catch((error) => reportSidecarFailure("rem_run", error)).finally(() => activeTasks.delete(task));
+			const start = () => {
+				clearTimeout(timer);
+				pendingTimers.delete(timer);
+				runChassisJob(store, chassisJournal, job.job_id, holdMs, runtime).then(resolve, reject);
+			};
+			const timer = setTimeout(start, delayMs);
+			pendingTimers.set(timer, start);
+			if (isStopping()) start();
+		}
+		sendJson(response, 202, {
+			job_id: job.job_id,
+			waveId: job.job_id
+		});
+		return;
+	}
+	if (request.method === "GET" && url.pathname.startsWith("/rem/jobs/")) {
+		const store = await pendingStore;
+		const jobId = url.pathname.slice(REM_JOBS_PATH_PREFIX.length);
+		const job = store.get(jobId);
+		context.job_id = jobId;
+		context.correlation_id = readCorrelationId(request) ?? job?.correlation_id;
+		if (!job) {
+			context.error_code = "job_not_found";
+			sendJson(response, 404, { error: "job_not_found" });
+			return;
+		}
+		sendJson(response, 200, job);
+		return;
+	}
+	context.error_code = "not_found";
+	sendJson(response, 404, { error: "not_found" });
+}
+async function runChassisJob(store, journal, waveId, holdMs, runtime) {
+	const queued = store.get(waveId);
+	if (queued === void 0) throw new Error(`REM wave not found: ${waveId}`);
+	const resuming = queued.state === "running";
+	return withLogContext$1({
+		operation_id: queued.job_id,
+		job_id: queued.job_id,
+		session_reference: queued.scope,
+		external_reference: queued.correlation_id
+	}, async () => {
+		const started = performance.now();
+		let persistence = "unavailable";
+		let completion;
+		let failed = false;
+		let failure;
+		const requestedOperations = queued.requested_operations.flatMap((operation) => {
+			const parsed = parseRemOperationType(operation);
+			return parsed === void 0 ? [] : [parsed];
+		});
+		let writesApplied = false;
+		try {
+			if (remNeedsHost(runtime.config.mode, runtime.settings.modelCalls) && !runtime.connectedRemPort()) {
+				await skipNonTerminalJob(store, queued.job_id, "no host model connected");
+				return;
+			}
+			const running = resuming ? queued : await store.transition(queued.job_id, {
+				state: "running",
+				started_at: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			if (!resuming) await auditRem("rem_triggered", running);
+			if (holdMs > 0) await new Promise((resolvePromise) => setTimeout(resolvePromise, holdMs));
+			const configuration = readRemOperationalConfig();
+			const enabledBySettings = runtime.settings.rem.operations;
+			const enabledOperations = [];
+			const cleanRefusalReasons = [];
+			for (const operation of requestedOperations) {
+				let reason;
+				if (!isBuiltOperation(operation)) reason = `not-built:${operation}`;
+				else if (configuration.operations[operation] && enabledBySettings.includes(operation)) {
+					enabledOperations.push(operation);
+					continue;
+				} else reason = `switched-off:${operation}`;
+				cleanRefusalReasons.push(reason);
+				await appendChassisRefusal(journal, queued, operation, "refused", reason);
+			}
+			const { runRemProductionOrderedWave } = await import("./rem-batch-executor-bc0IFlp2.js");
+			const result = enabledOperations.length === 0 ? {
+				decision: "allow",
+				reasonCode: null,
+				waveId: queued.job_id,
+				actionsApplied: 0,
+				actionableCandidateCount: 0,
+				appliedFraction: null,
+				candidateCount: 0,
+				stampedSkippedCount: 0,
+				parseFailureCount: 0,
+				topRefusalReasons: [],
+				measurements: {
+					rowsConsidered: 0,
+					pairsBuilt: 0,
+					pairCapBinding: false,
+					modelCalls: 0,
+					modelTokens: 0,
+					wallMs: 0
+				},
+				perOperation: []
+			} : await runRemProductionOrderedWave({
+				mode: runtime.config.mode,
+				settings: runtime.settings,
+				agentPort: runtime.connectedRemPort(),
+				scope: queued.scope,
+				waveId: queued.job_id,
+				requestedOperations: enabledOperations
+			});
+			if (result.decision === "refuse") {
+				const operation = enabledOperations[0] ?? "rem-replace";
+				const reason = result.reasonCode;
+				await appendChassisRefusal(journal, queued, operation, "failed", reason);
+				throw new Error(reason);
+			}
+			writesApplied = true;
+			const completionStats = {
+				operations: result.actionsApplied,
+				applied_count: result.actionsApplied,
+				actionable_candidate_count: result.actionableCandidateCount,
+				applied_fraction: result.appliedFraction,
+				scan: {
+					scope: queued.scope,
+					candidate_count: result.candidateCount,
+					stamped_skipped_count: result.stampedSkippedCount,
+					actionable_candidate_count: result.actionableCandidateCount
+				},
+				parse_failure_count: result.parseFailureCount,
+				top_refusal_reasons: [...cleanRefusalReasons, ...result.topRefusalReasons].slice(0, 2),
+				measured: {
+					rows_considered: result.measurements.rowsConsidered,
+					pairs_built: result.measurements.pairsBuilt,
+					pair_cap_binding: result.measurements.pairCapBinding,
+					model_calls: result.measurements.modelCalls,
+					model_tokens: result.measurements.modelTokens,
+					wall_ms: result.measurements.wallMs
+				},
+				...result.perOperation.length === 0 ? {} : { by_operation: result.perOperation.map(({ operation, ...operationResult }) => ({
+					operation,
+					applied_count: operationResult.actionsApplied,
+					actionable_candidate_count: operationResult.actionableCandidateCount,
+					candidate_count: operationResult.candidateCount,
+					parse_failure_count: operationResult.parseFailureCount,
+					top_refusal_reasons: operationResult.topRefusalReasons,
+					measured: {
+						rows_considered: operationResult.measurements.rowsConsidered,
+						pairs_built: operationResult.measurements.pairsBuilt,
+						pair_cap_binding: operationResult.measurements.pairCapBinding,
+						model_calls: operationResult.measurements.modelCalls,
+						model_tokens: operationResult.measurements.modelTokens,
+						wall_ms: operationResult.measurements.wallMs
+					}
+				})) }
+			};
+			completion = completionStats;
+			persistence = await persistCompletedJob(store, running, completionStats);
+			for (const operationResult of result.perOperation) try {
+				await journal.appendJournalWithCorrelation(running.job_id, operationResult.operation, running.correlation_id, {
+					stage: operationResult.operation,
+					outcome: operationResult.actionsApplied > 0 ? "done" : "no-action",
+					pairsScanned: operationResult.measurements.pairsBuilt,
+					verdicts: operationResult.actionableCandidateCount,
+					actionsApplied: operationResult.actionsApplied
+				});
+			} catch (error) {
+				log.error("job_completion_journal_failed", {
+					error,
+					job_id: running.job_id,
+					job_type: operationResult.operation,
+					correlation_id: running.correlation_id
+				}, {
+					event_name: "sno_station_mem.server.job.completion.journal.failed",
+					file: "packages/memory/src/sidecar/server.ts",
+					function: "runChassisJob",
+					site_id: "server.runChassisJob.e7639bd8fc"
+				});
+			}
+		} catch (error) {
+			failed = true;
+			failure = error;
+			if (!writesApplied) {
+				if (error instanceof ModelCallRefusedError) await skipNonTerminalJob(store, queued.job_id, error.reason, error.callId, error.destination);
+				else await failNonTerminalJob(store, queued.job_id, errorMessage(error));
+			}
+		} finally {
+			let outcome = "empty-success";
+			if (failed) outcome = writesApplied ? "partial" : "failed";
+			else if (persistence === "unavailable") outcome = "partial";
+			else if ((completion?.applied_count ?? 0) > 0) outcome = "success";
+			log[failed || persistence === "unavailable" ? "error" : "info"]("REM job completed", {
+				outcome,
+				job_id: queued.job_id,
+				basis: persistence,
+				applied_count: completion?.applied_count ?? (writesApplied ? null : 0),
+				candidate_count: completion?.scan?.candidate_count ?? null,
+				parse_failure_count: completion?.parse_failure_count ?? null,
+				duration_ms: performance.now() - started,
+				...failure === void 0 ? {} : { error: failure }
+			}, {
+				event_name: "sidecar.job.completed",
+				file: "packages/memory/src/sidecar/server.ts",
+				function: "runChassisJob",
+				site_id: "sidecar.job.completed"
+			});
+		}
+	});
+}
+async function persistCompletedJob(store, job, stats) {
+	const auditPersisted = await auditRem("rem_completed", job, { stats });
+	await store.transition(job.job_id, {
+		state: "done",
+		finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+		stats
+	});
+	if (store.isPersisted(job.job_id)) return "job_journal";
+	if (auditPersisted) return "completed_audit";
+	reportSidecarFailure("completion-persistence", /* @__PURE__ */ new Error("completed work has no durable completion receipt"));
+	return "unavailable";
+}
+async function appendChassisRefusal(journal, job, jobType, outcome, reason) {
+	await journal.appendJournalWithCorrelation(job.job_id, jobType, job.correlation_id, {
+		stage: jobType,
+		outcome,
+		pairsScanned: 0,
+		verdicts: 0,
+		actionsApplied: 0,
+		reason
+	});
+}
+function isBuiltOperation(jobType) {
+	return REM_BUILT_OPERATION_TYPES.some((operation) => operation === jobType);
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function failNonTerminalJob(store, jobId, reason) {
+	const current = store.get(jobId);
+	if (!current || current.state !== "queued" && current.state !== "running") return;
+	try {
+		await auditRem("rem_failed", current, { error: reason });
+		await store.transition(jobId, {
+			state: "failed",
+			finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+			error: reason
+		});
+	} catch (error) {
+		log.error("job_failure_audit_failed", {
+			error,
+			job_id: jobId
+		}, {
+			event_name: "sno_station_mem.server.job.failure.audit.failed",
+			file: "packages/memory/src/sidecar/server.ts",
+			function: "failNonTerminalJob",
+			site_id: "server.failNonTerminalJob.cf84e07c6d"
+		});
+	}
+}
+async function skipNonTerminalJob(store, jobId, reason, callId, destination) {
+	const current = store.get(jobId);
+	if (!current || current.state !== "queued" && current.state !== "running") return;
+	await auditRem("rem_skipped", current, {
+		reason,
+		call_id: callId,
+		destination
+	});
+	await store.transition(jobId, {
+		state: "skipped",
+		finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+		error: reason
+	});
+}
+async function recoverInterruptedJobs(store, completedJobStats, jobs) {
+	const resumableJobIds = [];
+	for (const job of jobs) try {
+		const stats = completedJobStats.get(job.job_id);
+		if (stats !== void 0) {
+			await store.transition(job.job_id, {
+				state: "done",
+				finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+				stats
+			});
+			continue;
+		}
+		if (job.state === "running") {
+			log.warn("job_recovery_resuming", {
+				job_id: job.job_id,
+				correlation_id: job.correlation_id,
+				reason: "completion_receipt_missing_replay_same_wave"
+			}, {
+				event_name: "sno_station_mem.server.job.recovery.resuming",
+				file: "packages/memory/src/sidecar/server.ts",
+				function: "recoverInterruptedJobs",
+				site_id: "server.recoverInterruptedJobs.15309ea841"
+			});
+			resumableJobIds.push(job.job_id);
+			continue;
+		}
+		await auditRem("rem_failed", job, { error: "sidecar_restart" });
+		await store.transition(job.job_id, {
+			state: "failed",
+			finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+			error: "sidecar_restart"
+		});
+	} catch (error) {
+		reportSidecarFailure("job-recovery", error);
+	}
+	return resumableJobIds;
+}
+async function readCompletedJobStats(wantedJobs) {
+	const completed = /* @__PURE__ */ new Map();
+	for await (const line of readJsonlLines(getAuditPath(getSnoStationMemStateDir()))) {
+		if (line.length === 0) continue;
+		try {
+			const entry = JSON.parse(line);
+			if (!isRecord(entry) || entry["event"] !== "rem_completed") continue;
+			const details = entry["details"];
+			if (!isRecord(details) || typeof details["job_id"] !== "string" || !wantedJobs.has(details["job_id"])) continue;
+			const type = details["type"];
+			if (typeof type !== "string" || parseRemOperationType(type) === void 0) continue;
+			const stats = parseRemJobStats(details["stats"]);
+			if (stats === void 0) continue;
+			completed.set(details["job_id"], stats);
+		} catch {}
+	}
+	return completed;
+}
+async function auditRem(event, job, extra = {}) {
+	return appendAuditEntryStrict(getSnoStationMemStateDir(), {
+		event,
+		scope: job.scope,
+		resultStatus: event === "rem_skipped" ? "skipped" : event === "rem_failed" ? "error" : "ok",
+		details: {
+			type: job.type,
+			scope: job.scope,
+			job_id: job.job_id,
+			correlation_id: job.correlation_id,
+			source: REM_SOURCE,
+			stats: { operations: 0 },
+			...extra
+		}
+	});
+}
+function readCorrelationId(request) {
+	const value = request.headers[REM_CORRELATION_ID_HEADER];
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+async function readJsonBody(request) {
+	const body = await readRequestBody(request);
+	try {
+		return JSON.parse(body);
+	} catch {
+		throw new HttpError(400, "invalid_request");
+	}
+}
+function sendJson(response, status, body) {
+	const payload = JSON.stringify(body);
+	response.writeHead(status, {
+		"Content-Type": "application/json",
+		"Content-Length": Buffer.byteLength(payload)
+	});
+	response.end(payload);
+}
+function requestPath(request) {
+	try {
+		return new URL(request.url ?? "/healthz", REM_SIDECAR_ORIGIN).pathname;
+	} catch {
+		return request.url ?? "/healthz";
+	}
+}
+async function listen(server) {
+	await new Promise((resolvePromise, reject) => {
+		server.once("error", reject);
+		server.listen(0, REM_SIDECAR_HOST, () => {
+			server.removeListener("error", reject);
+			resolvePromise();
+		});
+	});
+}
+async function closeServer(server) {
+	if (!server.listening) return;
+	await new Promise((resolvePromise, reject) => {
+		server.close((error) => error ? reject(error) : resolvePromise());
+	});
+}
+async function writeDiscovery(discoveryPath, discovery) {
+	const parent = path.dirname(discoveryPath);
+	await mkdir(parent, { recursive: true });
+	const temporaryPath = `${discoveryPath}.${randomUUID()}.tmp`;
+	const handle = await open(temporaryPath, "wx", 384);
+	try {
+		try {
+			await handle.writeFile(JSON.stringify(discovery), "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		await rename(temporaryPath, discoveryPath);
+		await syncDirectory(parent);
+	} finally {
+		await rm(temporaryPath, { force: true });
+	}
+}
+async function removeOwnedDiscovery(discoveryPath, token) {
+	if (!await discoveryBelongsTo(discoveryPath, token)) return;
+	await rm(discoveryPath, { force: true });
+	await syncDirectory(path.dirname(discoveryPath));
+}
+function removeOwnedDiscoverySync(discoveryPath, token) {
+	try {
+		if (JSON.parse(readFileSync(discoveryPath, "utf8")).token === token) rmSync(discoveryPath, { force: true });
+	} catch {}
+}
+async function discoveryBelongsTo(discoveryPath, token) {
+	if (!existsSync(discoveryPath)) return false;
+	try {
+		return JSON.parse(await readFile(discoveryPath, "utf8")).token === token;
+	} 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 isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function reportSidecarFailure(step, error) {
+	log.error("sidecar.operation.failed", {
+		step,
+		error
+	}, {
+		event_name: "sidecar.operation.failed",
+		file: "packages/memory/src/sidecar/server.ts",
+		function: "reportSidecarFailure",
+		site_id: "sidecar.operation.failed"
+	});
+}
+//#endregion
+export { DuplicateSidecarError, startRemSidecar };