@snoai/memory 1.2.8 → 1.2.10

package/dist/{retriever-ZoLvPRHq.js → retriever-BXQmJMh0.js}

@@ -1,6 +1,6 @@
 import { CHUNKING_VERSION, DEFAULT_BM25_WEIGHT, DEFAULT_RECALL_LIFECYCLE, DEFAULT_RERANK_MODEL, DEFAULT_RERANK_TIMEOUT_MS, DEFAULT_VECTOR_WEIGHT, IMPORTANCE_WEIGHT_BASE, LIGHTWEIGHT_COSINE_WEIGHT, LIGHTWEIGHT_FUSION_WEIGHT, LIGHTWEIGHT_RERANK_PENALTY, MMR_LAMBDA, RECENCY_WEIGHT, RERANK_BLEND_CROSS, RERANK_BLEND_VECTOR, TIME_DECAY_FLOOR, experimentCandidatePoolOverride, experimentMmrDisabled } from "./internal/config/index.js";
 import "./internal/engine/shared/types.js";
-import { RetrievalError } from "./internal/engine/shared/errors.js";
+import { EmbeddingError, RetrievalError } from "./internal/engine/shared/errors.js";
 import { o as isMemoryExpired, s as parseInsightMetadata } from "./memory-metadata-codec-DL1sbJiN.js";
 import { clamp01 } from "./internal/engine/shared/utils.js";
 import { i as memoryOperationSignal } from "./operation-cancellation-CTKWwNHk.js";
@@ -375,6 +375,19 @@ function collectParallelStage(results, key, fallbackIds) {
 }
 //#endregion
 //#region src/engine/retrieval/retriever-search-modes.ts
+/**
+* Ordinary long prose is chunked and averaged by the embedder. Text it cannot cut under the model's limit (a pasted log or hash
+* dump) is rejected, and would fail the whole recall, so only then is the query cut to the limit; keyword search still sees all of it.
+*/
+async function embedQuery(embedder, query) {
+	await embedder.warmup();
+	try {
+		return await embedder.embed(query);
+	} catch (error) {
+		if (!(error instanceof EmbeddingError)) throw error;
+		return embedder.embed(embedder.truncateToTokens(query, 512));
+	}
+}
 Object.assign(MemoryRetriever.prototype, {
 	async aggregationComplete(context, trace) {
 		trace?.startStage("aggregation_evidence", []);
@@ -420,7 +433,7 @@ Object.assign(MemoryRetriever.prototype, {
 		return mapped;
 	},
 	async vectorOnly(context, trace) {
-		const vector = await this.embedder.embed(context.query);
+		const vector = await embedQuery(this.embedder, context.query);
 		this.throwIfAborted(context);
 		const searchLimit = this.config.temporalExpiry ? Math.max(this.config.candidatePoolSize, context.limit * 2) : context.limit;
 		trace?.startStage("vector_search", []);
@@ -463,7 +476,7 @@ Object.assign(MemoryRetriever.prototype, {
 	},
 	async precisionRecall(context, trace) {
 		trace?.startStage("embed_query", []);
-		const queryVector = await this.embedder.embed(context.query);
+		const queryVector = await embedQuery(this.embedder, context.query);
 		trace?.endStage([]);
 		this.throwIfAborted(context);
 		const bm25Query = context.query;

package/dist/{retriever-DQdyGlkr.d.ts → retriever-BpxV-0fB.d.ts}

@@ -1,13 +1,13 @@
-import { h as MemoryCategory, l as DecayScore, r as AggregationQuery, u as DecayableMemory, x as RetrievalResult, y as MemorySearchResult } from "./types-Del9J7UB.js";
-import { sn as RecallLifecycleConfig } from "./index-DL8AVj0Z.js";
+import { h as MemoryCategory, l as DecayScore, r as AggregationQuery, u as DecayableMemory, x as RetrievalResult, y as MemorySearchResult } from "./types-Ae3a8562.js";
+import { sn as RecallLifecycleConfig } from "./index-Pb9LrHgL.js";
 import { t as Embedder } from "./embedding-provider-client-vynZMuit.js";
 import "./trace-C1JxMfs-.js";
-import "./memory-metadata-codec-DcSqjbWR.js";
-import { K as RemFacetPolicy } from "./index-BO4RU_mc.js";
-import { C as MemoryStore } from "./memory-store-base-z593oJ4h.js";
-import "./store-DKndKig1.js";
-import { n as AccessTracker } from "./access-tracker-D1e-2-Bb.js";
-import { r as TierPromoter } from "./memory-tier-promoter-Z7jprFB7.js";
+import "./memory-metadata-codec-wVAuoKrG.js";
+import { K as RemFacetPolicy } from "./index-DPfJrOFD.js";
+import { C as MemoryStore } from "./memory-store-base-Bk2dOKED.js";
+import "./store-BDIAl2cc.js";
+import { n as AccessTracker } from "./access-tracker-BOPHSJjf.js";
+import { r as TierPromoter } from "./memory-tier-promoter-MkZPQ8u1.js";
 import "@snoai/utils/logger";
 //#region src/engine/retrieval/retrieval-trace.d.ts
 /** @file retrieval-trace.ts

package/dist/{runtime-audit-log-BCeujlEp.js → runtime-audit-log-DK6xAYxh.js}

@@ -5,8 +5,9 @@ import path from "node:path";
 import { appendFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { appendFileSync, createReadStream, existsSync, mkdirSync } from "node:fs";
+import { appendFileSync, closeSync, createReadStream, existsSync, fsyncSync, mkdirSync, openSync, readSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { createInterface } from "node:readline";
+import { StringDecoder } from "node:string_decoder";
 //#region src/engine/operations/jsonl-lines.ts
 const log = createLogger("sno-station-mem:jsonl");
 /** Preserve complete records without materializing an unbounded log as one string. */
@@ -131,6 +132,7 @@ function enqueueAuditWrite(auditPath, line) {
 	const next = (auditWriteQueues.get(auditPath) ?? Promise.resolve(true)).catch(() => void 0).then(async () => {
 		mkdirSync(path.dirname(auditPath), { recursive: true });
 		await appendFile(auditPath, line);
+		compactAuditLog(auditPath);
 		return true;
 	}).catch((error) => {
 		createLogger("sno-station-mem:audit").error("Audit entry append failed", { error }, {
@@ -151,6 +153,104 @@ function enqueueAuditWrite(auditPath, line) {
 function getAuditPath(stateDir) {
 	return path.join(stateDir, "audit.jsonl");
 }
+/** Retain the recent tail and two days of REM replay evidence when the audit exceeds 16 MiB. */
+function compactAuditLog(auditPath) {
+	try {
+		compactAuditFile(auditPath);
+	} catch (error) {
+		createLogger("sno-station-mem:audit").error("Audit compaction failed; existing records retained", { error }, {
+			event_name: "memory.audit.compact.failed",
+			file: "packages/memory/src/engine/operations/runtime-audit-log.ts",
+			function: "compactAuditLog",
+			site_id: "memory.audit.compact.failed"
+		});
+	}
+}
+function compactAuditFile(auditPath) {
+	if (!existsSync(auditPath) || statSync(auditPath).size <= 16777216) return;
+	const fd = openSync(auditPath, "r");
+	const retained = [];
+	const openAttempts = /* @__PURE__ */ new Map();
+	let tail;
+	let size = 0;
+	try {
+		size = statSync(auditPath).size;
+		const tailStart = Math.max(0, size - 8388608);
+		tail = Buffer.alloc(size - tailStart);
+		const tailRead = readSync(fd, tail, 0, tail.length, tailStart);
+		tail = tail.subarray(0, tailRead);
+		const newline = tail.indexOf(10);
+		const prefixEnd = newline < 0 ? size : tailStart + newline + 1;
+		tail = newline < 0 ? Buffer.alloc(0) : tail.subarray(newline + 1);
+		const cutoff = (/* @__PURE__ */ new Date(Date.now() - 1728e5)).toISOString();
+		const buffer = Buffer.alloc(65536);
+		let position = 0;
+		let pending = "";
+		let linePosition = 0;
+		const decoder = new StringDecoder("utf8");
+		let oversized = false;
+		while (position < prefixEnd) {
+			const count = readSync(fd, buffer, 0, Math.min(buffer.length, prefixEnd - position), position);
+			if (count === 0) break;
+			position += count;
+			const parts = (pending + decoder.write(buffer.subarray(0, count))).split("\n");
+			pending = parts.pop() ?? "";
+			for (const line of parts) {
+				if (oversized) {
+					oversized = false;
+					linePosition++;
+					continue;
+				}
+				try {
+					const entry = JSON.parse(line);
+					if (isRecord(entry) && typeof entry["event"] === "string" && entry["event"].startsWith("rem_") && typeof entry["timestamp"] === "string" && entry["timestamp"] >= cutoff && (entry["event"] !== "rem_trigger_evaluated" || isRecord(entry["details"]) && entry["details"]["row"] === "dispatch")) retained.push({
+						position: linePosition,
+						line: line + "\n"
+					});
+					if (isRecord(entry) && isRecord(entry["details"])) {
+						const id = entry["details"]["audit_operation_id"];
+						if (typeof id === "string" && entry["decision"] === "mutation-attempt-open") openAttempts.set(id, {
+							position: linePosition,
+							line: line + "\n"
+						});
+						if (typeof id === "string" && entry["details"]["mutation_outcome"] !== void 0) openAttempts.delete(id);
+					}
+				} catch {}
+				linePosition++;
+			}
+			if (pending.length > 1048576 || oversized) {
+				pending = "";
+				oversized = true;
+			}
+		}
+	} finally {
+		closeSync(fd);
+	}
+	const temporary = `${auditPath}.${randomUUID()}.tmp`;
+	try {
+		writeFileSync(temporary, [...retained, ...openAttempts.values()].sort((a, b) => a.position - b.position).map((record) => record.line).join(""), { mode: 384 });
+		appendFileSync(temporary, tail);
+		const output = openSync(temporary, "r+");
+		try {
+			fsyncSync(output);
+		} finally {
+			closeSync(output);
+		}
+		const grown = statSync(auditPath).size;
+		if (grown > size) {
+			const late = Buffer.alloc(grown - size);
+			const source = openSync(auditPath, "r");
+			try {
+				appendFileSync(temporary, late.subarray(0, readSync(source, late, 0, late.length, size)));
+			} finally {
+				closeSync(source);
+			}
+		}
+		renameSync(temporary, auditPath);
+	} finally {
+		rmSync(temporary, { force: true });
+	}
+}
 /** Returns cost path from audit log state state without side effects. */
 function getCostPath(stateDir) {
 	return path.join(stateDir, "cost.jsonl");
@@ -217,6 +317,7 @@ function appendAuditEntrySync(stateDir, entry) {
 			...prepared,
 			timestamp: (/* @__PURE__ */ new Date()).toISOString()
 		})}\n`);
+		compactAuditLog(auditPath);
 	} catch (error) {
 		createLogger("sno-station-mem:audit").error("memory.audit.append.failed", { error }, {
 			event_name: "memory.audit.append.failed",
@@ -427,4 +528,4 @@ async function flushAuditWrites() {
 	await Promise.allSettled(pending);
 }
 //#endregion
-export { flushAuditWrites as a, recoverInterruptedMutationAttempts as c, runWithMutationAttempt as d, currentMutationAttemptId as i, runWithMemoryAudit as l, appendAuditEntryStrict as n, getAuditPath as o, appendAuditEntrySync as r, getCostPath as s, appendAuditEntry as t, runWithMemoryAuditSync as u };
+export { currentMutationAttemptId as a, getCostPath as c, runWithMemoryAuditSync as d, runWithMutationAttempt as f, compactAuditLog as i, recoverInterruptedMutationAttempts as l, appendAuditEntryStrict as n, flushAuditWrites as o, readJsonlLines as p, appendAuditEntrySync as r, getAuditPath as s, appendAuditEntry as t, runWithMemoryAudit as u };

package/dist/{runtime-audit-log-Bn3JLBPj.d.ts → runtime-audit-log-DdhLlTxi.d.ts}

@@ -1,4 +1,4 @@
-import "./paths-D3dEsoE4.js";
+import "./paths-DmmPxD_v.js";
 //#region src/engine/operations/runtime-audit-log.d.ts
 type AuditEvent = "tool_call" | "hook_trigger" | "kill_switch" | "startup" | "error" | "auto_recall" | "ambient_learning" | "session_summary" | "envelope_strip" | "storage_integrity" | "memory_injected" | "memory_searched" | "memory_read" | "memory_updated" | "memory_superseded" | "memory_deleted" | "memory_purged" | "rem_trigger_evaluated" | "rem_triggered" | "rem_completed" | "rem_failed";
 type AuditStatus = "ok" | "error" | "skipped" | "partial";
@@ -125,6 +125,8 @@ interface MutationAttemptRunOptions<T> {
 }
 /** Returns audit path from audit log state state without side effects. */
 declare function getAuditPath(stateDir: string): string;
+/** Retain the recent tail and two days of REM replay evidence when the audit exceeds 16 MiB. */
+declare function compactAuditLog(auditPath: string): void;
 /** Returns cost path from audit log state state without side effects. */
 declare function getCostPath(stateDir: string): string;
 /** Persists audit entry through the single audit log state write path. */
@@ -146,4 +148,4 @@ declare function runWithMemoryAuditSync<T, E extends MemoryAuditEvent>(options:
 /** Implements flush audit writes as the local audit log state operation. */
 declare function flushAuditWrites(): Promise<void>;
 //#endregion
-export { runWithMutationAttempt as S, getAuditPath as _, MemoryAuditEvent as a, runWithMemoryAudit as b, MutationAttemptCompletion as c, MutationAttemptWriter as d, appendAuditEntry as f, flushAuditWrites as g, currentMutationAttemptId as h, MemoryAuditDetailsByEvent as i, MutationAttemptOutcome as l, appendAuditEntrySync as m, AuditEvent as n, MemoryAuditRunOptions as o, appendAuditEntryStrict as p, AuditStatus as r, MemoryAuditSyncRunOptions as s, AuditEntry as t, MutationAttemptRunOptions as u, getCostPath as v, runWithMemoryAuditSync as x, recoverInterruptedMutationAttempts as y };
+export { runWithMutationAttempt as C, runWithMemoryAuditSync as S, flushAuditWrites as _, MemoryAuditEvent as a, recoverInterruptedMutationAttempts as b, MutationAttemptCompletion as c, MutationAttemptWriter as d, appendAuditEntry as f, currentMutationAttemptId as g, compactAuditLog as h, MemoryAuditDetailsByEvent as i, MutationAttemptOutcome as l, appendAuditEntrySync as m, AuditEvent as n, MemoryAuditRunOptions as o, appendAuditEntryStrict as p, AuditStatus as r, MemoryAuditSyncRunOptions as s, AuditEntry as t, MutationAttemptRunOptions as u, getAuditPath as v, runWithMemoryAudit as x, getCostPath as y };

package/dist/{scopes-CSOn6zdd.js → scopes-a4Kly9n7.js}

@@ -1,4 +1,4 @@
-import { c as SCOPE_PATTERNS, i as isSystemBypassId, o as shouldWarnLegacyFallbackBypassId } from "./memory-scope-policy-DICSCURA.js";
+import { c as SCOPE_PATTERNS, i as isSystemBypassId, o as shouldWarnLegacyFallbackBypassId } from "./memory-scope-policy--TiLZnrE.js";
 import { createLogger, privateLogReference } from "@snoai/utils/logger";
 //#region src/engine/security/scope-helpers.ts
 /** @file scope-helpers.ts

package/dist/{server-Dw34jY1d.js → server-CCduS_Ea.js}

@@ -1,5 +1,5 @@
-import { Et as ModelCallRefusedError, G as parseRemOperationType, W as REM_BUILT_OPERATION_TYPES, ct as readJsonlLines, it as getAuditPath, n as remNeedsHost, nt as appendAuditEntryStrict } from "./rem-trigger-DZaplx_E.js";
-import { Ar as MEMORY_ERROR_STATUS, C as getSnoStationMemStateDir, Fr as memoryMethod, Mr as MEMORY_ROUTES, Nr as MEMORY_SKIN_HEADER, S as getSidecarSocketPath, _ as readRemTestHoldMs, c as REM_SIDECAR_ORIGIN, d as getRemDiscoveryPath, f as getRemJobJournalPath, g as readRemOperationalConfig, i as REM_JOBS_PATH_PREFIX, kr as MEMORY_DEFAULT_SKIN_ID, l as REM_SOURCE, nr as MEMORY_SHUTDOWN_TIMEOUT_MS, r as REM_CORRELATION_ID_HEADER, s as REM_SIDECAR_HOST, u as getRemChassisJournalPath, v as SettingsUnavailableError, y as getDiscoveryPath } from "./config-BCZRhUvW.js";
+import { At as getAuditPath, Dt as appendAuditEntryStrict, K as REM_BUILT_OPERATION_TYPES, Ot as compactAuditLog, Pt as readJsonlLines, bt as ModelCallRefusedError, d as RemJobStore, f as parseRemJobStats, n as remNeedsHost, q as parseRemOperationType } from "./rem-trigger-DmRERTNH.js";
+import { Ar as MEMORY_ERROR_STATUS, C as getSnoStationMemStateDir, Fr as memoryMethod, Mr as MEMORY_ROUTES, Nr as MEMORY_SKIN_HEADER, S as getSidecarSocketPath, _ as readRemTestHoldMs, c as REM_SIDECAR_ORIGIN, d as getRemDiscoveryPath, f as getRemJobJournalPath, g as readRemOperationalConfig, i as REM_JOBS_PATH_PREFIX, kr as MEMORY_DEFAULT_SKIN_ID, l as REM_SOURCE, nr as MEMORY_SHUTDOWN_TIMEOUT_MS, r as REM_CORRELATION_ID_HEADER, s as REM_SIDECAR_HOST, u as getRemChassisJournalPath, v as SettingsUnavailableError, y as getDiscoveryPath } from "./config-C7LzSWhG.js";
 import { t as ContractError } from "./error-D-wb-rZw.js";
 import { setImmediate } from "node:timers/promises";
 import { createLogger, currentLogContext, effectiveLogLevel, emitDiagnostic } from "@snoai/utils/logger";
@@ -80,7 +80,7 @@ function readRequestBody(request, signal) {
 }
 //#endregion
 //#region src/sidecar/memory-routes.ts
-const log$2 = createLogger("sno-station-mem:memory-routes");
+const log$1 = 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;
@@ -123,7 +123,7 @@ async function serveMemoryRoute(request, response, pathname, openPool, activeTas
 			}));
 			return true;
 		}
-		log$2.error("Memory engine request failed", {
+		log$1.error("Memory engine request failed", {
 			method,
 			skinId,
 			error,
@@ -208,318 +208,9 @@ var RemChassisJournal = class {
 		} 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");
@@ -643,7 +334,7 @@ async function startOwnedRemSidecar() {
 		async open() {
 			if (currentMemory) return currentMemory;
 			if (settingsError) throw settingsError;
-			openingMemory ??= import("./memory-runtime-DSP8cXik.js").then((module) => module.MemoryRuntimePool.open()).then((pool) => {
+			openingMemory ??= import("./memory-runtime-HibOMCFa.js").then((module) => module.MemoryRuntimePool.open()).then((pool) => {
 				currentMemory = pool;
 				if (stopping) pool.stopTimers();
 				return pool;
@@ -1038,7 +729,7 @@ async function runChassisJob(store, journal, waveId, holdMs, runtime) {
 				cleanRefusalReasons.push(reason);
 				await appendChassisRefusal(journal, queued, operation, "refused", reason);
 			}
-			const { runRemProductionOrderedWave } = await import("./rem-batch-executor-DsXWpJYU.js");
+			const { runRemProductionOrderedWave } = await import("./rem-batch-executor-8x4FBLtW.js");
 			const result = enabledOperations.length === 0 ? {
 				decision: "allow",
 				reasonCode: null,
@@ -1167,11 +858,15 @@ async function runChassisJob(store, journal, waveId, holdMs, runtime) {
 }
 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
-	});
+	try {
+		await store.transition(job.job_id, {
+			state: "done",
+			finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+			stats
+		});
+	} catch (error) {
+		reportSidecarFailure("completion-job-journal", error);
+	}
 	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"));
@@ -1268,6 +963,8 @@ async function recoverInterruptedJobs(store, completedJobStats, jobs) {
 }
 async function readCompletedJobStats(wantedJobs) {
 	const completed = /* @__PURE__ */ new Map();
+	if (wantedJobs.size === 0) return completed;
+	compactAuditLog(getAuditPath(getSnoStationMemStateDir()));
 	for await (const line of readJsonlLines(getAuditPath(getSnoStationMemStateDir()))) {
 		if (line.length === 0) continue;
 		try {

package/dist/sidecar/main.js

@@ -1,4 +1,4 @@
-import { jr as MEMORY_RECONNECT_INTERVAL_MS, m as isRemTraceEnabled, p as getRemTraceLogPath, v as SettingsUnavailableError } from "../config-BCZRhUvW.js";
+import { jr as MEMORY_RECONNECT_INTERVAL_MS, m as isRemTraceEnabled, p as getRemTraceLogPath, v as SettingsUnavailableError } from "../config-C7LzSWhG.js";
 import { setTimeout } from "node:timers/promises";
 import { addLogFileTarget, closeLogger, createLogger } from "@snoai/utils/logger";
 //#region src/sidecar/main.ts
@@ -6,9 +6,9 @@ import { addLogFileTarget, closeLogger, createLogger } from "@snoai/utils/logger
 * @purpose Boots the standalone local REM sidecar process.
 * @boundary Process environment, sidecar lifecycle, and local request-log destination.
 */
-const { startRemSidecar, DuplicateSidecarError } = await import("../server-Dw34jY1d.js");
+const { startRemSidecar, DuplicateSidecarError } = await import("../server-CCduS_Ea.js");
 let sidecar;
-while (!sidecar) try {
+for (let attempt = 1; !sidecar; attempt++) try {
 	sidecar = await startRemSidecar();
 } catch (error) {
 	if (error instanceof DuplicateSidecarError) {
@@ -16,12 +16,19 @@ while (!sidecar) try {
 		process.exit(0);
 	}
 	if (error instanceof SettingsUnavailableError) throw error;
-	createLogger("sno-station-mem:sidecar").error("Memory service startup failed; retrying", { error }, {
+	createLogger("sno-station-mem:sidecar").error(attempt >= 3 ? "Memory service startup failed after three attempts; stopping" : "Memory service startup failed; retrying", {
+		error,
+		attempt
+	}, {
 		event_name: "memory.sidecar.startup.failed",
 		file: "packages/memory/src/sidecar/main.ts",
 		function: "<module>",
 		site_id: "sidecar.main.startup.failed"
 	});
+	if (attempt >= 3) {
+		await closeLogger();
+		process.exit(1);
+	}
 	await setTimeout(MEMORY_RECONNECT_INTERVAL_MS);
 }
 if (isRemTraceEnabled()) addLogFileTarget(getRemTraceLogPath());