@snoai/memory 1.2.8 → 1.2.10

package/dist/{rem-trigger-DZaplx_E.js → rem-trigger-DmRERTNH.js}

@@ -1,7 +1,7 @@
-import { $ as FIXED_IDX_MEMORY_ACTIVE_TASK_EVIDENCE_INSTANCE, $n as MAX_CHUNK_FETCH_LIMIT, $t as FIXED_VEC_MEMORY, At as FIXED_MEMORY_PROVIDER_AGENT_MAPPINGS, B as FIXED_EXTERNAL_VALUE_51, C as getSnoStationMemStateDir, Cn as CHUNK_TARGET_TOKENS, Cr as LOCAL_EMBEDDING_CACHE_DIR_DEFAULT, Ct as FIXED_MEMORY_CHUNKS_MEM_IDX, D as settingsToPluginConfig, Dn as DEFAULT_RECALL_LIFECYCLE, Dr as ensureModelDownloaded, Dt as FIXED_MEMORY_MEMORIES_FACT_ID_UPDATE_GUARD, En as DEFAULT_IMPORTANCE, Er as LocalEmbedProvider, Et as FIXED_MEMORY_MEMORIES_FACT_ID_INSERT_GUARD, Fn as EMBEDDER_DIM, Ft as FIXED_MEMORY_SNO_EXTRACT_CHAT, G as FIXED_EXTERNAL_VALUE_56, Gt as FIXED_PROTOCOL_VALUE_69, H as FIXED_EXTERNAL_VALUE_53, Hn as HEAD_EXTRACT_OVERLAP_DROP_RATIO, In as EMBEDDER_MODEL_DEFAULT, J as FIXED_EXTERNAL_VALUE_62, Jn as LIGHTWEIGHT_FUSION_WEIGHT, K as FIXED_EXTERNAL_VALUE_57, Kn as INTRA_MEMORY_COSINE_THRESHOLD, Kt as FIXED_PROTOCOL_VALUE_73, Ln as EMBEDDER_PROVIDER_DEFAULT, Lt as FIXED_MEMORY_TASK_LIFECYCLE_COMMANDS, Mn as DEFAULT_RERANK_TIMEOUT_MS, Mt as FIXED_MEMORY_PROVIDER_PROJECT_MAPPINGS, N as observeAgentId, O as MODEL_CALLS, Ot as FIXED_MEMORY_MIGRATION_MARKERS, Pn as DEFAULT_VECTOR_WEIGHT, Pr as REM_SIDECAR_TOKEN_HEADER, Q as FIXED_IDX_MEMORY_ACTIVE_TASK_CURRENT_REVISION, Rn as EVAL_QA_TRACES_FILENAME, Rt as FIXED_MEMORY_UNPLACED_CANDIDATES, Sn as CHUNK_OVERLAP_TOKENS, Sr as CachedEmbeddingProvider, St as FIXED_MEMORY_CHUNKS_MEM_FACET_IDX, T as readSettings, Tn as DEFAULT_BM25_WEIGHT, Tt as FIXED_MEMORY_MEMORIES, U as FIXED_EXTERNAL_VALUE_54, Un as HEAD_EXTRACT_TOKEN_BUDGET, V as FIXED_EXTERNAL_VALUE_52, Vn as HEAD_EXTRACT_MIN_CONTENT_TOKENS, W as FIXED_EXTERNAL_VALUE_55, Wn as IMPORTANCE_WEIGHT_BASE, X as FIXED_EXTERNAL_VALUE_9, Y as FIXED_EXTERNAL_VALUE_8, Yn as LIGHTWEIGHT_RERANK_PENALTY, Z as FIXED_IDX_MEMORY, _n as BONUS_TOTAL_INVARIANT, _t as FIXED_MEMORY_CHUNKS_AD, a as REM_MODEL_OUTPUT_TOKEN_CAP, ar as MULTI_HIT_BONUS_CAP, at as FIXED_IDX_MEMORY_MEMORIES_PROJECT, bn as CHUNK_MAX_TOKENS, br as experimentMmrDisabled, bt as FIXED_MEMORY_CHUNKS_FTS, cr as RECENCY_WEIGHT, ct as FIXED_IDX_MEMORY_MEMORIES_PROJECT_TIMESTAMP, d as getRemDiscoveryPath, dr as RERANK_BLEND_CROSS, dt as FIXED_MEMORY_ACTIVE_TASK_INSTANCES, en as FIXED_VEC_MEMORY_CHUNKS, er as MAX_LIST_LIMIT, et as FIXED_IDX_MEMORY_ACTIVE_TASK_INSTANCES_PROJECTION, fr as RERANK_BLEND_VECTOR, ft as FIXED_MEMORY_ACTIVE_TASK_MIGRATION_EVIDENCE, g as readRemOperationalConfig, gt as FIXED_MEMORY_CHUNKS, hr as TIME_DECAY_FLOOR, ht as FIXED_MEMORY_ACTIVE_TASK_TRANSITIONS, in as PERSISTED_PROVIDER_SYSTEM, ir as MMR_LAMBDA, it as FIXED_IDX_MEMORY_MEMORIES_LANE_PROJECT, jn as DEFAULT_RERANK_MODEL, jt as FIXED_MEMORY_PROVIDER_PROJECT_AGENTS, k as modelCallDestination, kt as FIXED_MEMORY_PROFILE_RECOVERY_ENTRIES, ln as ADJACENCY_BONUS_CAP, lt as FIXED_MEMORY, mt as FIXED_MEMORY_ACTIVE_TASK_REVISIONS, nn as PERSISTED_CONTENT_HASH_V1, nt as FIXED_IDX_MEMORY_MEMORIES_CONTENT_HASH, o as REM_RUN_PATH, on as llmRoutingConfigSchema, or as MULTI_HIT_BONUS_PER_HIT, ot as FIXED_IDX_MEMORY_MEMORIES_PROJECT_CONTENT_HASH, pr as RETRIEVAL_STORAGE_CHUNK_PROFILE, pt as FIXED_MEMORY_ACTIVE_TASK_MIGRATION_MANIFESTS, q as FIXED_EXTERNAL_VALUE_58, qn as LIGHTWEIGHT_COSINE_WEIGHT, r as REM_CORRELATION_ID_HEADER, rn as PERSISTED_CONTENT_HASH_V3, rt as FIXED_IDX_MEMORY_MEMORIES_FACT_ID, s as REM_SIDECAR_HOST, sn as SUPPORTED_LOCALES, st as FIXED_IDX_MEMORY_MEMORIES_PROJECT_FACT_KEY_ACTIVE, tn as PERSISTED_CANDIDATE_HASH_V1, tt as FIXED_IDX_MEMORY_MEMORIES_CATEGORY, un as ADJACENCY_BONUS_PER_PAIR, ut as FIXED_MEMORY_ACTIVE_TASK_EVIDENCE, vn as CACHE_TTL_MS, vt as FIXED_MEMORY_CHUNKS_AI, wn as CHUNK_TOKENIZER_MODE, wr as LOCAL_EMBEDDING_MODEL, wt as FIXED_MEMORY_EXTRACTION_TIMESTAMPS, xn as CHUNK_MIN_TOKENS, xt as FIXED_MEMORY_CHUNKS_MEMORY_ID_IDX, yn as CHUNKING_VERSION$1, yr as experimentCandidatePoolOverride, yt as FIXED_MEMORY_CHUNKS_AU, z as FIXED_EXTERNAL_VALUE_49 } from "./config-BCZRhUvW.js";
+import { $ as FIXED_IDX_MEMORY_ACTIVE_TASK_EVIDENCE_INSTANCE, $n as MAX_CHUNK_FETCH_LIMIT, $t as FIXED_VEC_MEMORY, At as FIXED_MEMORY_PROVIDER_AGENT_MAPPINGS, B as FIXED_EXTERNAL_VALUE_51, C as getSnoStationMemStateDir, Cn as CHUNK_TARGET_TOKENS, Cr as LOCAL_EMBEDDING_CACHE_DIR_DEFAULT, Ct as FIXED_MEMORY_CHUNKS_MEM_IDX, D as settingsToPluginConfig, Dn as DEFAULT_RECALL_LIFECYCLE, Dr as ensureModelDownloaded, Dt as FIXED_MEMORY_MEMORIES_FACT_ID_UPDATE_GUARD, En as DEFAULT_IMPORTANCE, Er as LocalEmbedProvider, Et as FIXED_MEMORY_MEMORIES_FACT_ID_INSERT_GUARD, Fn as EMBEDDER_DIM, Ft as FIXED_MEMORY_SNO_EXTRACT_CHAT, G as FIXED_EXTERNAL_VALUE_56, Gt as FIXED_PROTOCOL_VALUE_69, H as FIXED_EXTERNAL_VALUE_53, Hn as HEAD_EXTRACT_OVERLAP_DROP_RATIO, In as EMBEDDER_MODEL_DEFAULT, J as FIXED_EXTERNAL_VALUE_62, Jn as LIGHTWEIGHT_FUSION_WEIGHT, K as FIXED_EXTERNAL_VALUE_57, Kn as INTRA_MEMORY_COSINE_THRESHOLD, Kt as FIXED_PROTOCOL_VALUE_73, Ln as EMBEDDER_PROVIDER_DEFAULT, Lt as FIXED_MEMORY_TASK_LIFECYCLE_COMMANDS, Mn as DEFAULT_RERANK_TIMEOUT_MS, Mt as FIXED_MEMORY_PROVIDER_PROJECT_MAPPINGS, N as observeAgentId, O as MODEL_CALLS, Ot as FIXED_MEMORY_MIGRATION_MARKERS, Pn as DEFAULT_VECTOR_WEIGHT, Pr as REM_SIDECAR_TOKEN_HEADER, Q as FIXED_IDX_MEMORY_ACTIVE_TASK_CURRENT_REVISION, Rn as EVAL_QA_TRACES_FILENAME, Rt as FIXED_MEMORY_UNPLACED_CANDIDATES, Sn as CHUNK_OVERLAP_TOKENS, Sr as CachedEmbeddingProvider, St as FIXED_MEMORY_CHUNKS_MEM_FACET_IDX, T as readSettings, Tn as DEFAULT_BM25_WEIGHT, Tt as FIXED_MEMORY_MEMORIES, U as FIXED_EXTERNAL_VALUE_54, Un as HEAD_EXTRACT_TOKEN_BUDGET, V as FIXED_EXTERNAL_VALUE_52, Vn as HEAD_EXTRACT_MIN_CONTENT_TOKENS, W as FIXED_EXTERNAL_VALUE_55, Wn as IMPORTANCE_WEIGHT_BASE, X as FIXED_EXTERNAL_VALUE_9, Y as FIXED_EXTERNAL_VALUE_8, Yn as LIGHTWEIGHT_RERANK_PENALTY, Z as FIXED_IDX_MEMORY, _n as BONUS_TOTAL_INVARIANT, _t as FIXED_MEMORY_CHUNKS_AD, a as REM_MODEL_OUTPUT_TOKEN_CAP, ar as MULTI_HIT_BONUS_CAP, at as FIXED_IDX_MEMORY_MEMORIES_PROJECT, bn as CHUNK_MAX_TOKENS, br as experimentMmrDisabled, bt as FIXED_MEMORY_CHUNKS_FTS, cr as RECENCY_WEIGHT, ct as FIXED_IDX_MEMORY_MEMORIES_PROJECT_TIMESTAMP, d as getRemDiscoveryPath, dr as RERANK_BLEND_CROSS, dt as FIXED_MEMORY_ACTIVE_TASK_INSTANCES, en as FIXED_VEC_MEMORY_CHUNKS, er as MAX_LIST_LIMIT, et as FIXED_IDX_MEMORY_ACTIVE_TASK_INSTANCES_PROJECTION, fr as RERANK_BLEND_VECTOR, ft as FIXED_MEMORY_ACTIVE_TASK_MIGRATION_EVIDENCE, g as readRemOperationalConfig, gt as FIXED_MEMORY_CHUNKS, hr as TIME_DECAY_FLOOR, ht as FIXED_MEMORY_ACTIVE_TASK_TRANSITIONS, in as PERSISTED_PROVIDER_SYSTEM, ir as MMR_LAMBDA, it as FIXED_IDX_MEMORY_MEMORIES_LANE_PROJECT, jn as DEFAULT_RERANK_MODEL, jt as FIXED_MEMORY_PROVIDER_PROJECT_AGENTS, k as modelCallDestination, kt as FIXED_MEMORY_PROFILE_RECOVERY_ENTRIES, ln as ADJACENCY_BONUS_CAP, lt as FIXED_MEMORY, mt as FIXED_MEMORY_ACTIVE_TASK_REVISIONS, nn as PERSISTED_CONTENT_HASH_V1, nt as FIXED_IDX_MEMORY_MEMORIES_CONTENT_HASH, o as REM_RUN_PATH, on as llmRoutingConfigSchema, or as MULTI_HIT_BONUS_PER_HIT, ot as FIXED_IDX_MEMORY_MEMORIES_PROJECT_CONTENT_HASH, pr as RETRIEVAL_STORAGE_CHUNK_PROFILE, pt as FIXED_MEMORY_ACTIVE_TASK_MIGRATION_MANIFESTS, q as FIXED_EXTERNAL_VALUE_58, qn as LIGHTWEIGHT_COSINE_WEIGHT, r as REM_CORRELATION_ID_HEADER, rn as PERSISTED_CONTENT_HASH_V3, rt as FIXED_IDX_MEMORY_MEMORIES_FACT_ID, s as REM_SIDECAR_HOST, sn as SUPPORTED_LOCALES, st as FIXED_IDX_MEMORY_MEMORIES_PROJECT_FACT_KEY_ACTIVE, tn as PERSISTED_CANDIDATE_HASH_V1, tt as FIXED_IDX_MEMORY_MEMORIES_CATEGORY, un as ADJACENCY_BONUS_PER_PAIR, ut as FIXED_MEMORY_ACTIVE_TASK_EVIDENCE, vn as CACHE_TTL_MS, vt as FIXED_MEMORY_CHUNKS_AI, wn as CHUNK_TOKENIZER_MODE, wr as LOCAL_EMBEDDING_MODEL, wt as FIXED_MEMORY_EXTRACTION_TIMESTAMPS, xn as CHUNK_MIN_TOKENS, xt as FIXED_MEMORY_CHUNKS_MEMORY_ID_IDX, yn as CHUNKING_VERSION$1, yr as experimentCandidatePoolOverride, yt as FIXED_MEMORY_CHUNKS_AU, z as FIXED_EXTERNAL_VALUE_49 } from "./config-C7LzSWhG.js";
 import { createLogger, createLogger as createLogger$1, currentLogContext, privateLogReference, withLogContext } from "@snoai/utils/logger";
 import path, { dirname, join, resolve } from "node:path";
-import { appendFileSync, createReadStream, existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { appendFileSync, closeSync, createReadStream, existsSync, fstatSync, fsyncSync, ftruncateSync, mkdirSync, openSync, readFileSync, readSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
 import { arch, availableParallelism, platform } from "node:os";
 import { fileURLToPath } from "node:url";
 import { LRUCache } from "lru-cache";
@@ -13,10 +13,11 @@ import { getDek, openEncryptedDb, openEncryptedDbReadonly } from "@snoai/sqlite-
 import { appendFile, mkdir, open, readFile, rename, rm } from "node:fs/promises";
 import { Temporal } from "@js-temporal/polyfill";
 import { redactForStorage, sanitizeContentIngress, sanitizeStructuredJsonForStorage } from "@snoai/content-sanitizer";
+import { createInterface } from "node:readline";
+import { StringDecoder } from "node:string_decoder";
 import { CallPipeline, ConfigRegistryManager, KeyPool, loadLlmixTrustManifest, registryRootOptionsFromTrustManifest } from "@snoai/llmix";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { Mutex } from "async-mutex";
-import { createInterface } from "node:readline";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { migrate } from "drizzle-orm/better-sqlite3/migrator";
 import { index, integer, primaryKey, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
@@ -37,7 +38,7 @@ var __exportAll = (all, no_symbols) => {
 };
 //#endregion
 //#region src/engine/telemetry/observe-ledger.ts
-const log$23 = createLogger("sno-station-mem:observe-ledger");
+const log$24 = createLogger("sno-station-mem:observe-ledger");
 const rowSchema = z.object({
 	ts_ms: z.number().int().nonnegative(),
 	agent_id: z.string().transform(observeAgentId).optional(),
@@ -54,7 +55,7 @@ function observeLedgerSyncedPath(profileDir) {
 }
 function warn(observe, message) {
 	if (observe.logger) observe.logger.warn(message);
-	else log$23.warn(message, void 0, {
+	else log$24.warn(message, void 0, {
 		event_name: "observe.ledger.failed",
 		file: "packages/memory/src/engine/telemetry/observe-ledger.ts",
 		function: "forwardObserveLedger",
@@ -79,25 +80,52 @@ function consumeRows(profileDir, observe, batchSize) {
 		rows,
 		offset
 	};
-	const ledger = readFileSync(path);
-	if (offset > ledger.length) {
-		warn(observe, `offset beyond ledger: ${offset} > ${ledger.length}`);
-		return {
-			rows,
-			offset
-		};
-	}
-	while (rows.length < batchSize) {
-		const newline = ledger.indexOf(10, offset);
-		if (newline === -1) break;
-		rows.push({
-			start: offset,
-			end: newline + 1,
-			text: ledger.toString("utf8", offset, newline)
-		});
-		offset = newline + 1;
+	const fd = openSync(path, "r+");
+	try {
+		const size = fstatSync(fd).size;
+		if (offset > size) {
+			warn(observe, `offset beyond ledger: ${offset} > ${size}`);
+			offset = 0;
+			writeFileSync(syncedPath, "0", { mode: 384 });
+		}
+		const buffer = Buffer.alloc(65536);
+		let position = offset;
+		let pending = Buffer.alloc(0);
+		while (rows.length < batchSize && position < size) {
+			const count = readSync(fd, buffer, 0, Math.min(buffer.length, size - position), position);
+			if (count === 0) break;
+			position += count;
+			pending = Buffer.concat([pending, buffer.subarray(0, count)]);
+			let consumed = 0;
+			while (rows.length < batchSize) {
+				const newline = pending.indexOf(10, consumed);
+				if (newline === -1) break;
+				const end = offset + newline - consumed + 1;
+				rows.push({
+					start: offset,
+					end,
+					text: pending.toString("utf8", consumed, newline)
+				});
+				offset = end;
+				consumed = newline + 1;
+			}
+			pending = pending.subarray(consumed);
+		}
+		if (offset >= 1048576 && size - offset <= 65536) {
+			let source = offset;
+			for (let end = fstatSync(fd).size; source < end; end = fstatSync(fd).size) while (source < end) {
+				const count = readSync(fd, buffer, 0, Math.min(buffer.length, end - source), source);
+				if (count === 0) break;
+				writeSync(fd, buffer, 0, count, source - offset);
+				source += count;
+			}
+			ftruncateSync(fd, source - offset);
+			offset = 0;
+		}
+		if (rows.length) writeFileSync(syncedPath, String(offset), { mode: 384 });
+	} finally {
+		closeSync(fd);
 	}
-	if (rows.length) writeFileSync(syncedPath, String(offset), { mode: 384 });
 	return {
 		rows,
 		offset
@@ -141,7 +169,7 @@ async function forwardObserveLedgerUntilIdle(options) {
 //#endregion
 //#region src/engine/operation-cancellation.ts
 const operations = new AsyncLocalStorage();
-const log$22 = createLogger("sno-station-mem:cancellation");
+const log$23 = createLogger("sno-station-mem:cancellation");
 /** Carries cancellation through the existing nested extraction and reflection writers. */
 async function withMemoryOperation(method, signal, run) {
 	const operation = {
@@ -157,7 +185,7 @@ async function withMemoryOperation(method, signal, run) {
 			signal?.throwIfAborted();
 			return result;
 		} finally {
-			if (signal?.aborted) log$22.error("memory.operation.aborted", {
+			if (signal?.aborted) log$23.error("memory.operation.aborted", {
 				method,
 				outcome: "aborted",
 				writes: operation.writes
@@ -5828,6 +5856,18 @@ function bytesToF32(bytes) {
 function stableHash(text) {
 	return createHash("sha256").update(text).digest("hex");
 }
+/**
+* Return a short, secret-redacted, whitespace-collapsed preview of `text` for
+* audit logs. Previews are enabled by default and pass through `redactSecrets`
+* before they are persisted in audit.jsonl on disk.
+*/
+function debugContentPreview(text, enabled, maxChars = 80) {
+	if (!enabled) return void 0;
+	if (!text) return void 0;
+	const collapsed = redactSecrets(text).replace(/\s+/g, " ").trim();
+	if (collapsed.length === 0) return void 0;
+	return collapsed.length > maxChars ? `${collapsed.slice(0, maxChars)}...` : collapsed;
+}
 z.object({ source: z.object({ commit: z.string().min(1) }) });
 //#endregion
 //#region config/skin-defaults.ts
@@ -5847,165 +5887,675 @@ const CODING_SKIN_CHILD_DEADLINE_MS = 11e4;
 const CODING_SKIN_SESSION_QUERY = "standing decisions, open tasks, conventions and known pitfalls for this repository";
 const CODING_SKIN_LEDGER_MAX_CHARS = 12e3;
 //#endregion
-//#region src/model/llm-failure.ts
-const CREDENTIAL_CATEGORIES = /* @__PURE__ */ new Set([
-	"auth",
-	"credential-expired",
-	"credential-revoked"
-]);
-const TERMINAL_CATEGORIES = /* @__PURE__ */ new Set([...CREDENTIAL_CATEGORIES, "exhausted"]);
-function isCredentialRevokedMessage(message) {
-	return /oauth token refresh failed for openai:.*\binvalid_grant\b.*\btoken revoked\b/i.test(message);
+//#region src/engine/operations/jsonl-lines.ts
+const log$22 = createLogger("sno-station-mem:jsonl");
+/** Preserve complete records without materializing an unbounded log as one string. */
+async function* readJsonlLines(file) {
+	const stream = createReadStream(file, { encoding: "utf8" });
+	const lines = createInterface({
+		input: stream,
+		crlfDelay: Infinity
+	});
+	try {
+		for await (const line of lines) if (line.trim()) yield line;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
+		log$22.error("jsonl.read.failed", {
+			file,
+			error
+		}, {
+			event_name: "memory.jsonl.read.failed",
+			file: "packages/memory/src/engine/operations/jsonl-lines.ts",
+			function: "readJsonlLines",
+			site_id: "memory.jsonl.read.failed"
+		});
+	} finally {
+		lines.close();
+		stream.destroy();
+	}
 }
-function isCredentialExpiredMessage(message) {
-	return /\bexpired access token\b/i.test(message);
+//#endregion
+//#region src/engine/operations/runtime-audit-log.ts
+/** @file runtime-audit-log.ts
+* @purpose Records audit events for operational visibility and safety-sensitive actions.
+* @boundary Plugin runtime events and filesystem-backed audit persistence.
+* @see sno-station-mem-plugin-runtime.ts, memory-tool-registration.ts, errors.ts.
+*/
+const auditWriteQueues = /* @__PURE__ */ new Map();
+const memoryAuditScope = new AsyncLocalStorage();
+const mutationAttemptScope = new AsyncLocalStorage();
+const mutationRecoveryPromises = /* @__PURE__ */ new Map();
+const MEMORY_AUDIT_COMMON_KEYS = [
+	"operation",
+	"audit_phase",
+	"audit_operation_id"
+];
+const MUTATION_AUDIT_DETAIL_KEYS = [
+	"mutation_writer",
+	"mutation_subject",
+	"mutation_outcome",
+	"refusal_reason"
+];
+const MEMORY_AUDIT_ALLOWED_DETAIL_KEYS = {
+	memory_injected: /* @__PURE__ */ new Set([
+		...MEMORY_AUDIT_COMMON_KEYS,
+		"scope",
+		"category",
+		"lane",
+		"count",
+		"memory_ids",
+		"write_outcome",
+		"created_count",
+		"existing_count"
+	]),
+	memory_searched: /* @__PURE__ */ new Set([
+		...MEMORY_AUDIT_COMMON_KEYS,
+		"scope",
+		"query_kind",
+		"requested_count",
+		"result_count",
+		"memory_ids"
+	]),
+	memory_read: /* @__PURE__ */ new Set([
+		...MEMORY_AUDIT_COMMON_KEYS,
+		"scope",
+		"requested_count",
+		"result_count",
+		"memory_ids",
+		"requested_fact_id",
+		"resolved_fact_id",
+		"fact_ids",
+		"found",
+		"outcome"
+	]),
+	memory_updated: /* @__PURE__ */ new Set([
+		...MEMORY_AUDIT_COMMON_KEYS,
+		...MUTATION_AUDIT_DETAIL_KEYS,
+		"scope",
+		"requested_count",
+		"result_count",
+		"memory_ids",
+		"outcome",
+		"migration_status",
+		"rewritten_rows",
+		"checked_rows"
+	]),
+	memory_superseded: /* @__PURE__ */ new Set([
+		...MEMORY_AUDIT_COMMON_KEYS,
+		...MUTATION_AUDIT_DETAIL_KEYS,
+		"scope",
+		"replacement_memory_id",
+		"closed_memory_ids",
+		"write_outcome"
+	]),
+	memory_deleted: /* @__PURE__ */ new Set([
+		...MEMORY_AUDIT_COMMON_KEYS,
+		"scope",
+		"deleted_memory_ids",
+		"delete_reason",
+		"count",
+		"outcome",
+		"removed_files"
+	]),
+	memory_purged: /* @__PURE__ */ new Set([
+		...MEMORY_AUDIT_COMMON_KEYS,
+		"target_fact_id",
+		"purged_fact_ids",
+		"failed_fact_ids",
+		"status",
+		"blocked_reason"
+	])
+};
+/** Implements enqueue audit write as the local audit log state operation. */
+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 }, {
+			event_name: "memory.audit.append.failed",
+			file: "packages/memory/src/engine/operations/runtime-audit-log.ts",
+			function: "enqueueAuditWrite",
+			site_id: "memory.audit.append.failed"
+		});
+		return false;
+	});
+	auditWriteQueues.set(auditPath, next);
+	next.finally(() => {
+		if (auditWriteQueues.get(auditPath) === next) auditWriteQueues.delete(auditPath);
+	});
+	return next;
 }
-function isAuthMessage(message) {
-	return /\b(?:401|403)\b/.test(message) || /unauthori[sz]ed/i.test(message) || /no api key found/i.test(message) || /(?:invalid|incorrect) api[- ]?key/i.test(message) || /(?:invalid|expired) (?:access |oauth )?token/i.test(message) || /(?:api[- ]?key|token).*(?:invalid|expired|rejected)/i.test(message) || /credential (?:is )?(?:invalid|expired|rejected)/i.test(message) || /no (?:valid )?credential (?:found|available|configured)/i.test(message) || /re-?authenticate/i.test(message) || /no authentication configured/i.test(message);
+/** Returns audit path from audit log state state without side effects. */
+function getAuditPath(stateDir) {
+	return path.join(stateDir, "audit.jsonl");
 }
-function isExhaustedMessage(message) {
-	return /you(?:'|’)ve reached your codex subscription usage limit/i.test(message);
+/** 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 isThrottleMessage(message) {
-	return /\b429\b/.test(message) || /rate.?limit/i.test(message) || /quota/i.test(message);
+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$1(entry) && typeof entry["event"] === "string" && entry["event"].startsWith("rem_") && typeof entry["timestamp"] === "string" && entry["timestamp"] >= cutoff && (entry["event"] !== "rem_trigger_evaluated" || isRecord$1(entry["details"]) && entry["details"]["row"] === "dispatch")) retained.push({
+						position: linePosition,
+						line: line + "\n"
+					});
+					if (isRecord$1(entry) && isRecord$1(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 });
+	}
 }
-function categoryOf(status, message) {
-	if (isCredentialRevokedMessage(message)) return "credential-revoked";
-	if (isCredentialExpiredMessage(message)) return "credential-expired";
-	if (status === 401 || status === 403 || isAuthMessage(message)) return "auth";
-	if (isExhaustedMessage(message)) return "exhausted";
-	if (status === 429 || isThrottleMessage(message)) return "throttle";
-	if (status !== void 0 && (status === 404 || status === 408 || status >= 500)) return "transport";
-	return "unknown";
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
 }
-/** Classifies one failed model call from whatever the transport surfaced: a status, a message, or both. */
-function classifyLlmFailure(input) {
-	const category = categoryOf(input.status, input.message ?? "");
-	const terminal = TERMINAL_CATEGORIES.has(category);
+function isMemoryAuditEvent(event) {
+	return event.startsWith("memory_");
+}
+function redactAuditValue(value) {
+	if (typeof value === "string") return redactSecrets(value);
+	if (Array.isArray(value)) return value.map(redactAuditValue);
+	if (!isRecord$1(value)) return value;
+	const redacted = {};
+	for (const [key, child] of Object.entries(value)) redacted[key] = redactAuditValue(child);
+	return redacted;
+}
+function prepareAuditEntry(entry) {
+	if (!isMemoryAuditEvent(entry.event) || entry.details?.["audit_phase"] === void 0) return entry;
+	const allowed = MEMORY_AUDIT_ALLOWED_DETAIL_KEYS[entry.event];
+	const details = {};
+	for (const [key, value] of Object.entries(entry.details)) if (allowed.has(key)) details[key] = value;
+	else createLogger("sno-station-mem:audit").error("memory.audit.detail.unknown", {
+		event: entry.event,
+		key
+	}, {
+		event_name: "memory.audit.detail.unknown",
+		file: "packages/memory/src/engine/operations/runtime-audit-log.ts",
+		function: "prepareAuditEntry",
+		site_id: "memory.audit.detail.unknown"
+	});
 	return {
-		category,
-		terminal,
-		endpointRefused: terminal || input.status === 404 || input.status === 503
+		...entry,
+		...entry.scope === void 0 ? {} : { scope: redactSecrets(entry.scope) },
+		details: redactAuditValue(details)
 	};
 }
-function isCredentialFailure(category) {
-	return CREDENTIAL_CATEGORIES.has(category);
+/** Persists audit entry through the single audit log state write path. */
+function appendAuditEntry(stateDir, entry) {
+	const auditPath = getAuditPath(stateDir);
+	const prepared = prepareAuditEntry(entry);
+	enqueueAuditWrite(auditPath, `${JSON.stringify({
+		...prepared,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	})}\n`);
 }
-function isTerminalLlmFailure$1(category) {
-	return TERMINAL_CATEGORIES.has(category);
+/** Waits for the audit append; failures are logged without blocking the operation. */
+async function appendAuditEntryStrict(stateDir, entry) {
+	const auditPath = getAuditPath(stateDir);
+	const prepared = prepareAuditEntry(entry);
+	return enqueueAuditWrite(auditPath, `${JSON.stringify({
+		...prepared,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	})}\n`);
 }
-/** A status worth one more attempt against the same endpoint. */
-function isTransientLlmStatus(status) {
-	return status === 408 || status === 429 || status >= 500;
+/** Attempts a synchronous audit append and logs a failure. */
+function appendAuditEntrySync(stateDir, entry) {
+	const auditPath = getAuditPath(stateDir);
+	const prepared = prepareAuditEntry(entry);
+	try {
+		mkdirSync(path.dirname(auditPath), { recursive: true });
+		appendFileSync(auditPath, `${JSON.stringify({
+			...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",
+			file: "packages/memory/src/engine/operations/runtime-audit-log.ts",
+			function: "appendAuditEntrySync",
+			site_id: "memory.audit.sync.failed"
+		});
+	}
 }
-//#endregion
-//#region src/model/llmix-registry.ts
-/** @file llmix-registry.ts
-* @purpose Loads the bundled signed LLMIx registry for sno-station-mem.
-* @boundary Trust-anchor verification and package-relative asset resolution only.
-*/
-const SNO_STATION_MEM_RELEASE_ANCHOR_URL = FIXED_EXTERNAL_VALUE_8;
-const SNO_STATION_MEM_RELEASE_KEY_ID = FIXED_EXTERNAL_VALUE_9;
-const SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS = 2;
-const SNO_STATION_MEM_RELEASE_ANCHOR_RETRY_DELAY_MS = 50;
-const ALLOWED_HTTP_ENDPOINT_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1"]);
-function parsePresetId(preset) {
-	const [module, presetName] = preset.split("/");
-	if (!module || !presetName) throw new Error(`sno-station-mem llm-client: invalid LLMIx preset id "${preset}"`);
+function memoryAuditDetails(operation, phase, operationId, details) {
 	return {
-		module,
-		preset: presetName
+		...details,
+		operation,
+		audit_phase: phase,
+		audit_operation_id: operationId
 	};
 }
-function assertSupportedProvider(provider) {
-	if (provider === "openai" || provider === "openrouter" || provider === "sno-gpu") return provider;
-	throw new Error(`sno-station-mem llm-client: unsupported LLMIx provider "${provider}"`);
+/** Records the start and outcome without using audit availability as admission. */
+async function runWithMemoryAudit(options) {
+	if (memoryAuditScope.getStore()) return options.run();
+	return memoryAuditScope.run(true, async () => {
+		const operationId = randomUUID();
+		await appendAuditEntryStrict(options.stateDir, {
+			event: options.event,
+			scope: options.scope,
+			resultStatus: "partial",
+			details: memoryAuditDetails(options.operation, "started", operationId, options.startedDetails)
+		});
+		let result;
+		try {
+			result = await options.run();
+		} catch (error) {
+			await appendAuditEntryStrict(options.stateDir, {
+				event: options.event,
+				scope: options.scope,
+				resultStatus: "error",
+				errorCode: "memory_operation_failed",
+				details: memoryAuditDetails(options.operation, "failed", operationId, options.startedDetails)
+			});
+			throw error;
+		}
+		await appendAuditEntryStrict(options.stateDir, {
+			event: options.event,
+			scope: options.scope,
+			resultStatus: "ok",
+			details: memoryAuditDetails(options.operation, "completed", operationId, options.completedDetails(result))
+		});
+		return result;
+	});
 }
-function resolveEndpointBase(baseSource, preservePath) {
-	let parsed;
-	try {
-		parsed = new URL(baseSource);
-	} catch {
-		throw new Error(`sno-station-mem llm-client: invalid extraction.llm.baseURL "${baseSource}"`);
+async function readOpenMutationAttempts(stateDir) {
+	const auditPath = getAuditPath(stateDir);
+	if (!existsSync(auditPath)) return [];
+	const openAttempts = /* @__PURE__ */ new Map();
+	for await (const line of readJsonlLines(auditPath)) {
+		if (!line.trim()) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (!isRecord$1(parsed) || !isRecord$1(parsed["details"])) continue;
+		const event = parsed["event"];
+		const decision = parsed["decision"];
+		const details = parsed["details"];
+		const attemptId = details["audit_operation_id"];
+		if (typeof attemptId !== "string") continue;
+		if (details["mutation_outcome"] !== void 0) {
+			openAttempts.delete(attemptId);
+			continue;
+		}
+		if (decision !== "mutation-attempt-open" || details["audit_phase"] !== "started" || event !== "memory_updated" && event !== "memory_superseded" || typeof details["operation"] !== "string" || details["mutation_writer"] !== "profile-section" && details["mutation_writer"] !== "task-lifecycle" && details["mutation_writer"] !== "legacy-profile-refusal") continue;
+		openAttempts.set(attemptId, {
+			event,
+			operation: details["operation"],
+			attemptId,
+			writer: details["mutation_writer"],
+			...typeof details["mutation_subject"] === "string" ? { subject: details["mutation_subject"] } : {}
+		});
 	}
-	if (parsed.protocol !== "https:" && !ALLOWED_HTTP_ENDPOINT_HOSTS.has(parsed.hostname)) throw new Error("sno-station-mem llm-client: extraction.llm.baseURL must use https");
-	if (parsed.protocol === "https:" && parsed.hostname.toLowerCase() === "api.openai.com") throw new Error("sno-station-mem llm-client: direct api.openai.com transport is forbidden; use local ccproxy or an explicit custom endpoint");
-	if (!preservePath) return parsed.origin;
-	const base = parsed.toString();
-	return base.endsWith("/") ? base : `${base}/`;
-}
-function packageRootFromImportMeta() {
-	const moduleDir = path.dirname(fileURLToPath(import.meta.url));
-	const bundledRoot = path.resolve(moduleDir, "..");
-	return [bundledRoot, path.resolve(moduleDir, "../..")].find(hasBundledRegistryAssets) ?? bundledRoot;
-}
-function hasBundledRegistryAssets(packageRoot) {
-	return existsSync(path.join(packageRoot, "config", "llm", "current.json")) && existsSync(path.join(packageRoot, "config", "llm.trust.json"));
+	return [...openAttempts.values()];
 }
-function resolveBundledLlmixRegistryPaths(packageRoot = packageRootFromImportMeta()) {
-	const registryDir = path.join(packageRoot, "config", "llm");
-	const trustManifestPath = path.join(packageRoot, "config", "llm.trust.json");
-	if (!hasBundledRegistryAssets(packageRoot)) throw new Error("sno-station-mem LLMIx registry assets are missing from the installed package");
+function mutationAuditDetails(input) {
 	return {
-		registryDir,
-		trustManifestPath
+		operation: input.operation,
+		audit_phase: input.phase,
+		audit_operation_id: input.attemptId,
+		mutation_writer: input.writer,
+		...input.subject === void 0 ? {} : { mutation_subject: input.subject },
+		...input.outcome === void 0 ? {} : { mutation_outcome: input.outcome },
+		...input.refusalReason === void 0 ? {} : { refusal_reason: input.refusalReason }
 	};
 }
-function isJsonObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readPublicKeyJwk(document) {
-	if (!isJsonObject(document) || document.id !== "did:web:www.sno.ai") return null;
-	const methods = document.verificationMethod;
-	if (!Array.isArray(methods)) return null;
-	for (const method of methods) {
-		if (!isJsonObject(method) || method.id !== SNO_STATION_MEM_RELEASE_KEY_ID) continue;
-		const jwk = method.publicKeyJwk;
-		if (isJsonObject(jwk) && jwk.kty === "OKP" && jwk.crv === "Ed25519" && typeof jwk.x === "string") return jwk;
-	}
-	return null;
+function mutationAuditStatus(outcome) {
+	if (outcome === "failed" || outcome === "interrupted-unknown") return "error";
+	if (outcome.startsWith("refused-")) return "skipped";
+	return "ok";
 }
-function verifyEd25519(jwk, paeBytes, signature) {
-	const publicKey = createPublicKey({
-		key: jwk,
-		format: "jwk"
+async function closeMutationAttempt(stateDir, attempt, completion) {
+	const phase = completion.outcome === "failed" || completion.outcome === "interrupted-unknown" ? "failed" : "completed";
+	await appendAuditEntryStrict(stateDir, {
+		event: attempt.event,
+		resultStatus: mutationAuditStatus(completion.outcome),
+		decision: completion.outcome,
+		details: mutationAuditDetails({
+			operation: attempt.operation,
+			phase,
+			attemptId: attempt.attemptId,
+			writer: attempt.writer,
+			...attempt.subject === void 0 ? {} : { subject: attempt.subject },
+			outcome: completion.outcome,
+			...completion.refusalReason === void 0 ? {} : { refusalReason: completion.refusalReason }
+		})
 	});
-	return verify(null, Buffer$1.from(paeBytes), publicKey, Buffer$1.from(signature, "base64"));
-}
-function releaseAnchorFailureMessage(error) {
-	if (!isJsonObject(error) || !isJsonObject(error.details)) return null;
-	const cause = error.details.cause;
-	if (typeof cause !== "string") return null;
-	return cause.includes("sno-station-mem LLMIx release anchor fetch") ? cause : null;
 }
-async function fetchReleaseAnchorOnce(fetchImpl, timeoutMs) {
-	const controller = new AbortController();
-	let timeout;
-	const timeoutPromise = new Promise((_resolve, reject) => {
-		timeout = setTimeout(() => {
-			controller.abort();
-			reject(/* @__PURE__ */ new Error(`sno-station-mem LLMIx release anchor fetch timed out after ${timeoutMs}ms`));
-		}, timeoutMs);
-	});
-	try {
-		return await Promise.race([fetchImpl(SNO_STATION_MEM_RELEASE_ANCHOR_URL, { signal: controller.signal }), timeoutPromise]);
-	} finally {
-		if (timeout !== void 0) clearTimeout(timeout);
-	}
+/** Closes mutation attempts whose process stopped before a terminal audit record was written. */
+async function recoverInterruptedMutationAttempts(stateDir) {
+	const attempts = await readOpenMutationAttempts(stateDir);
+	for (const attempt of attempts) await closeMutationAttempt(stateDir, attempt, { outcome: "interrupted-unknown" });
+	return attempts.map((attempt) => attempt.attemptId);
 }
-function isTransientAnchorResponse(response) {
-	return isTransientLlmStatus(response.status);
+function ensureMutationRecovery(stateDir) {
+	const existing = mutationRecoveryPromises.get(stateDir);
+	if (existing) return existing;
+	const recovery = recoverInterruptedMutationAttempts(stateDir).then(() => void 0);
+	mutationRecoveryPromises.set(stateDir, recovery);
+	return recovery;
 }
-async function fetchReleaseAnchor(fetchImpl, timeoutMs) {
-	for (let attempt = 1; attempt <= SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS; attempt++) {
+/** Runs one mutation under a durable open record and exactly one terminal outcome. */
+async function runWithMutationAttempt(options) {
+	if (mutationAttemptScope.getStore()) return options.run();
+	await ensureMutationRecovery(options.stateDir);
+	const attempt = {
+		event: options.event,
+		operation: options.operation,
+		attemptId: randomUUID(),
+		writer: options.writer,
+		...options.subject === void 0 ? {} : { subject: options.subject }
+	};
+	return mutationAttemptScope.run(attempt.attemptId, async () => {
+		await appendAuditEntryStrict(options.stateDir, {
+			event: options.event,
+			resultStatus: "partial",
+			decision: "mutation-attempt-open",
+			details: mutationAuditDetails({
+				operation: attempt.operation,
+				phase: "started",
+				attemptId: attempt.attemptId,
+				writer: attempt.writer,
+				...attempt.subject === void 0 ? {} : { subject: attempt.subject }
+			})
+		});
+		let result;
 		try {
-			const response = await fetchReleaseAnchorOnce(fetchImpl, timeoutMs);
-			if (attempt === SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS || !isTransientAnchorResponse(response)) return response;
+			result = await options.run();
 		} catch (error) {
-			if (attempt === SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS) throw error;
+			await closeMutationAttempt(options.stateDir, attempt, options.failedOutcome?.(error) ?? { outcome: "failed" });
+			throw error;
 		}
-		await new Promise((resolve) => setTimeout(resolve, SNO_STATION_MEM_RELEASE_ANCHOR_RETRY_DELAY_MS));
-	}
+		await closeMutationAttempt(options.stateDir, attempt, options.completedOutcome(result));
+		return result;
+	});
+}
+/** Returns the durable identifier owned by the current mutation boundary. */
+function currentMutationAttemptId() {
+	const attemptId = mutationAttemptScope.getStore();
+	if (!attemptId) throw new Error("mutation attempt identifier requested outside a mutation boundary");
+	return attemptId;
+}
+/** Runs a synchronous memory operation only after its durable start record is persisted. */
+function runWithMemoryAuditSync(options) {
+	if (memoryAuditScope.getStore()) return options.run();
+	return memoryAuditScope.run(true, () => {
+		const operationId = randomUUID();
+		appendAuditEntrySync(options.stateDir, {
+			event: options.event,
+			scope: options.scope,
+			resultStatus: "partial",
+			details: memoryAuditDetails(options.operation, "started", operationId, options.startedDetails)
+		});
+		let result;
+		try {
+			result = options.run();
+		} catch (error) {
+			appendAuditEntrySync(options.stateDir, {
+				event: options.event,
+				scope: options.scope,
+				resultStatus: "error",
+				errorCode: "memory_operation_failed",
+				details: memoryAuditDetails(options.operation, "failed", operationId, options.startedDetails)
+			});
+			throw error;
+		}
+		appendAuditEntrySync(options.stateDir, {
+			event: options.event,
+			scope: options.scope,
+			resultStatus: "ok",
+			details: memoryAuditDetails(options.operation, "completed", operationId, options.completedDetails(result))
+		});
+		return result;
+	});
+}
+//#endregion
+//#region src/model/llm-failure.ts
+const CREDENTIAL_CATEGORIES = /* @__PURE__ */ new Set([
+	"auth",
+	"credential-expired",
+	"credential-revoked"
+]);
+const TERMINAL_CATEGORIES = /* @__PURE__ */ new Set([...CREDENTIAL_CATEGORIES, "exhausted"]);
+function isCredentialRevokedMessage(message) {
+	return /oauth token refresh failed for openai:.*\binvalid_grant\b.*\btoken revoked\b/i.test(message);
+}
+function isCredentialExpiredMessage(message) {
+	return /\bexpired access token\b/i.test(message);
+}
+function isAuthMessage(message) {
+	return /\b(?:401|403)\b/.test(message) || /unauthori[sz]ed/i.test(message) || /no api key found/i.test(message) || /(?:invalid|incorrect) api[- ]?key/i.test(message) || /(?:invalid|expired) (?:access |oauth )?token/i.test(message) || /(?:api[- ]?key|token).*(?:invalid|expired|rejected)/i.test(message) || /credential (?:is )?(?:invalid|expired|rejected)/i.test(message) || /no (?:valid )?credential (?:found|available|configured)/i.test(message) || /re-?authenticate/i.test(message) || /no authentication configured/i.test(message);
+}
+function isExhaustedMessage(message) {
+	return /you(?:'|’)ve reached your codex subscription usage limit/i.test(message);
+}
+function isThrottleMessage(message) {
+	return /\b429\b/.test(message) || /rate.?limit/i.test(message) || /quota/i.test(message);
+}
+function categoryOf(status, message) {
+	if (isCredentialRevokedMessage(message)) return "credential-revoked";
+	if (isCredentialExpiredMessage(message)) return "credential-expired";
+	if (status === 401 || status === 403 || isAuthMessage(message)) return "auth";
+	if (isExhaustedMessage(message)) return "exhausted";
+	if (status === 429 || isThrottleMessage(message)) return "throttle";
+	if (status !== void 0 && (status === 404 || status === 408 || status >= 500)) return "transport";
+	return "unknown";
+}
+/** Classifies one failed model call from whatever the transport surfaced: a status, a message, or both. */
+function classifyLlmFailure(input) {
+	const category = categoryOf(input.status, input.message ?? "");
+	const terminal = TERMINAL_CATEGORIES.has(category);
+	return {
+		category,
+		terminal,
+		endpointRefused: terminal || input.status === 404 || input.status === 503
+	};
+}
+function isCredentialFailure(category) {
+	return CREDENTIAL_CATEGORIES.has(category);
+}
+function isTerminalLlmFailure$1(category) {
+	return TERMINAL_CATEGORIES.has(category);
+}
+/** A status worth one more attempt against the same endpoint. */
+function isTransientLlmStatus(status) {
+	return status === 408 || status === 429 || status >= 500;
+}
+//#endregion
+//#region src/model/llmix-registry.ts
+/** @file llmix-registry.ts
+* @purpose Loads the bundled signed LLMIx registry for sno-station-mem.
+* @boundary Trust-anchor verification and package-relative asset resolution only.
+*/
+const SNO_STATION_MEM_RELEASE_ANCHOR_URL = FIXED_EXTERNAL_VALUE_8;
+const SNO_STATION_MEM_RELEASE_KEY_ID = FIXED_EXTERNAL_VALUE_9;
+const SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS = 2;
+const SNO_STATION_MEM_RELEASE_ANCHOR_RETRY_DELAY_MS = 50;
+const ALLOWED_HTTP_ENDPOINT_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1"]);
+function parsePresetId(preset) {
+	const [module, presetName] = preset.split("/");
+	if (!module || !presetName) throw new Error(`sno-station-mem llm-client: invalid LLMIx preset id "${preset}"`);
+	return {
+		module,
+		preset: presetName
+	};
+}
+function assertSupportedProvider(provider) {
+	if (provider === "openai" || provider === "openrouter" || provider === "sno-gpu") return provider;
+	throw new Error(`sno-station-mem llm-client: unsupported LLMIx provider "${provider}"`);
+}
+function resolveEndpointBase(baseSource, preservePath) {
+	let parsed;
+	try {
+		parsed = new URL(baseSource);
+	} catch {
+		throw new Error(`sno-station-mem llm-client: invalid extraction.llm.baseURL "${baseSource}"`);
+	}
+	if (parsed.protocol !== "https:" && !ALLOWED_HTTP_ENDPOINT_HOSTS.has(parsed.hostname)) throw new Error("sno-station-mem llm-client: extraction.llm.baseURL must use https");
+	if (parsed.protocol === "https:" && parsed.hostname.toLowerCase() === "api.openai.com") throw new Error("sno-station-mem llm-client: direct api.openai.com transport is forbidden; use local ccproxy or an explicit custom endpoint");
+	if (!preservePath) return parsed.origin;
+	const base = parsed.toString();
+	return base.endsWith("/") ? base : `${base}/`;
+}
+function packageRootFromImportMeta() {
+	const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+	const bundledRoot = path.resolve(moduleDir, "..");
+	return [bundledRoot, path.resolve(moduleDir, "../..")].find(hasBundledRegistryAssets) ?? bundledRoot;
+}
+function hasBundledRegistryAssets(packageRoot) {
+	return existsSync(path.join(packageRoot, "config", "llm", "current.json")) && existsSync(path.join(packageRoot, "config", "llm.trust.json"));
+}
+function resolveBundledLlmixRegistryPaths(packageRoot = packageRootFromImportMeta()) {
+	const registryDir = path.join(packageRoot, "config", "llm");
+	const trustManifestPath = path.join(packageRoot, "config", "llm.trust.json");
+	if (!hasBundledRegistryAssets(packageRoot)) throw new Error("sno-station-mem LLMIx registry assets are missing from the installed package");
+	return {
+		registryDir,
+		trustManifestPath
+	};
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readPublicKeyJwk(document) {
+	if (!isJsonObject(document) || document.id !== "did:web:www.sno.ai") return null;
+	const methods = document.verificationMethod;
+	if (!Array.isArray(methods)) return null;
+	for (const method of methods) {
+		if (!isJsonObject(method) || method.id !== SNO_STATION_MEM_RELEASE_KEY_ID) continue;
+		const jwk = method.publicKeyJwk;
+		if (isJsonObject(jwk) && jwk.kty === "OKP" && jwk.crv === "Ed25519" && typeof jwk.x === "string") return jwk;
+	}
+	return null;
+}
+function verifyEd25519(jwk, paeBytes, signature) {
+	const publicKey = createPublicKey({
+		key: jwk,
+		format: "jwk"
+	});
+	return verify(null, Buffer$1.from(paeBytes), publicKey, Buffer$1.from(signature, "base64"));
+}
+function releaseAnchorFailureMessage(error) {
+	if (!isJsonObject(error) || !isJsonObject(error.details)) return null;
+	const cause = error.details.cause;
+	if (typeof cause !== "string") return null;
+	return cause.includes("sno-station-mem LLMIx release anchor fetch") ? cause : null;
+}
+async function fetchReleaseAnchorOnce(fetchImpl, timeoutMs) {
+	const controller = new AbortController();
+	let timeout;
+	const timeoutPromise = new Promise((_resolve, reject) => {
+		timeout = setTimeout(() => {
+			controller.abort();
+			reject(/* @__PURE__ */ new Error(`sno-station-mem LLMIx release anchor fetch timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+	});
+	try {
+		return await Promise.race([fetchImpl(SNO_STATION_MEM_RELEASE_ANCHOR_URL, { signal: controller.signal }), timeoutPromise]);
+	} finally {
+		if (timeout !== void 0) clearTimeout(timeout);
+	}
+}
+function isTransientAnchorResponse(response) {
+	return isTransientLlmStatus(response.status);
+}
+async function fetchReleaseAnchor(fetchImpl, timeoutMs) {
+	for (let attempt = 1; attempt <= SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS; attempt++) {
+		try {
+			const response = await fetchReleaseAnchorOnce(fetchImpl, timeoutMs);
+			if (attempt === SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS || !isTransientAnchorResponse(response)) return response;
+		} catch (error) {
+			if (attempt === SNO_STATION_MEM_RELEASE_ANCHOR_ATTEMPTS) throw error;
+		}
+		await new Promise((resolve) => setTimeout(resolve, SNO_STATION_MEM_RELEASE_ANCHOR_RETRY_DELAY_MS));
+	}
 	throw new Error("sno-station-mem LLMIx release anchor fetch exhausted");
 }
 function createSnoMemSnoStationMemDidWebVerifier(fetchImpl = globalThis.fetch, options = {}) {
@@ -6051,7 +6601,10 @@ function materializeBundledLlmixEndpoint(input) {
 	if (!path) throw new Error(`sno-station-mem llm-client: signed endpoint path missing from preset ${input.preset.preset}`);
 	return {
 		url: new URL(path, resolveEndpointBase(input.baseSource, input.preset.provider !== "sno-gpu")).toString(),
-		preset: input.preset
+		preset: input.preset.provider === "sno-gpu" && path === "/extract/profile/v1/completions" ? {
+			...input.preset,
+			model: "b-profile"
+		} : input.preset
 	};
 }
 async function resolveConfiguredBundledLlmixEndpoint(input) {
@@ -6672,6 +7225,7 @@ function normalizeMemoryLlmRequest(value) {
 	const emptyReplyAttempts = raw.emptyReplyAttempts;
 	if (emptyReplyAttempts !== void 0 && (!Number.isInteger(emptyReplyAttempts) || Number(emptyReplyAttempts) < 1 || Number(emptyReplyAttempts) > EMPTY_REPLY_ATTEMPTS)) throw new Error(`sno-station-mem llm-client: emptyReplyAttempts must be an integer from 1 to ${EMPTY_REPLY_ATTEMPTS}`);
 	const enableThinking = raw.enableThinking;
+	const takeProviderAttempt = raw.takeProviderAttempt;
 	if (enableThinking !== void 0 && typeof enableThinking !== "boolean") throw new Error("sno-station-mem llm-client: enableThinking must be a boolean");
 	const signal = raw.signal;
 	if (signal !== void 0 && !hasAbortSignalShape(signal)) throw new Error("sno-station-mem llm-client: signal must be an AbortSignal");
@@ -6685,6 +7239,7 @@ function normalizeMemoryLlmRequest(value) {
 		...maxTokens !== void 0 ? { maxTokens: Number(maxTokens) } : {},
 		...emptyReplyAttempts !== void 0 ? { emptyReplyAttempts: Number(emptyReplyAttempts) } : {},
 		...enableThinking !== void 0 ? { enableThinking } : {},
+		...typeof takeProviderAttempt === "function" ? { takeProviderAttempt: () => takeProviderAttempt() === true } : {},
 		...requestId !== void 0 ? { requestId } : {},
 		...typeof raw.promptTemplateHash === "string" && /^[a-f0-9]{64}$/.test(raw.promptTemplateHash) ? { promptTemplateHash: raw.promptTemplateHash } : {},
 		...typeof raw.extractionSkillHash === "string" && /^[a-f0-9]{64}$/.test(raw.extractionSkillHash) ? { extractionSkillHash: raw.extractionSkillHash } : {},
@@ -6692,7 +7247,9 @@ function normalizeMemoryLlmRequest(value) {
 	};
 }
 function textSystemContent(request) {
-	return MODEL_CALLS[request.callId].occasion === "conflictAdjudication" ? CONFLICT_ADJUDICATION_SYSTEM_CONTENT : REFLECTION_TEXT_SYSTEM_CONTENT;
+	const occasion = MODEL_CALLS[request.callId].occasion;
+	if (occasion === "conflictAdjudication") return CONFLICT_ADJUDICATION_SYSTEM_CONTENT;
+	return occasion === "memoryExtract" ? JSON_SYSTEM_CONTENT : REFLECTION_TEXT_SYSTEM_CONTENT;
 }
 /** Creates the LLM client facade with provider routing, key rotation, and JSON parsing. */
 function createLlmClient(config) {
@@ -6722,8 +7279,29 @@ function createLlmClient(config) {
 		}
 		return endpointPromise;
 	};
+	const providerBudget = new AsyncLocalStorage();
 	const pipeline = new CallPipeline({
-		dispatch: callProvider,
+		dispatch: async (context) => {
+			const budget = providerBudget.getStore();
+			if (!budget) return callProvider(context);
+			const timeoutMs = Math.floor(budget.deadlineMs - performance.now());
+			if (timeoutMs <= 0) throw Object.assign(/* @__PURE__ */ new Error("Request deadline exhausted before provider dispatch"), { statusCode: 499 });
+			if (budget.remaining <= 0 || budget.takeProviderAttempt && !budget.takeProviderAttempt()) throw Object.assign(/* @__PURE__ */ new Error("Provider request attempts exhausted"), { statusCode: 499 });
+			budget.remaining -= 1;
+			const providerConfig = context.config;
+			const dispatchConfig = {
+				...providerConfig,
+				timeoutMs,
+				...providerConfig.rawCompletion ? { rawCompletion: {
+					...providerConfig.rawCompletion,
+					timeoutMs
+				} } : {}
+			};
+			return callProvider({
+				...context,
+				config: dispatchConfig
+			});
+		},
 		maxRetries: 2,
 		retryBaseMs: 100,
 		retryMaxDelayMs: 500,
@@ -6795,6 +7373,7 @@ function createLlmClient(config) {
 		if (transport === "agent-host-seam") {
 			const agentPort = config.agentPort;
 			if (!agentPort) throw new LlmClientTerminalError("transport", `sno-station-mem: llm-client [${request.callId}] AgentLlmPort is unavailable`);
+			if (request.takeProviderAttempt && !request.takeProviderAttempt()) return null;
 			config.onTransportAttempt?.({
 				callId: request.callId,
 				destination,
@@ -7037,13 +7616,18 @@ function createLlmClient(config) {
 	* result is returned untouched — it means no call was made, not that the model said nothing.
 	*/
 	const requestContentRetryingEmpty = async (state, request, systemContent, deadlineMs, prompt = request.prompt) => {
-		let content = await requestContent(state, request, systemContent, prompt);
+		const budget = {
+			remaining: EMPTY_REPLY_ATTEMPTS,
+			deadlineMs,
+			takeProviderAttempt: request.takeProviderAttempt
+		};
+		let content = await providerBudget.run(budget, () => requestContent(state, request, systemContent, prompt));
 		let usage = state.usage;
 		try {
 			checkMemoryOperation();
 			const attemptLimit = request.emptyReplyAttempts ?? EMPTY_REPLY_ATTEMPTS;
 			for (let attempt = 2; attempt <= attemptLimit; attempt += 1) {
-				if (content === null || content.raw.trim().length > 0) break;
+				if (content === null || content.raw.trim().length > 0 || budget.remaining <= 0) break;
 				const remainingMs = deadlineMs - performance.now();
 				if (remainingMs <= 0) break;
 				log$20.debug("Retrying empty model reply", {
@@ -7057,10 +7641,10 @@ function createLlmClient(config) {
 					function: "requestContentRetryingEmpty",
 					site_id: "shared.llm-client.requestContentRetryingEmpty.cd874fefff"
 				});
-				content = await requestContent(state, {
+				content = await providerBudget.run(budget, () => requestContent(state, {
 					...request,
 					timeoutMs: remainingMs
-				}, systemContent, prompt);
+				}, systemContent, prompt));
 				usage = addUsage(usage, state.usage);
 				checkMemoryOperation();
 			}
@@ -7085,6 +7669,7 @@ function createLlmClient(config) {
 			if (snoError !== void 0) throw snoError;
 			return content;
 		}
+		const remainingMs = Math.floor(deadlineMs - performance.now());
 		const originalLastError = state.error;
 		const originalLastUsage = state.usage;
 		const source = snoError instanceof Error ? snoError.message : originalLastError ?? "";
@@ -7096,21 +7681,25 @@ function createLlmClient(config) {
 		else if (!config.apiKey?.trim()) snoFailure = "missing_key";
 		const operationId = config.operationId ?? memoryOperationId();
 		let hostFailure = "empty_reply";
-		if (!config.agentPort) hostFailure = "port_unavailable";
+		if (remainingMs <= 0) hostFailure = "deadline_exhausted";
+		else if (!config.agentPort) hostFailure = "port_unavailable";
 		else if ([
 			"E10",
 			"P1",
 			"REM1"
 		].includes(request.callId) && !request.hostPrompt) hostFailure = "host_prompt_missing";
 		else try {
-			const host = await requestContent(state, request, systemContent, request.hostPrompt ?? request.prompt, "host");
+			const host = await requestContent(state, {
+				...request,
+				timeoutMs: remainingMs
+			}, systemContent, request.hostPrompt ?? request.prompt, "host");
 			if (host?.raw.trim()) {
 				log$20.info("Sno model call answered by host", {
 					call_id: request.callId,
 					operation_id: operationId,
 					sno_failure: snoFailure,
 					host_outcome: "answered",
-					timeout_ms: resolveRequestTimeoutMs(request)
+					timeout_ms: remainingMs
 				}, {
 					event_name: "memory.llm_client.fallback",
 					file: "packages/memory/src/model/llm-client.ts",
@@ -7122,7 +7711,7 @@ function createLlmClient(config) {
 			}
 			if (host === null) hostFailure = "host_error";
 		} catch (error) {
-			if (request.signal?.aborted) throw error;
+			if (request.signal?.aborted || error instanceof ModelCallRefusedError) throw error;
 			hostFailure = error instanceof LlmClientTerminalError ? error.category : "transport";
 		}
 		state.error = originalLastError;
@@ -7267,7 +7856,7 @@ function createLlmClient(config) {
 //#region src/engine/security/scope-policy-types.ts
 const DEFAULT_SCOPE_CONFIG = {
 	default: "global",
-	definitions: { global: { description: "Shared knowledge across all agents" } },
+	definitions: { global: { description: "Knowledge used by all your agents" } },
 	agentAccess: {},
 	extraAccessibleScopes: []
 };
@@ -7361,7 +7950,7 @@ var MemoryScopePolicy = class {
 			},
 			extraAccessibleScopes: normalizeExtraAccessibleScopes(config.extraAccessibleScopes ?? DEFAULT_SCOPE_CONFIG.extraAccessibleScopes)
 		};
-		if (!this.config.definitions.global) this.config.definitions.global = { description: "Shared knowledge across all agents" };
+		if (!this.config.definitions.global) this.config.definitions.global = { description: "Knowledge used by all your agents" };
 		this.validateConfiguration();
 	}
 	validateConfiguration() {
@@ -14321,487 +14910,77 @@ async function resolveMemoryDate(input) {
 			}
 		};
 	}
-	const stage = {
-		modelCalled: true,
-		reason: reply.reason
-	};
-	const calculated = calculateCalendarTime(reply.time, anchor, unresolved.timezone);
-	log$17.info("Memory date resolution completed", {
-		model_called: true,
-		resolved: calculated !== null
-	}, {
-		event_name: "sno_station_mem.date-resolution.date.resolution.stage",
-		file: "packages/memory/src/engine/extraction/date-resolution.ts",
-		function: "resolveMemoryDate",
-		site_id: "date-resolution.resolveMemoryDate.1224fa35b2"
-	});
-	if (reply.time.kind === "none") return {
-		...unresolved,
-		interval: {
-			type: "static",
-			resolutionStatus: "static"
-		},
-		stage
-	};
-	if (!calculated) return {
-		...unresolved,
-		stage
-	};
-	return {
-		interval: {
-			type: "bounded",
-			resolutionStatus: "resolved",
-			from: calculated.from,
-			until: calculated.until,
-			phrase: input.expression ?? input.text,
-			date: calculated.label,
-			precision: calculated.precision,
-			timezone: calculated.timezone
-		},
-		timestamp: unresolved.timestamp,
-		timezone: unresolved.timezone,
-		stage
-	};
-}
-//#endregion
-//#region src/engine/extraction/memory-temporality-classifier.ts
-function parseSessionTimestamp(sessionDateTime) {
-	return parseIsoDateTimeMs(sessionDateTime);
-}
-function serializeIntervalMetadata(category, interval) {
-	if (interval.type === "static") return {
-		memory_temporal_type: "static",
-		temporal_resolution_status: "static"
-	};
-	const base = {
-		memory_temporal_type: "dynamic",
-		temporal_resolution_status: interval.resolutionStatus
-	};
-	if ("phrase" in interval && interval.phrase) base.temporal_phrase = interval.phrase;
-	if (interval.type === "instant") {
-		if (category === "episodic") base.event_at = interval.at;
-		base.valid_from = interval.at;
-	} else if (interval.type === "bounded") {
-		base.valid_from = interval.from;
-		if (category === "episodic") base.valid_until = interval.until;
-		if (interval.date !== void 0) base.temporal_date = interval.date;
-		if (interval.precision !== void 0) base.temporal_precision = interval.precision;
-		if (interval.timezone !== void 0) base.temporal_timezone = interval.timezone;
-	} else if (interval.type === "ongoing") {
-		base.valid_from = interval.from;
-		if (interval.until !== void 0) base.valid_until = interval.until;
-	}
-	return base;
-}
-//#endregion
-//#region src/engine/operations/jsonl-lines.ts
-const log$16 = createLogger("sno-station-mem:jsonl");
-/** Preserve complete records without materializing an unbounded log as one string. */
-async function* readJsonlLines(file) {
-	const stream = createReadStream(file, { encoding: "utf8" });
-	const lines = createInterface({
-		input: stream,
-		crlfDelay: Infinity
-	});
-	try {
-		for await (const line of lines) if (line.trim()) yield line;
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
-		log$16.error("jsonl.read.failed", {
-			file,
-			error
-		}, {
-			event_name: "memory.jsonl.read.failed",
-			file: "packages/memory/src/engine/operations/jsonl-lines.ts",
-			function: "readJsonlLines",
-			site_id: "memory.jsonl.read.failed"
-		});
-	} finally {
-		lines.close();
-		stream.destroy();
-	}
-}
-//#endregion
-//#region src/engine/operations/runtime-audit-log.ts
-/** @file runtime-audit-log.ts
-* @purpose Records audit events for operational visibility and safety-sensitive actions.
-* @boundary Plugin runtime events and filesystem-backed audit persistence.
-* @see sno-station-mem-plugin-runtime.ts, memory-tool-registration.ts, errors.ts.
-*/
-const auditWriteQueues = /* @__PURE__ */ new Map();
-const memoryAuditScope = new AsyncLocalStorage();
-const mutationAttemptScope = new AsyncLocalStorage();
-const mutationRecoveryPromises = /* @__PURE__ */ new Map();
-const MEMORY_AUDIT_COMMON_KEYS = [
-	"operation",
-	"audit_phase",
-	"audit_operation_id"
-];
-const MUTATION_AUDIT_DETAIL_KEYS = [
-	"mutation_writer",
-	"mutation_subject",
-	"mutation_outcome",
-	"refusal_reason"
-];
-const MEMORY_AUDIT_ALLOWED_DETAIL_KEYS = {
-	memory_injected: /* @__PURE__ */ new Set([
-		...MEMORY_AUDIT_COMMON_KEYS,
-		"scope",
-		"category",
-		"lane",
-		"count",
-		"memory_ids",
-		"write_outcome",
-		"created_count",
-		"existing_count"
-	]),
-	memory_searched: /* @__PURE__ */ new Set([
-		...MEMORY_AUDIT_COMMON_KEYS,
-		"scope",
-		"query_kind",
-		"requested_count",
-		"result_count",
-		"memory_ids"
-	]),
-	memory_read: /* @__PURE__ */ new Set([
-		...MEMORY_AUDIT_COMMON_KEYS,
-		"scope",
-		"requested_count",
-		"result_count",
-		"memory_ids",
-		"requested_fact_id",
-		"resolved_fact_id",
-		"fact_ids",
-		"found",
-		"outcome"
-	]),
-	memory_updated: /* @__PURE__ */ new Set([
-		...MEMORY_AUDIT_COMMON_KEYS,
-		...MUTATION_AUDIT_DETAIL_KEYS,
-		"scope",
-		"requested_count",
-		"result_count",
-		"memory_ids",
-		"outcome",
-		"migration_status",
-		"rewritten_rows",
-		"checked_rows"
-	]),
-	memory_superseded: /* @__PURE__ */ new Set([
-		...MEMORY_AUDIT_COMMON_KEYS,
-		...MUTATION_AUDIT_DETAIL_KEYS,
-		"scope",
-		"replacement_memory_id",
-		"closed_memory_ids",
-		"write_outcome"
-	]),
-	memory_deleted: /* @__PURE__ */ new Set([
-		...MEMORY_AUDIT_COMMON_KEYS,
-		"scope",
-		"deleted_memory_ids",
-		"delete_reason",
-		"count",
-		"outcome",
-		"removed_files"
-	]),
-	memory_purged: /* @__PURE__ */ new Set([
-		...MEMORY_AUDIT_COMMON_KEYS,
-		"target_fact_id",
-		"purged_fact_ids",
-		"failed_fact_ids",
-		"status",
-		"blocked_reason"
-	])
-};
-/** Implements enqueue audit write as the local audit log state operation. */
-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);
-		return true;
-	}).catch((error) => {
-		createLogger("sno-station-mem:audit").error("Audit entry append failed", { error }, {
-			event_name: "memory.audit.append.failed",
-			file: "packages/memory/src/engine/operations/runtime-audit-log.ts",
-			function: "enqueueAuditWrite",
-			site_id: "memory.audit.append.failed"
-		});
-		return false;
-	});
-	auditWriteQueues.set(auditPath, next);
-	next.finally(() => {
-		if (auditWriteQueues.get(auditPath) === next) auditWriteQueues.delete(auditPath);
-	});
-	return next;
-}
-/** Returns audit path from audit log state state without side effects. */
-function getAuditPath(stateDir) {
-	return path.join(stateDir, "audit.jsonl");
-}
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null;
-}
-function isMemoryAuditEvent(event) {
-	return event.startsWith("memory_");
-}
-function redactAuditValue(value) {
-	if (typeof value === "string") return redactSecrets(value);
-	if (Array.isArray(value)) return value.map(redactAuditValue);
-	if (!isRecord$1(value)) return value;
-	const redacted = {};
-	for (const [key, child] of Object.entries(value)) redacted[key] = redactAuditValue(child);
-	return redacted;
-}
-function prepareAuditEntry(entry) {
-	if (!isMemoryAuditEvent(entry.event) || entry.details?.["audit_phase"] === void 0) return entry;
-	const allowed = MEMORY_AUDIT_ALLOWED_DETAIL_KEYS[entry.event];
-	const details = {};
-	for (const [key, value] of Object.entries(entry.details)) if (allowed.has(key)) details[key] = value;
-	else createLogger("sno-station-mem:audit").error("memory.audit.detail.unknown", {
-		event: entry.event,
-		key
-	}, {
-		event_name: "memory.audit.detail.unknown",
-		file: "packages/memory/src/engine/operations/runtime-audit-log.ts",
-		function: "prepareAuditEntry",
-		site_id: "memory.audit.detail.unknown"
-	});
-	return {
-		...entry,
-		...entry.scope === void 0 ? {} : { scope: redactSecrets(entry.scope) },
-		details: redactAuditValue(details)
-	};
-}
-/** Persists audit entry through the single audit log state write path. */
-function appendAuditEntry(stateDir, entry) {
-	const auditPath = getAuditPath(stateDir);
-	const prepared = prepareAuditEntry(entry);
-	enqueueAuditWrite(auditPath, `${JSON.stringify({
-		...prepared,
-		timestamp: (/* @__PURE__ */ new Date()).toISOString()
-	})}\n`);
-}
-/** Waits for the audit append; failures are logged without blocking the operation. */
-async function appendAuditEntryStrict(stateDir, entry) {
-	const auditPath = getAuditPath(stateDir);
-	const prepared = prepareAuditEntry(entry);
-	return enqueueAuditWrite(auditPath, `${JSON.stringify({
-		...prepared,
-		timestamp: (/* @__PURE__ */ new Date()).toISOString()
-	})}\n`);
-}
-/** Attempts a synchronous audit append and logs a failure. */
-function appendAuditEntrySync(stateDir, entry) {
-	const auditPath = getAuditPath(stateDir);
-	const prepared = prepareAuditEntry(entry);
-	try {
-		mkdirSync(path.dirname(auditPath), { recursive: true });
-		appendFileSync(auditPath, `${JSON.stringify({
-			...prepared,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString()
-		})}\n`);
-	} catch (error) {
-		createLogger("sno-station-mem:audit").error("memory.audit.append.failed", { error }, {
-			event_name: "memory.audit.append.failed",
-			file: "packages/memory/src/engine/operations/runtime-audit-log.ts",
-			function: "appendAuditEntrySync",
-			site_id: "memory.audit.sync.failed"
-		});
-	}
-}
-function memoryAuditDetails(operation, phase, operationId, details) {
-	return {
-		...details,
-		operation,
-		audit_phase: phase,
-		audit_operation_id: operationId
-	};
-}
-/** Records the start and outcome without using audit availability as admission. */
-async function runWithMemoryAudit(options) {
-	if (memoryAuditScope.getStore()) return options.run();
-	return memoryAuditScope.run(true, async () => {
-		const operationId = randomUUID();
-		await appendAuditEntryStrict(options.stateDir, {
-			event: options.event,
-			scope: options.scope,
-			resultStatus: "partial",
-			details: memoryAuditDetails(options.operation, "started", operationId, options.startedDetails)
-		});
-		let result;
-		try {
-			result = await options.run();
-		} catch (error) {
-			await appendAuditEntryStrict(options.stateDir, {
-				event: options.event,
-				scope: options.scope,
-				resultStatus: "error",
-				errorCode: "memory_operation_failed",
-				details: memoryAuditDetails(options.operation, "failed", operationId, options.startedDetails)
-			});
-			throw error;
-		}
-		await appendAuditEntryStrict(options.stateDir, {
-			event: options.event,
-			scope: options.scope,
-			resultStatus: "ok",
-			details: memoryAuditDetails(options.operation, "completed", operationId, options.completedDetails(result))
-		});
-		return result;
-	});
-}
-async function readOpenMutationAttempts(stateDir) {
-	const auditPath = getAuditPath(stateDir);
-	if (!existsSync(auditPath)) return [];
-	const openAttempts = /* @__PURE__ */ new Map();
-	for await (const line of readJsonlLines(auditPath)) {
-		if (!line.trim()) continue;
-		let parsed;
-		try {
-			parsed = JSON.parse(line);
-		} catch {
-			continue;
-		}
-		if (!isRecord$1(parsed) || !isRecord$1(parsed["details"])) continue;
-		const event = parsed["event"];
-		const decision = parsed["decision"];
-		const details = parsed["details"];
-		const attemptId = details["audit_operation_id"];
-		if (typeof attemptId !== "string") continue;
-		if (details["mutation_outcome"] !== void 0) {
-			openAttempts.delete(attemptId);
-			continue;
-		}
-		if (decision !== "mutation-attempt-open" || details["audit_phase"] !== "started" || event !== "memory_updated" && event !== "memory_superseded" || typeof details["operation"] !== "string" || details["mutation_writer"] !== "profile-section" && details["mutation_writer"] !== "task-lifecycle" && details["mutation_writer"] !== "legacy-profile-refusal") continue;
-		openAttempts.set(attemptId, {
-			event,
-			operation: details["operation"],
-			attemptId,
-			writer: details["mutation_writer"],
-			...typeof details["mutation_subject"] === "string" ? { subject: details["mutation_subject"] } : {}
-		});
-	}
-	return [...openAttempts.values()];
-}
-function mutationAuditDetails(input) {
-	return {
-		operation: input.operation,
-		audit_phase: input.phase,
-		audit_operation_id: input.attemptId,
-		mutation_writer: input.writer,
-		...input.subject === void 0 ? {} : { mutation_subject: input.subject },
-		...input.outcome === void 0 ? {} : { mutation_outcome: input.outcome },
-		...input.refusalReason === void 0 ? {} : { refusal_reason: input.refusalReason }
+	const stage = {
+		modelCalled: true,
+		reason: reply.reason
 	};
-}
-function mutationAuditStatus(outcome) {
-	if (outcome === "failed" || outcome === "interrupted-unknown") return "error";
-	if (outcome.startsWith("refused-")) return "skipped";
-	return "ok";
-}
-async function closeMutationAttempt(stateDir, attempt, completion) {
-	const phase = completion.outcome === "failed" || completion.outcome === "interrupted-unknown" ? "failed" : "completed";
-	await appendAuditEntryStrict(stateDir, {
-		event: attempt.event,
-		resultStatus: mutationAuditStatus(completion.outcome),
-		decision: completion.outcome,
-		details: mutationAuditDetails({
-			operation: attempt.operation,
-			phase,
-			attemptId: attempt.attemptId,
-			writer: attempt.writer,
-			...attempt.subject === void 0 ? {} : { subject: attempt.subject },
-			outcome: completion.outcome,
-			...completion.refusalReason === void 0 ? {} : { refusalReason: completion.refusalReason }
-		})
+	const calculated = calculateCalendarTime(reply.time, anchor, unresolved.timezone);
+	log$17.info("Memory date resolution completed", {
+		model_called: true,
+		resolved: calculated !== null
+	}, {
+		event_name: "sno_station_mem.date-resolution.date.resolution.stage",
+		file: "packages/memory/src/engine/extraction/date-resolution.ts",
+		function: "resolveMemoryDate",
+		site_id: "date-resolution.resolveMemoryDate.1224fa35b2"
 	});
-}
-/** Closes mutation attempts whose process stopped before a terminal audit record was written. */
-async function recoverInterruptedMutationAttempts(stateDir) {
-	const attempts = await readOpenMutationAttempts(stateDir);
-	for (const attempt of attempts) await closeMutationAttempt(stateDir, attempt, { outcome: "interrupted-unknown" });
-	return attempts.map((attempt) => attempt.attemptId);
-}
-function ensureMutationRecovery(stateDir) {
-	const existing = mutationRecoveryPromises.get(stateDir);
-	if (existing) return existing;
-	const recovery = recoverInterruptedMutationAttempts(stateDir).then(() => void 0);
-	mutationRecoveryPromises.set(stateDir, recovery);
-	return recovery;
-}
-/** Runs one mutation under a durable open record and exactly one terminal outcome. */
-async function runWithMutationAttempt(options) {
-	if (mutationAttemptScope.getStore()) return options.run();
-	await ensureMutationRecovery(options.stateDir);
-	const attempt = {
-		event: options.event,
-		operation: options.operation,
-		attemptId: randomUUID(),
-		writer: options.writer,
-		...options.subject === void 0 ? {} : { subject: options.subject }
+	if (reply.time.kind === "none") return {
+		...unresolved,
+		interval: {
+			type: "static",
+			resolutionStatus: "static"
+		},
+		stage
+	};
+	if (!calculated) return {
+		...unresolved,
+		stage
+	};
+	return {
+		interval: {
+			type: "bounded",
+			resolutionStatus: "resolved",
+			from: calculated.from,
+			until: calculated.until,
+			phrase: input.expression ?? input.text,
+			date: calculated.label,
+			precision: calculated.precision,
+			timezone: calculated.timezone
+		},
+		timestamp: unresolved.timestamp,
+		timezone: unresolved.timezone,
+		stage
 	};
-	return mutationAttemptScope.run(attempt.attemptId, async () => {
-		await appendAuditEntryStrict(options.stateDir, {
-			event: options.event,
-			resultStatus: "partial",
-			decision: "mutation-attempt-open",
-			details: mutationAuditDetails({
-				operation: attempt.operation,
-				phase: "started",
-				attemptId: attempt.attemptId,
-				writer: attempt.writer,
-				...attempt.subject === void 0 ? {} : { subject: attempt.subject }
-			})
-		});
-		let result;
-		try {
-			result = await options.run();
-		} catch (error) {
-			await closeMutationAttempt(options.stateDir, attempt, options.failedOutcome?.(error) ?? { outcome: "failed" });
-			throw error;
-		}
-		await closeMutationAttempt(options.stateDir, attempt, options.completedOutcome(result));
-		return result;
-	});
 }
-/** Returns the durable identifier owned by the current mutation boundary. */
-function currentMutationAttemptId() {
-	const attemptId = mutationAttemptScope.getStore();
-	if (!attemptId) throw new Error("mutation attempt identifier requested outside a mutation boundary");
-	return attemptId;
+//#endregion
+//#region src/engine/extraction/memory-temporality-classifier.ts
+function parseSessionTimestamp(sessionDateTime) {
+	return parseIsoDateTimeMs(sessionDateTime);
 }
-/** Runs a synchronous memory operation only after its durable start record is persisted. */
-function runWithMemoryAuditSync(options) {
-	if (memoryAuditScope.getStore()) return options.run();
-	return memoryAuditScope.run(true, () => {
-		const operationId = randomUUID();
-		appendAuditEntrySync(options.stateDir, {
-			event: options.event,
-			scope: options.scope,
-			resultStatus: "partial",
-			details: memoryAuditDetails(options.operation, "started", operationId, options.startedDetails)
-		});
-		let result;
-		try {
-			result = options.run();
-		} catch (error) {
-			appendAuditEntrySync(options.stateDir, {
-				event: options.event,
-				scope: options.scope,
-				resultStatus: "error",
-				errorCode: "memory_operation_failed",
-				details: memoryAuditDetails(options.operation, "failed", operationId, options.startedDetails)
-			});
-			throw error;
-		}
-		appendAuditEntrySync(options.stateDir, {
-			event: options.event,
-			scope: options.scope,
-			resultStatus: "ok",
-			details: memoryAuditDetails(options.operation, "completed", operationId, options.completedDetails(result))
-		});
-		return result;
-	});
+function serializeIntervalMetadata(category, interval) {
+	if (interval.type === "static") return {
+		memory_temporal_type: "static",
+		temporal_resolution_status: "static"
+	};
+	const base = {
+		memory_temporal_type: "dynamic",
+		temporal_resolution_status: interval.resolutionStatus
+	};
+	if ("phrase" in interval && interval.phrase) base.temporal_phrase = interval.phrase;
+	if (interval.type === "instant") {
+		if (category === "episodic") base.event_at = interval.at;
+		base.valid_from = interval.at;
+	} else if (interval.type === "bounded") {
+		base.valid_from = interval.from;
+		if (category === "episodic") base.valid_until = interval.until;
+		if (interval.date !== void 0) base.temporal_date = interval.date;
+		if (interval.precision !== void 0) base.temporal_precision = interval.precision;
+		if (interval.timezone !== void 0) base.temporal_timezone = interval.timezone;
+	} else if (interval.type === "ongoing") {
+		base.valid_from = interval.from;
+		if (interval.until !== void 0) base.valid_until = interval.until;
+	}
+	return base;
 }
 createLogger("sno-station-mem:scopes");
 //#endregion
@@ -15763,12 +15942,14 @@ function createVerdictGeneration(database, input) {
 				generation_id, pair_id, left_row_id, right_row_id, sort_key,
 				claim_state, attempt_count, progress_state, refusal_reason, inherited_from_generation_id
 			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-		const inheritedRefusal = input.inheritedRefusalsFromGenerationId ? database.prepare(`SELECT attempt_count, refusal_reason FROM nodix_rem_scan_pairs
-				WHERE generation_id = ? AND pair_id = ? AND progress_state = 'refused'
-					AND refusal_reason IN ('content_changed', 'target_changed')`) : void 0;
+		const inheritedRefusal = database.prepare(`SELECT pair.attempt_count, pair.refusal_reason, pair.generation_id
+			FROM nodix_rem_scan_pairs AS pair
+			JOIN nodix_rem_scan_generations AS generation USING (generation_id)
+			WHERE pair.pair_id = ? AND pair.progress_state = 'refused'
+			ORDER BY generation.rowid DESC LIMIT 1`);
 		for (const pair of input.pairs) {
-			const inherited = inheritedRefusal?.get(input.inheritedRefusalsFromGenerationId, pair.pairId);
-			insertPair.run(input.generationId, pair.pairId, pair.leftRowId, pair.rightRowId, pair.sortKey, "unvisited", inherited?.attempt_count ?? 0, inherited ? "refused" : "pending", inherited?.refusal_reason ?? null, inherited ? input.inheritedRefusalsFromGenerationId : null);
+			const inherited = inheritedRefusal.get(pair.pairId);
+			insertPair.run(input.generationId, pair.pairId, pair.leftRowId, pair.rightRowId, pair.sortKey, "unvisited", inherited?.attempt_count ?? 0, inherited ? "refused" : "pending", inherited?.refusal_reason ?? null, inherited?.generation_id ?? null);
 		}
 	}).immediate();
 }
@@ -15803,7 +15984,7 @@ function listVerdictPairs(database, generationId) {
 }
 function readClosedVerdictPairIds(database, pairIds) {
 	const rows = database.prepare(`SELECT DISTINCT pair_id FROM nodix_rem_scan_pairs
-			WHERE progress_state = 'closed' AND pair_id IN (SELECT value FROM json_each(?))`).all(JSON.stringify(pairIds));
+			WHERE progress_state IN ('closed', 'exhausted') AND pair_id IN (SELECT value FROM json_each(?))`).all(JSON.stringify(pairIds));
 	return new Set(rows.map((row) => row.pair_id));
 }
 function claimNextPair(database, input) {
@@ -15816,7 +15997,7 @@ function claimNextPair(database, input) {
 					reserved_tokens, attempt_count, progress_state, refusal_reason, inherited_from_generation_id
 				FROM nodix_rem_scan_pairs
 				WHERE generation_id = ? AND claim_state = 'unvisited'
-				ORDER BY CASE progress_state WHEN 'refused' THEN 0 ELSE 1 END, sort_key, pair_id
+				ORDER BY attempt_count, sort_key, pair_id
 				LIMIT 1`).get(input.generationId);
 		if (!pair) return void 0;
 		if (asRunResult(database.prepare(`UPDATE nodix_rem_scan_pairs SET
@@ -17838,7 +18019,7 @@ function loadSqliteVecExtension(database) {
 *   idempotent, so an interrupted move simply completes on the next boot.
 * @boundary Reads and writes only those two tables through the caller's handle.
 */
-const log$14 = createLogger("unplaced-candidate-migration");
+const log$15 = createLogger("unplaced-candidate-migration");
 /**
 * Legacy rows are keyed on their own row id, not on the live writer's basis.
 * Two legacy rows can carry byte-identical payloads and reasons and still be
@@ -17881,7 +18062,7 @@ function migrateUnplacedCandidates(sqlite) {
 		}
 		return moved;
 	})();
-	log$14.warn("relocated non-active memory rows into the unplaced-candidate table", { moved }, {
+	log$15.warn("relocated non-active memory rows into the unplaced-candidate table", { moved }, {
 		event_name: FIXED_EXTERNAL_VALUE_62,
 		file: "packages/memory/src/store/unplaced-candidate-migration.ts",
 		function: "migrateUnplacedCandidates",
@@ -17896,7 +18077,7 @@ function migrateUnplacedCandidates(sqlite) {
 * @boundary Filesystem safety, database pragmas, migrations, and runtime loading.
 * @see sqlite-runtime.ts, schema.ts, store.ts.
 */
-const log$13 = createLogger("sno-station-mem:db");
+const log$14 = createLogger("sno-station-mem:db");
 function parseVecTableDimension(sql) {
 	if (!/create\s+virtual\s+table/i.test(sql) || !/using\s+vec0/i.test(sql)) throw new StorageError(`nodix_memory_chunk_vectors exists but is not a sqlite-vec virtual table: ${sql}`);
 	const token = sql.match(/embedding\s+float\[(\d+)\]/i)?.[1];
@@ -17935,7 +18116,7 @@ function ensureChunkVecTable(db, vectorDim) {
 	const existing = readChunkVecTableState(db);
 	if (existing && (existing.dimension !== vectorDim || !existing.hasPartitionKey)) {
 		if (existing.rowCount > 0) {
-			log$13.error("storage.vector.configuration.mismatch", {
+			log$14.error("storage.vector.configuration.mismatch", {
 				vectorDim,
 				existing
 			}, {
@@ -17975,7 +18156,7 @@ function loadSimpleTokenizer(db) {
 	db.loadExtension(extensionPath);
 	db.prepare("SELECT jieba_dict(?)").get(dictPath);
 	db.exec("CREATE VIRTUAL TABLE temp.nodix_simple_tokenizer_smoke USING fts5(x, tokenize='simple 0'); DROP TABLE temp.nodix_simple_tokenizer_smoke;");
-	log$13.info("simple-tokenizer loaded", {
+	log$14.info("simple-tokenizer loaded", {
 		platform,
 		extensionPath
 	}, {
@@ -18005,7 +18186,7 @@ function resolveMigrationsDir() {
 const MIGRATIONS_DIR = resolveMigrationsDir();
 /** Implements init db as the local SQLite connection setup operation. */
 function initDb(dbPath, vectorDim) {
-	log$13.info("initializing database", {
+	log$14.info("initializing database", {
 		dbPath,
 		vectorDim
 	}, {
@@ -18022,7 +18203,7 @@ function initDb(dbPath, vectorDim) {
 			run();
 			pending.delete(step);
 		} catch (error) {
-			log$13.error("storage.setup.failed", {
+			log$14.error("storage.setup.failed", {
 				step,
 				error
 			}, {
@@ -18081,7 +18262,7 @@ function ensureColumn(database, tableName, columnName, declaration) {
 * @boundary SQLite schema, embedding vectors, FTS, and metadata invariants.
 * @see connection.ts, schema.ts, retriever.ts.
 */
-const log$12 = createLogger("sno-station-mem:store");
+const log$13 = createLogger("sno-station-mem:store");
 /**
 * Reflection v3: discriminator added to content-hash input when the
 * row carries a `metadata.mappedKind`. Two rows with same projectId + same store
@@ -18191,7 +18372,11 @@ function loadMemoryTelemetryKeySet(options) {
 		historic: /* @__PURE__ */ new Map()
 	};
 	const key = options.key;
-	if (!key || key.trim().length === 0) throw new Error("telemetry.memoryUsage.key is required when memory telemetry is enabled");
+	if (!key || key.trim().length === 0) return {
+		enabled: true,
+		current: null,
+		historic: new Map(options.historicKeys.map((value, index) => [index + 1, value]))
+	};
 	const currentKeyVersion = options.currentKeyVersion ?? options.historicKeys.length + 1;
 	if (!Number.isInteger(currentKeyVersion) || currentKeyVersion <= 0) throw new Error("memory telemetry current key version must be a positive integer");
 	return {
@@ -18348,7 +18533,7 @@ function verification(status, receipt) {
 }
 //#endregion
 //#region src/engine/telemetry/memory-telemetry-events.ts
-const log$11 = createLogger("sno-station-mem:memory-telemetry-events");
+const log$12 = createLogger("sno-station-mem:memory-telemetry-events");
 var MemoryTelemetryEventWriter = class {
 	sqlite;
 	enabled;
@@ -18381,28 +18566,40 @@ var MemoryTelemetryEventWriter = class {
 				historicKeys: options.config?.historicKeys ?? [],
 				currentKeyVersion: options.config?.currentKeyVersion
 			});
-			this.receiptService = options.config?.receiptService ?? createMemoryTelemetryReceiptService(keySet);
+			this.receiptService = options.config?.receiptService ?? (keySet.current ? createMemoryTelemetryReceiptService(keySet) : null);
 		} catch (error) {
-			log$11.warn("memory telemetry disabled: receipt key unavailable", { error }, {
-				event_name: "sno_station_mem.memory-telemetry-events.memory.telemetry.disabled.receipt.key.unavailable",
+			log$12.warn("memory telemetry signing unavailable; recording unsigned events", { error }, {
+				event_name: "memory.telemetry.signing.unavailable",
 				file: "packages/memory/src/engine/telemetry/memory-telemetry-events.ts",
 				function: "<anonymous callback>",
 				site_id: "memory-telemetry-events.<anonymous callback>.23cfef2d08"
 			});
-			this.enabled = false;
 			this.receiptService = null;
 		}
 	}
 	writeReceiptEvent(input) {
 		if (!this.enabled) return;
 		const timestampMs = input.timestampMs ?? Date.now();
-		const receipt = this.requireReceiptService().sign({
-			factId: input.factId,
-			contentHash: input.contentHash,
-			timestampMs
+		let receipt;
+		try {
+			receipt = this.receiptService?.sign({
+				factId: input.factId,
+				contentHash: input.contentHash,
+				timestampMs
+			});
+		} catch (error) {
+			log$12.warn("memory telemetry signing failed; recording unsigned event", { error }, {
+				event_name: "memory.telemetry.signing.failed",
+				file: "packages/memory/src/engine/telemetry/memory-telemetry-events.ts",
+				function: "writeReceiptEvent",
+				site_id: "memory.telemetry.signing.failed"
+			});
+		}
+		const metadata = validateMemoryTelemetryMetadata(input.eventType, {
+			...input.metadata,
+			...input.eventType === "create" ? { receipt_status: receipt ? "signed" : "unsigned" } : {}
 		});
-		const metadata = validateMemoryTelemetryMetadata(input.eventType, input.metadata);
-		this.insertReceiptEventStatement.run(input.eventType, input.factId, input.memoryKind, timestampMs, this.agentId, input.projectId, input.sourceEventId ?? null, input.derivedFrom ? JSON.stringify(input.derivedFrom) : null, receipt.contentHash, receipt.receiptHmac, receipt.keyVersion, JSON.stringify(metadata));
+		this.insertReceiptEventStatement.run(input.eventType, input.factId, input.memoryKind, timestampMs, this.agentId, input.projectId, input.sourceEventId ?? null, input.derivedFrom ? JSON.stringify(input.derivedFrom) : null, input.contentHash, receipt?.receiptHmac ?? null, receipt?.keyVersion ?? null, JSON.stringify(metadata));
 	}
 	writeLifecycleEvent(input) {
 		if (!this.enabled) return;
@@ -18414,10 +18611,6 @@ var MemoryTelemetryEventWriter = class {
 		if (!this.enabled) return null;
 		return this.readLatestReceiptEventIdStatement.get(factId)?.id ?? null;
 	}
-	requireReceiptService() {
-		if (!this.receiptService) throw new Error("memory telemetry receipt service is unavailable");
-		return this.receiptService;
-	}
 };
 //#endregion
 //#region src/store/rem-update-stamp-migration.ts
@@ -18761,7 +18954,7 @@ var MemoryStore = class {
 			sqlite.close();
 			throw error;
 		}
-		log$12.info("memory store initialized", {
+		log$13.info("memory store initialized", {
 			dbPath: config.dbPath,
 			vectorDim: this.vectorDim,
 			hasFtsSupport: this.hasFtsSupport
@@ -18920,7 +19113,7 @@ Object.assign(MemoryStore.prototype, {
 			} catch (error) {
 				failedRows++;
 				if (firstFailure === void 0 && error instanceof Error) firstFailure = error;
-				log$12.warn("legacy memory chunk backfill skipped row", {
+				log$13.warn("legacy memory chunk backfill skipped row", {
 					memory_id: row.id,
 					error
 				}, {
@@ -18970,7 +19163,7 @@ Object.assign(MemoryStore.prototype, {
 			this.backfillFailureCount = 0;
 			this.backfillNextRetryAt = 0;
 			this.backfillLastFailureAt = 0;
-			if (count > 0) log$12.info("backfilled legacy memory chunks", { count }, {
+			if (count > 0) log$13.info("backfilled legacy memory chunks", { count }, {
 				event_name: "sno_station_mem.memory-store-backfill.backfilled.legacy.memory.chunks",
 				file: "packages/memory/src/store/memory-store-backfill.ts",
 				function: "<anonymous callback>",
@@ -18983,7 +19176,7 @@ Object.assign(MemoryStore.prototype, {
 			this.backfillLastFailureAt = failedAt;
 			const retryInMs = this.backfillFailureCount < 3 ? CHUNK_BACKFILL_RETRY_BASE_MS * 2 ** (this.backfillFailureCount - 1) : null;
 			this.backfillNextRetryAt = retryInMs === null ? Number.POSITIVE_INFINITY : failedAt + retryInMs;
-			log$12.warn("legacy memory chunk backfill failed", {
+			log$13.warn("legacy memory chunk backfill failed", {
 				attempt: this.backfillFailureCount,
 				maxAttempts: 3,
 				retryInMs,
@@ -19281,7 +19474,7 @@ Object.assign(MemoryStore.prototype, {
 		const entry = readEntry(this, key);
 		if (entry.state !== "pending_reprocess" || entry.reprocessReason === null) throw new StorageError(`Cannot reopen atomic extraction from state '${entry.state}'`);
 		if (entry.reprocessAttemptCount >= attemptCap) {
-			log$12.error("atomic extraction chunk stuck at reprocess attempt cap", {
+			log$13.error("atomic extraction chunk stuck at reprocess attempt cap", {
 				product_session_reference: privateLogReference(key.conversationId),
 				chunk_hash: key.chunkHash,
 				version: key.pipelineVersion,
@@ -21111,7 +21304,7 @@ function canTrustedWrite(kind) {
 * @purpose Validates and normalizes memory-kind metadata before direct store writes.
 * @boundary Storage write chokepoint only; extraction owns metadata semantics.
 */
-const log$9 = createLogger("sno-station-mem:active-task-shape-alarm");
+const log$10 = createLogger("sno-station-mem:active-task-shape-alarm");
 function validateAtomicCardWrite(input) {
 	if (input.category !== "state") return;
 	if (input.subject === null || !input.subject.startsWith("entity:") || input.subject.length === 7) throw new StorageError("state memory requires a non-empty entity subject");
@@ -21155,7 +21348,7 @@ function formatCause(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function shapeAlarm(operation, reason) {
-	log$9.error("Active task shape validation failed", {
+	log$10.error("Active task shape validation failed", {
 		operation,
 		reason_code: reason.replace(/[^a-z0-9]+/gi, "_").toLowerCase()
 	}, {
@@ -21600,7 +21793,7 @@ async function readAtomicArrivalRetirementCandidateSet(store, input) {
 	};
 	const scoreById = scoreCandidatesBySimilarity(store, await store.embedder.embed(nominatedRow.text), candidates.map(({ id }) => id));
 	const ranked = candidates.sort((left, right) => (scoreById.get(right.id) ?? Number.NEGATIVE_INFINITY) - (scoreById.get(left.id) ?? Number.NEGATIVE_INFINITY) || left.id.localeCompare(right.id));
-	if (ranked.length > 10) appendArrivalRetirementJournal(store, {
+	if (ranked.length > 3) appendArrivalRetirementJournal(store, {
 		jobId: input.jobId,
 		nominatedRowId: nominatedRow.id,
 		outcome: "no-action",
@@ -21608,12 +21801,12 @@ async function readAtomicArrivalRetirementCandidateSet(store, input) {
 		actionsApplied: 0,
 		detail: {
 			nominatedRowId: nominatedRow.id,
-			omittedCount: ranked.length - 10
+			omittedCount: ranked.length - 3
 		}
 	});
 	return {
 		nominatedRow: judgedRow(nominatedRow),
-		candidateRows: ranked.slice(0, 10).map(judgedRow)
+		candidateRows: ranked.slice(0, 3).map(judgedRow)
 	};
 }
 function journalAtomicArrivalRetirementRefusal(store, input) {
@@ -23542,7 +23735,7 @@ Object.assign(MemoryStore.prototype, {
 	async store(entry) {
 		const safeEntry = sanitizeStoreInput(entry);
 		const lane = safeEntry.lane ?? "active";
-		log$12.debug("storing memory", {
+		log$13.debug("storing memory", {
 			category: safeEntry.category,
 			projectId: safeEntry.projectId
 		}, {
@@ -23585,7 +23778,7 @@ Object.assign(MemoryStore.prototype, {
 		if (writeIdentity) {
 			const alreadyWritten = this.findByExtractionIdempotencyKey(projectId, writeIdentity);
 			if (alreadyWritten) {
-				log$12.debug("idempotency key match, skipping store", {
+				log$13.debug("idempotency key match, skipping store", {
 					projectId,
 					memory_id: alreadyWritten.id
 				}, {
@@ -23599,7 +23792,7 @@ Object.assign(MemoryStore.prototype, {
 		}
 		const earlyDup = this.readExistingByHash(projectId, hash, category);
 		if (earlyDup && !canRevive(earlyDup)) {
-			log$12.debug("content hash match, skipping store", {
+			log$13.debug("content hash match, skipping store", {
 				projectId,
 				memory_id: earlyDup.id
 			}, {
@@ -23616,7 +23809,7 @@ Object.assign(MemoryStore.prototype, {
 			if (writeIdentity) {
 				const alreadyWritten = this.findByExtractionIdempotencyKey(projectId, writeIdentity);
 				if (alreadyWritten) {
-					log$12.debug("idempotency key match, skipping store", {
+					log$13.debug("idempotency key match, skipping store", {
 						projectId,
 						memory_id: alreadyWritten.id
 					}, {
@@ -23630,7 +23823,7 @@ Object.assign(MemoryStore.prototype, {
 			}
 			const existing = this.readExistingByHash(projectId, hash, category);
 			if (existing && !canRevive(existing)) {
-				log$12.debug("content hash match, skipping store", {
+				log$13.debug("content hash match, skipping store", {
 					projectId,
 					memory_id: existing.id
 				}, {
@@ -23940,7 +24133,7 @@ Object.assign(MemoryStore.prototype, {
 		assertProfileRecoveryWrite(args.profileRecovery);
 		const { activeFactGuard, activeTaskProjectionGuard, closes, preserveExisting, reviveInvalidatedExisting } = args;
 		const create = sanitizeStoreInput(args.create);
-		log$12.debug("supersede write", {
+		log$13.debug("supersede write", {
 			category: create.category,
 			projectId: create.projectId,
 			closes: closes.length
@@ -24720,7 +24913,7 @@ function mergeMetadata(current, patch) {
 Object.assign(MemoryStore.prototype, {
 	async update(id, changes) {
 		const countRecordTokens = await recordTokenCounter(this.embedder);
-		log$12.debug("updating memory", { memory_id: id }, {
+		log$13.debug("updating memory", { memory_id: id }, {
 			event_name: "sno_station_mem.memory-store-update-api.updating.memory",
 			file: "packages/memory/src/store/memory-store-update-api.ts",
 			function: "update",
@@ -24845,7 +25038,7 @@ Object.assign(MemoryStore.prototype, {
 		});
 	},
 	async updateTier(memoryId, newTier, options) {
-		log$12.debug("updating tier", {
+		log$13.debug("updating tier", {
 			memory_id: memoryId,
 			tier: newTier
 		}, {
@@ -24867,7 +25060,7 @@ Object.assign(MemoryStore.prototype, {
 		});
 	},
 	async updateMetadata(memoryId, patch) {
-		log$12.debug("updating metadata", { memory_id: memoryId }, {
+		log$13.debug("updating metadata", { memory_id: memoryId }, {
 			event_name: "sno_station_mem.memory-store-update-api.updating.metadata",
 			file: "packages/memory/src/store/memory-store-update-api.ts",
 			function: "updateMetadata",
@@ -24885,7 +25078,7 @@ Object.assign(MemoryStore.prototype, {
 		});
 	},
 	async resolveReflectionItem(memoryId, opts) {
-		log$12.debug("resolving reflection item", { memory_id: memoryId }, {
+		log$13.debug("resolving reflection item", { memory_id: memoryId }, {
 			event_name: "sno_station_mem.memory-store-update-api.resolving.reflection.item",
 			file: "packages/memory/src/store/memory-store-update-api.ts",
 			function: "resolveReflectionItem",
@@ -24920,7 +25113,7 @@ Object.assign(MemoryStore.prototype, {
 	*/
 	async applyMetadataDeltas(entries) {
 		if (entries.length === 0) return;
-		log$12.debug("applying metadata deltas", { count: entries.length }, {
+		log$13.debug("applying metadata deltas", { count: entries.length }, {
 			event_name: "sno_station_mem.memory-store-update-api.applying.metadata.deltas",
 			file: "packages/memory/src/store/memory-store-update-api.ts",
 			function: "applyMetadataDeltas",
@@ -24944,7 +25137,7 @@ Object.assign(MemoryStore.prototype, {
 		});
 	},
 	async applyMetadataDelta(memoryId, deltaFn) {
-		log$12.debug("applying metadata delta", { memory_id: memoryId }, {
+		log$13.debug("applying metadata delta", { memory_id: memoryId }, {
 			event_name: "sno_station_mem.memory-store-update-api.applying.metadata.delta",
 			file: "packages/memory/src/store/memory-store-update-api.ts",
 			function: "applyMetadataDelta",
@@ -24965,7 +25158,7 @@ Object.assign(MemoryStore.prototype, {
 });
 //#endregion
 //#region src/store/memory-store-rem-api.ts
-const log$7 = createLogger("sno-station-mem:rem-write");
+const log$8 = createLogger("sno-station-mem:rem-write");
 Object.assign(MemoryStore.prototype, { async applyRemTextVersion(input) {
 	if (input.reason.trim().length === 0) throw new Error("mutation reason is required");
 	if (input.idempotencyKey !== void 0 && input.idempotencyKey.trim().length === 0) throw new Error("REM idempotency key must be non-empty");
@@ -24996,7 +25189,7 @@ Object.assign(MemoryStore.prototype, { async applyRemTextVersion(input) {
 			});
 		} catch (error) {
 			if (completedMutation === void 0) throw error;
-			log$7.error("rem_write_completion_audit_failed", {
+			log$8.error("rem_write_completion_audit_failed", {
 				error,
 				row_id: input.rowId
 			}, {
@@ -25105,7 +25298,7 @@ async function applyTransaction(store, input, chunks) {
 			}
 		});
 	} catch (error) {
-		log$7.error("rem_write_receipt_failed", {
+		log$8.error("rem_write_receipt_failed", {
 			error,
 			row_id: existing.id
 		}, {
@@ -25312,7 +25505,7 @@ function buildChunkSearchResults(vecRows, metaRows, limit, minScore) {
 Object.assign(MemoryStore.prototype, {
 	async searchChunksSemantic(vector, opts = {}) {
 		if (!this.db.vectorSearchAvailable) {
-			log$12.error("storage.vector.search.unavailable", { dbPath: this.dbPath }, {
+			log$13.error("storage.vector.search.unavailable", { dbPath: this.dbPath }, {
 				event_name: "storage.vector.search.unavailable",
 				file: "packages/memory/src/store/memory-store-chunk-search.ts",
 				function: "searchChunksSemantic",
@@ -25335,7 +25528,7 @@ Object.assign(MemoryStore.prototype, {
 				const metaRows = readSemanticMetaRows(this.sqlite, vecRows, opts);
 				const results = buildChunkSearchResults(vecRows, metaRows, limit, minScore);
 				if (results.length >= limit || vecRows.length < candidateBudget) {
-					log$12.debug("chunk semantic search", {
+					log$13.debug("chunk semantic search", {
 						limit,
 						projectIdFilter: opts.projectIdFilter,
 						vecCandidates: vecRows.length,
@@ -25355,7 +25548,7 @@ Object.assign(MemoryStore.prototype, {
 				candidateBudget = Math.min(candidateBudget * SEMANTIC_CANDIDATE_GROWTH_FACTOR, vectorRowCount);
 			}
 		} catch (error) {
-			log$12.error("chunk semantic search failed", {
+			log$13.error("chunk semantic search failed", {
 				error,
 				limit,
 				projectIdFilter: opts.projectIdFilter,
@@ -25420,7 +25613,7 @@ Object.assign(MemoryStore.prototype, {
 					rank: index + 1
 				});
 			});
-			log$12.debug("chunk keyword search", {
+			log$13.debug("chunk keyword search", {
 				query_length: safeQuery?.length ?? "unavailable",
 				limit,
 				minScore,
@@ -25433,7 +25626,7 @@ Object.assign(MemoryStore.prototype, {
 			});
 			return results;
 		} catch (error) {
-			log$12.error("chunk keyword search failed", {
+			log$13.error("chunk keyword search failed", {
 				error,
 				query_length: safeQuery?.length ?? "unavailable",
 				limit,
@@ -25609,7 +25802,7 @@ Object.assign(MemoryStore.prototype, {
 			if (results.length >= limit) break;
 		}
 		this.attachSnippets(results, opts.facetPolicy);
-		log$12.debug("semantic search (memory-level wrapper)", {
+		log$13.debug("semantic search (memory-level wrapper)", {
 			limit,
 			chunkLimit,
 			projectIdFilter: opts.projectIdFilter,
@@ -25655,7 +25848,7 @@ Object.assign(MemoryStore.prototype, {
 			if (results.length >= limit) break;
 		}
 		this.attachSnippets(results, opts.facetPolicy);
-		log$12.debug("keyword search (memory-level wrapper)", {
+		log$13.debug("keyword search (memory-level wrapper)", {
 			limit,
 			chunkLimit,
 			projectIdFilter: opts.projectIdFilter,
@@ -25686,7 +25879,7 @@ Object.assign(MemoryStore.prototype, {
 					neighborAfter: 2
 				});
 			} catch (err) {
-				log$12.warn("snippet expand window failed; falling back to entry text", {
+				log$13.warn("snippet expand window failed; falling back to entry text", {
 					memory_id: result.entry.id,
 					chunkIndex: result.chunkIndex,
 					totalChunks,
@@ -25826,7 +26019,7 @@ Object.assign(MemoryStore.prototype, {
 			}
 			return metadata;
 		} catch (e) {
-			log$12.warn("malformed metadata JSON", {
+			log$13.warn("malformed metadata JSON", {
 				memory_id: memoryId,
 				error: e
 			}, {
@@ -25890,7 +26083,7 @@ function writeDeleteEvents(internals, rows, reason) {
 }
 Object.assign(MemoryStore.prototype, {
 	async delete(idOrPrefix, options) {
-		log$12.info("deleting memories", { idOrPrefix }, {
+		log$13.info("deleting memories", { idOrPrefix }, {
 			event_name: "sno_station_mem.memory-store-admin-api.deleting.memories",
 			file: "packages/memory/src/store/memory-store-admin-api.ts",
 			function: "delete",
@@ -25915,7 +26108,7 @@ Object.assign(MemoryStore.prototype, {
 	async deleteMany(ids, options) {
 		const uniqueIds = Array.from(new Set(ids));
 		if (uniqueIds.length === 0) return 0;
-		log$12.info("deleting many memories", { count: uniqueIds.length }, {
+		log$13.info("deleting many memories", { count: uniqueIds.length }, {
 			event_name: "sno_station_mem.memory-store-admin-api.deleting.many.memories",
 			file: "packages/memory/src/store/memory-store-admin-api.ts",
 			function: "deleteMany",
@@ -25949,7 +26142,7 @@ Object.assign(MemoryStore.prototype, {
 		}).immediate();
 	},
 	async bulkDelete(filter, options) {
-		log$12.info("bulk delete", {
+		log$13.info("bulk delete", {
 			projectId: filter.projectId,
 			category: filter.category
 		}, {
@@ -26020,7 +26213,7 @@ Object.assign(MemoryStore.prototype, {
 				unplacedParams.push(filter.category);
 			}
 			this.sqlite.prepare(`DELETE FROM nodix_unplaced_memory_candidates${unplacedWhere.length > 0 ? ` WHERE ${unplacedWhere.join(" AND ")}` : ""}`).run(...unplacedParams);
-			if (truncated) log$12.warn("bulk delete reached safety iteration cap", {
+			if (truncated) log$13.warn("bulk delete reached safety iteration cap", {
 				projectId: filter.projectId,
 				category: filter.category,
 				deleted,
@@ -26063,7 +26256,7 @@ Object.assign(MemoryStore.prototype, {
 			this.sqlite.exec("PRAGMA optimize");
 			this.sqlite.exec("PRAGMA wal_checkpoint(TRUNCATE)");
 		} catch (error) {
-			log$12.warn("sqlite close-time maintenance failed", { error }, {
+			log$13.warn("sqlite close-time maintenance failed", { error }, {
 				event_name: "sno_station_mem.memory-store-admin-api.sqlite.close.time.maintenance.failed",
 				file: "packages/memory/src/store/memory-store-admin-api.ts",
 				function: "closeSqlite",
@@ -26159,7 +26352,7 @@ function truncateToTokens(text, maxTokens, countTokens) {
 * @see store.ts, retriever.ts.
 */
 /** Local ONNX embedding with an LRU cache and oversized-text chunking. */
-const log$6 = createLogger("sno-station-mem:embed");
+const log$7 = createLogger("sno-station-mem:embed");
 var Embedder = class {
 	provider;
 	chunkingEnabled;
@@ -26189,7 +26382,7 @@ var Embedder = class {
 			maxSize: 256,
 			ttlMs: CACHE_TTL_MS
 		});
-		log$6.info("embedder initialized", {
+		log$7.info("embedder initialized", {
 			provider: providerKind,
 			model: this.model,
 			dimensions: this.dimensions,
@@ -26249,7 +26442,7 @@ var Embedder = class {
 			if (pieceTokens > 512) throw new EmbeddingError(`Embedder chunk of ${pieceTokens} tokens exceeds DEFAULT_MAX_CONTEXT_TOKENS (512)`);
 		}
 		if (chunks.length <= 1) return this.embedDirect(chunks[0] ?? text);
-		log$6.warn("legacy chunker invoked (embedding-API safety net)", {
+		log$7.warn("legacy chunker invoked (embedding-API safety net)", {
 			chunks: chunks.length,
 			totalTokens: tokens,
 			maxTokens: 512
@@ -26267,7 +26460,7 @@ var Embedder = class {
 			const vector = await this.provider.embed(text);
 			return this.toFloat32(vector);
 		} catch (error) {
-			log$6.error("passage embedding failed", {
+			log$7.error("passage embedding failed", {
 				textLength: text.length,
 				error
 			}, {
@@ -26282,7 +26475,7 @@ var Embedder = class {
 	/** Implements embed many as the local embedding generation operation. */
 	async embedMany(values) {
 		await this.awaitWarmup();
-		log$6.debug("batch embedding", { count: values.length }, {
+		log$7.debug("batch embedding", { count: values.length }, {
 			event_name: "sno_station_mem.embedding-provider-client.batch.embedding",
 			file: "packages/memory/src/engine/extraction/embedding-provider-client.ts",
 			function: "embedMany",
@@ -26293,7 +26486,7 @@ var Embedder = class {
 			if (vectors.length !== values.length) throw new EmbeddingError(`Embedding provider returned ${vectors.length} vectors for ${values.length} inputs`);
 			return vectors.map((v) => this.toFloat32(v));
 		} catch (error) {
-			log$6.error("batch embedding failed", {
+			log$7.error("batch embedding failed", {
 				count: values.length,
 				error
 			}, {
@@ -26332,14 +26525,14 @@ var Embedder = class {
 				if (this.modelDownload) await ensureModelDownloaded(this.modelDownload);
 				const vector = await this.provider.embed("warmup");
 				if (vector.length !== this.dimensions) throw new EmbeddingError(`Embedder warmup dimension mismatch: expected ${this.dimensions}, got ${vector.length}`);
-				log$6.info("embedder warmup ok", { dimensions: this.dimensions }, {
+				log$7.info("embedder warmup ok", { dimensions: this.dimensions }, {
 					event_name: "sno_station_mem.embedding-provider-client.embedder.warmup.ok",
 					file: "packages/memory/src/engine/extraction/embedding-provider-client.ts",
 					function: "<anonymous callback>",
 					site_id: "embedding-provider-client.<anonymous callback>.32cc9ec43e"
 				});
 			} catch (error) {
-				log$6.error("embedder warmup failed", { error }, {
+				log$7.error("embedder warmup failed", { error }, {
 					event_name: "sno_station_mem.embedding-provider-client.embedder.warmup.failed",
 					file: "packages/memory/src/engine/extraction/embedding-provider-client.ts",
 					function: "<anonymous callback>",
@@ -26377,7 +26570,7 @@ function createEmbedder(config, stateDir) {
 * run-dir provided via `EVAL_TRACE_DIR` (env). Phase 0 instrumentation
 * (MRR/Recall, gold-rank, miss classification) remains explicitly waived.
 */
-const log$5 = createLogger("sno-station-mem:eval-trace");
+const log$6 = createLogger("sno-station-mem:eval-trace");
 /**
 * Returns true when the eval-trace surface should write. Reads the env var at
 * call time so harness-flipped values take effect without a re-import.
@@ -26412,7 +26605,7 @@ function appendQaTrace(trace, traceDirOverride) {
 			context: currentLogContext()
 		})}\n`, "utf8");
 	} catch (err) {
-		log$5.warn("failed to append qa trace", { error: err }, {
+		log$6.warn("failed to append qa trace", { error: err }, {
 			event_name: "sno_station_mem.trace.failed.to.append.qa.trace",
 			file: "packages/memory/src/engine/eval/trace.ts",
 			function: "appendQaTrace",
@@ -26482,7 +26675,7 @@ function sha256Hex(input) {
 * Tracks memory access patterns to support reinforcement-based decay.
 * Frequently accessed memories decay more slowly (longer effective half-life).
 */
-const log$4 = createLogger("sno-station-mem:access-tracker");
+const log$5 = createLogger("sno-station-mem:access-tracker");
 const MIN_ACCESS_COUNT = 0;
 const LEGACY_MAX_ACCESS_COUNT = 1e4;
 /** Default debounce interval before flushing pending writes (5 seconds) */
@@ -26631,7 +26824,7 @@ var AccessTracker = class {
 		this.clearTimer();
 		if (this.flushPromise) await this.flushPromise;
 		if (this.pending.size > 0) await this.doFlush();
-		if (this.pending.size > 0) log$4.warn("destroying with pending writes", { pendingCount: this.pending.size }, {
+		if (this.pending.size > 0) log$5.warn("destroying with pending writes", { pendingCount: this.pending.size }, {
 			event_name: "sno_station_mem.access-tracker.destroying.with.pending.writes",
 			file: "packages/memory/src/engine/retrieval/access-tracker.ts",
 			function: "destroy",
@@ -26666,7 +26859,7 @@ var AccessTracker = class {
 				const failures = (this.writeFailures.get(id) ?? 0) + 1;
 				if (failures >= MAX_WRITE_FAILURES_PER_ID) {
 					this.writeFailures.delete(id);
-					log$4.warn("dropping access delta after repeated write failures", {
+					log$5.warn("dropping access delta after repeated write failures", {
 						memory_id: id,
 						failures,
 						error: err
@@ -26681,7 +26874,7 @@ var AccessTracker = class {
 				this.writeFailures.set(id, failures);
 				this.pending.set(id, (this.pending.get(id) ?? 0) + delta);
 			}
-			log$4.warn("access flush batch failed", {
+			log$5.warn("access flush batch failed", {
 				batchSize: batch.size,
 				error: err,
 				committed_count: 0
@@ -26713,7 +26906,7 @@ var AccessTracker = class {
 			if (prevLast > 0 && now - prevLast < this.recallLifecycle.accessRateLimitMs) return void 0;
 			if (prevCount > ceiling && !this.clampedOnce.has(id)) {
 				this.clampedOnce.add(id);
-				log$4.warn("legacy access count clamped to ceiling", {
+				log$5.warn("legacy access count clamped to ceiling", {
 					memory_id: id,
 					previousCount: prevCount,
 					ceiling
@@ -27071,7 +27264,7 @@ Object.assign(MemoryRetriever.prototype, {
 });
 //#endregion
 //#region src/engine/retrieval/retrieval-scoring-utils.ts
-const log$3 = createLogger$1("sno-station-mem:retriever");
+const log$4 = createLogger$1("sno-station-mem:retriever");
 function dotProduct(a, b) {
 	let sum = 0;
 	const len = a.length;
@@ -27097,6 +27290,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", []);
@@ -27126,7 +27332,7 @@ Object.assign(MemoryRetriever.prototype, {
 			aggregationIncomplete: result.aggregationIncomplete
 		}));
 		trace?.endStage(mapped.map((result) => result.entry.id), mapped.map((result) => result.score));
-		log$3.info("aggregation evidence served", {
+		log$4.info("aggregation evidence served", {
 			rows: mapped.length,
 			scopeRows: mapped[0]?.scopeRowCount ?? 0,
 			readingBudget: context.limit,
@@ -27142,7 +27348,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", []);
@@ -27185,7 +27391,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;
@@ -27218,14 +27424,14 @@ Object.assign(MemoryRetriever.prototype, {
 			throw new RetrievalError("Both vector and keyword search failed", vectorSettled.reason);
 		}
 		let vectorResults = vectorSettled.status === "fulfilled" ? vectorSettled.value : [];
-		if (vectorSettled.status === "rejected") log$3.warn("vector search branch failed, using keyword-only", { error: vectorError }, {
+		if (vectorSettled.status === "rejected") log$4.warn("vector search branch failed, using keyword-only", { error: vectorError }, {
 			event_name: "memory.retriever_search_modes.diagnostic",
 			file: "packages/memory/src/engine/retrieval/retriever-search-modes.ts",
 			function: "precisionRecall",
 			site_id: "retrieval.retriever-search-modes.precisionRecall.97b8770f50"
 		});
 		let keywordResults = keywordSettled.status === "fulfilled" ? keywordSettled.value : [];
-		if (keywordSettled.status === "rejected") log$3.warn("keyword search branch failed, using vector-only", { error: keywordError }, {
+		if (keywordSettled.status === "rejected") log$4.warn("keyword search branch failed, using vector-only", { error: keywordError }, {
 			event_name: "memory.retriever_search_modes.diagnostic",
 			file: "packages/memory/src/engine/retrieval/retriever-search-modes.ts",
 			function: "precisionRecall",
@@ -27243,7 +27449,7 @@ Object.assign(MemoryRetriever.prototype, {
 		trace?.startStage("rrf_fusion", [...vectorResults.map((r) => r.entry.id), ...keywordResults.map((r) => r.entry.id)]);
 		let fused = this.rrfFuse(vectorResults, keywordResults);
 		trace?.endStage(fused.map((r) => r.entry.id), fused.map((r) => r.score));
-		log$3.debug("precision recall search", {
+		log$4.debug("precision recall search", {
 			vectorCount: vectorResults.length,
 			keywordCount: keywordResults.length,
 			fusedCount: fused.length,
@@ -27545,7 +27751,7 @@ Object.assign(MemoryRetriever.prototype, {
 		if (this.config.rerank === "lightweight" || !this.config.rerankApiKey) return { candidates: this.rerankLightweight(candidates, queryVector) };
 		const rerankEndpoint = this.config.rerankEndpoint ?? RERANK_DEFAULT_ENDPOINTS[provider];
 		if (!rerankEndpoint) {
-			log$3.warn("rerank skipped: no endpoint for provider", { provider }, {
+			log$4.warn("rerank skipped: no endpoint for provider", { provider }, {
 				event_name: "memory.retriever_rerank.diagnostic",
 				file: "packages/memory/src/engine/retrieval/retriever-rerank.ts",
 				function: "rerank",
@@ -27569,7 +27775,7 @@ Object.assign(MemoryRetriever.prototype, {
 		const queryTokens = this.embedder.countTokens(query);
 		const documentTokenBudget = 509 - queryTokens;
 		if (documentTokenBudget <= 0) {
-			log$3.warn("rerank skipped: the query alone fills the reranker token window", {
+			log$4.warn("rerank skipped: the query alone fills the reranker token window", {
 				queryTokens,
 				window: 512,
 				templateTokens: 3
@@ -27593,7 +27799,7 @@ Object.assign(MemoryRetriever.prototype, {
 			if (bounded !== c.entry.text) truncatedCandidates += 1;
 			return bounded;
 		});
-		if (truncatedCandidates > 0) log$3.warn("rerank candidates were cut to the document budget the query left", {
+		if (truncatedCandidates > 0) log$4.warn("rerank candidates were cut to the document budget the query left", {
 			truncatedCandidates,
 			documentTokenBudget,
 			queryTokens
@@ -27630,7 +27836,7 @@ Object.assign(MemoryRetriever.prototype, {
 								const target = Math.max(1, Math.floor(allowed * localPairTokens / named.inputTokens) - queryTokens);
 								return this.embedder.truncateToTokens(text, target);
 							});
-							log$3.warn("rerank batch refused over its token window; resending the named texts cut to fit", {
+							log$4.warn("rerank batch refused over its token window; resending the named texts cut to fit", {
 								status: response.status,
 								overLongCount: refusal.overLong.length,
 								maxInputTokens: refusal.maxInputTokens,
@@ -27644,7 +27850,7 @@ Object.assign(MemoryRetriever.prototype, {
 							});
 							continue;
 						}
-						log$3.warn("rerank API failed, using pre-rerank results", {
+						log$4.warn("rerank API failed, using pre-rerank results", {
 							status: response.status,
 							endpoint_hash: createHash("sha256").update(rerankEndpoint).digest("hex"),
 							retryAfter,
@@ -27661,7 +27867,7 @@ Object.assign(MemoryRetriever.prototype, {
 					}
 					const parsed = parseRerankResponse(provider, data);
 					if (!parsed) {
-						log$3.warn("rerank API returned unparseable response", {
+						log$4.warn("rerank API returned unparseable response", {
 							provider,
 							endpoint_hash: createHash("sha256").update(rerankEndpoint).digest("hex"),
 							batchStart: start
@@ -27729,7 +27935,7 @@ Object.assign(MemoryRetriever.prototype, {
 				score: clamp01(this.getRerankSourceScore(r) * LIGHTWEIGHT_RERANK_PENALTY, 0)
 			}));
 			const merged = [...reranked, ...unreturned].sort((a, b) => b.score - a.score);
-			log$3.debug("reranked", {
+			log$4.debug("reranked", {
 				totalCandidateCount: candidates.length,
 				sentToRerankCount: toRerank.length,
 				returnedCount: reranked.length,
@@ -27753,7 +27959,7 @@ Object.assign(MemoryRetriever.prototype, {
 			let reason;
 			if (isRerankTimeout(error)) {
 				reason = "timeout";
-				log$3.warn("rerank API timed out, using pre-rerank results", {
+				log$4.warn("rerank API timed out, using pre-rerank results", {
 					timeoutMs: rerankTimeoutMs,
 					attempts: RERANK_TRANSIENT_ATTEMPTS
 				}, {
@@ -27764,7 +27970,7 @@ Object.assign(MemoryRetriever.prototype, {
 				});
 			} else {
 				reason = "request_error";
-				log$3.warn("rerank error, using pre-rerank results", {
+				log$4.warn("rerank error, using pre-rerank results", {
 					error,
 					attempts: RERANK_TRANSIENT_ATTEMPTS
 				}, {
@@ -27823,7 +28029,7 @@ Object.assign(MemoryRetriever.prototype, {
 				}
 			};
 		});
-		if (dimMismatchCount > 0) log$3.warn("lightweight rerank: chunk vector dim mismatch on some candidates", {
+		if (dimMismatchCount > 0) log$4.warn("lightweight rerank: chunk vector dim mismatch on some candidates", {
 			dimMismatchCount,
 			queryDim: queryVector.length
 		}, {
@@ -27832,7 +28038,7 @@ Object.assign(MemoryRetriever.prototype, {
 			function: "rerankLightweight",
 			site_id: "retrieval.retriever-rerank.rerankLightweight.70eb2031f1"
 		});
-		log$3.debug("lightweight rerank applied", {
+		log$4.debug("lightweight rerank applied", {
 			candidateCount: candidates.length,
 			blendedCount,
 			fusionWeight: wF,
@@ -28230,7 +28436,7 @@ Object.assign(MemoryRetriever.prototype, {
 				...input,
 				signal: memoryOperationSignal(input.signal)
 			});
-			log$3.info("retrieval started", {
+			log$4.info("retrieval started", {
 				queryLength: context.query.length,
 				limit: context.limit,
 				mode: this.config.mode,
@@ -28304,7 +28510,7 @@ Object.assign(MemoryRetriever.prototype, {
 						...traceMetadata && { traceMetadata }
 					});
 				}
-				log$3.info("Memory retrieval completed", {
+				log$4.info("Memory retrieval completed", {
 					store_reference: privateLogReference(this.store.dbPath),
 					outcome: results.length ? "success" : "empty_success",
 					duration_ms: performance.now() - started,
@@ -28331,7 +28537,7 @@ Object.assign(MemoryRetriever.prototype, {
 				});
 				return results;
 			} catch (error) {
-				log$3.error("Memory retrieval failed", {
+				log$4.error("Memory retrieval failed", {
 					outcome: "failed",
 					error,
 					duration_ms: performance.now() - started
@@ -28373,7 +28579,7 @@ Object.assign(MemoryRetriever.prototype, {
 				if (!isExplicitAggregation && this._accessTracker && (this._recallLifecycle?.autoRecallAccessTracking === true || context.source === "manual") && results.length > 0) this._accessTracker.recordAccess(results.map((r) => r.entry.id));
 				if (!isExplicitAggregation && this._recallLifecycle?.tierPromoter && this._tierPromoter && results.length > 0) await this.evaluateTopKTierTransitions(results);
 				if (this._statsCollector) this._statsCollector.recordQuery(finalTrace, context.source ?? "debug");
-				log$3.info("Traced memory retrieval completed", {
+				log$4.info("Traced memory retrieval completed", {
 					outcome: results.length ? "success" : "empty_success",
 					store_reference: privateLogReference(this.store.dbPath),
 					duration_ms: performance.now() - started,
@@ -28398,7 +28604,7 @@ Object.assign(MemoryRetriever.prototype, {
 					trace: finalTrace
 				};
 			} catch (error) {
-				log$3.error("Traced memory retrieval failed", {
+				log$4.error("Traced memory retrieval failed", {
 					outcome: "failed",
 					error,
 					duration_ms: performance.now() - started
@@ -28461,18 +28667,393 @@ Object.assign(MemoryRetriever.prototype, {
 			if (!transition || transition.toTier === tier) continue;
 			await this.store.updateTier(entry.id, transition.toTier, { writerAuthority: "offline-family" });
 		} catch (error) {
-			log$3.warn("tier evaluation failed for memory", {
-				memoryId: r.entry.id,
-				error
-			}, {
-				event_name: "memory.retrieval.tier.failed",
-				file: "packages/memory/src/engine/retrieval/retriever-execution.ts",
-				function: "evaluateTopKTierTransitions",
-				site_id: "memory.retrieval.tier.failed"
-			});
+			log$4.warn("tier evaluation failed for memory", {
+				memoryId: r.entry.id,
+				error
+			}, {
+				event_name: "memory.retrieval.tier.failed",
+				file: "packages/memory/src/engine/retrieval/retriever-execution.ts",
+				function: "evaluateTopKTierTransitions",
+				site_id: "memory.retrieval.tier.failed"
+			});
+		}
+	}
+});
+//#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$3 = 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();
+	journalRecords = 0;
+	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);
+	}
+	static async readCompletedJobs(journalPath) {
+		const completed = /* @__PURE__ */ new Map();
+		for await (const line of readJsonlLines(journalPath)) try {
+			const parsed = remWaveJobSchema.parse(JSON.parse(line));
+			if (parsed.state === "done") completed.set(parsed.waveId, toRemJob(parsed));
+			else completed.delete(parsed.waveId);
+		} catch (error) {
+			log$3.error("rem.journal.failed", {
+				error,
+				path: journalPath
+			}, {
+				event_name: "rem.journal.failed",
+				file: "packages/memory/src/sidecar/rem-job-store.ts",
+				function: "readCompletedJobs",
+				site_id: "rem-job-store.readCompletedJobs.invalid-line"
+			});
+		}
+		return [...completed.values()];
+	}
+	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" && existing.state !== "failed" && 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 }
+			});
+			if (next.state === "done") this.jobs.set(jobId, next);
+			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;
+		await this.removeTornTail();
+		let index = 0;
+		for await (const line of readJsonlLines(this.journalPath)) {
+			index++;
+			this.journalRecords++;
+			try {
+				const job = remWaveJobSchema.parse(JSON.parse(line));
+				this.jobs.set(job.waveId, job);
+				this.mergeKeys.set(`${job.correlationId}\0${job.scope}`, job.waveId);
+			} catch (error) {
+				log$3.error("rem.journal.failed", {
+					path: this.journalPath,
+					line: index,
+					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"
+				});
+			}
+		}
+		if (this.journalRecords >= 256) await this.compact().catch((error) => this.reportFailure(error));
+	}
+	async removeTornTail() {
+		const handle = await open(this.journalPath, "r");
+		let committed = (await handle.stat()).size;
+		const buffer = Buffer.alloc(65536);
+		try {
+			while (committed > 0) {
+				const start = Math.max(0, committed - buffer.length);
+				const { bytesRead } = await handle.read(buffer, 0, committed - start, start);
+				const newline = buffer.subarray(0, bytesRead).lastIndexOf(10);
+				if (newline >= 0) {
+					committed = start + newline + 1;
+					break;
+				}
+				committed = start;
+			}
+			if (committed < (await handle.stat()).size) await this.truncateJournal(committed);
+		} finally {
+			await handle.close();
+		}
+	}
+	async compact() {
+		const cutoff = (/* @__PURE__ */ new Date(Date.now() - 1728e5)).toISOString();
+		const retained = [...this.jobs.values()].filter((job) => job.state === "queued" || job.state === "running" || (job.finishedAt ?? job.startedAt ?? "") >= cutoff);
+		const temporary = `${this.journalPath}.${randomUUID()}.tmp`;
+		const handle = await open(temporary, "wx", 384);
+		try {
+			try {
+				for (const job of retained) await handle.writeFile(`${JSON.stringify(job)}\n`, "utf8");
+				await handle.sync();
+			} finally {
+				await handle.close();
+			}
+			await rename(temporary, this.journalPath);
+			await syncDirectory$1(path.dirname(this.journalPath));
+			const retainedIds = new Set(retained.map((job) => job.waveId));
+			for (const id of this.jobs.keys()) if (!retainedIds.has(id)) {
+				this.jobs.delete(id);
+				this.persistedJobs.delete(id);
+			}
+			for (const [key, id] of this.mergeKeys) if (!retainedIds.has(id)) this.mergeKeys.delete(key);
+			this.journalRecords = 0;
+		} finally {
+			await rm(temporary, { force: true });
+		}
+	}
+	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$3.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);
+		this.journalRecords++;
+		if (this.journalRecords >= 256) {
+			this.jobs.set(job.waveId, job);
+			await this.compact().catch((error) => this.reportFailure(error));
+		}
+		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/rem-entry-foundations.ts
 const sha256Schema = z.string().regex(/^[0-9a-f]{64}$/u);
@@ -29355,6 +29936,10 @@ async function runRemProductionOrderedWave(input) {
 							agentPort: input.agentPort,
 							...input.implementationVersion === void 0 ? {} : { implementationVersion: input.implementationVersion }
 						});
+						if (result.hostRefusal) {
+							if (!(result.actionsApplied > 0 || repository.listJournal(waveId).some((entry) => entry.actionsApplied > 0 || entry.outcome === "no-action" && entry.verdicts > 0))) throw result.hostRefusal;
+							refusal = result.hostRefusal;
+						}
 						results.push({
 							operation: jobType,
 							...result
@@ -29363,7 +29948,10 @@ async function runRemProductionOrderedWave(input) {
 					}
 				}]
 			}))[jobType] === "failed") stageFailed = true;
-			if (refusal) throw refusal;
+			if (refusal) {
+				if (refusal.destination !== "host" || stageFailed) throw refusal;
+				break;
+			}
 		}
 	} finally {
 		journalDatabase.db.close();
@@ -29394,7 +29982,7 @@ async function runRemProductionOrderedWave(input) {
 		candidateCount: Math.max(0, ...results.map((result) => result.candidateCount)),
 		stampedSkippedCount: results.reduce((total, result) => total + result.stampedSkippedCount, 0),
 		parseFailureCount: results.reduce((total, result) => total + result.parseFailureCount, 0),
-		topRefusalReasons: [...new Set(results.flatMap((result) => result.topRefusalReasons))].slice(0, 2),
+		topRefusalReasons: [.../* @__PURE__ */ new Set([...refusal ? [`host-refused:${refusal.callId}`] : [], ...results.flatMap((result) => result.topRefusalReasons)])].slice(0, 2),
 		measurements: {
 			rowsConsidered: Math.max(0, ...results.map((result) => result.measurements.rowsConsidered)),
 			pairsBuilt: results.reduce((total, result) => total + result.measurements.pairsBuilt, 0),
@@ -29499,7 +30087,7 @@ async function runRemBatchJobUnlocked(input) {
 					terminalState: "done",
 					appliedFraction,
 					parseFailureCount,
-					topRefusalReasons
+					topRefusalReasons: [...result.hostRefusal ? [`host-refused:${result.hostRefusal.callId}`] : [], ...topRefusalReasons].slice(0, 2)
 				};
 				return completed;
 			} finally {
@@ -29739,230 +30327,264 @@ function createRemUpdateBudget(configuration) {
 	};
 }
 function recordRemUpdateModelCall(budget, prompt) {
+	if (budget.modelCalls >= (budget.configuration?.budgets.maxPairs ?? 0)) return false;
 	budget.modelCalls += 1;
 	budget.tokens += countTokens(prompt) + REM_MODEL_OUTPUT_TOKEN_CAP;
+	return true;
 }
 async function runUpdate(input) {
 	const budget = createRemUpdateBudget(input.configuration);
-	const candidates = input.candidates;
-	const ports = createSnoStationMemRemPorts({
-		database: input.runtime.database,
-		memoryStore: input.runtime.store
-	});
-	const configurationSha256 = input.configuration === void 0 ? "0".repeat(64) : deriveRemConfigurationSha256(input.configuration);
-	const recovery = createSnoStationMemRemRecovery(input.runtime.database);
-	const mutationExecutor = createSnoStationMemRemMutationExecutor({
-		database: input.runtime.database,
-		jobType: input.jobType,
-		configurationSha256,
-		liveContentionRetries: input.configuration?.retries.liveContentionRetries ?? 0,
-		recovery,
-		applyTextVersion: (write, verification) => ports.conflict.writeTextVersion({
-			...write,
-			verification
-		})
-	});
-	await mutationExecutor.recoverPendingAttempts();
-	const relationEffects = await runProductionUpdateRelations({
-		...input,
-		budget,
-		candidates,
-		configurationSha256,
-		mutationExecutor,
-		recovery
-	});
-	let actionsApplied = relationEffects.actionsApplied;
-	let verdicts = relationEffects.verdicts;
-	let llmCalls = relationEffects.llmCalls;
-	let successfulLlmCalls = relationEffects.successfulLlmCalls;
-	let lastRefusalReason = relationEffects.lastRefusalReason;
-	const stampedRowIds = new Set(input.stampedRows.map((row) => row.id));
-	const owned = candidates.filter((candidate) => candidate.owner === "restate" && !stampedRowIds.has(candidate.id) && !relationEffects.handledRowIds.has(candidate.id));
-	for (const stampedRow of input.stampedRows) {
-		if (relationEffects.handledRowIds.has(stampedRow.id)) continue;
-		appendRefusal(input.repository, input.jobId, input.jobType, stampedRow.id, "already_stamped");
-	}
-	for (const [index, candidate] of owned.entries()) {
-		const claimed = claimCandidate(input.repository, candidate, "restate");
-		if (!claimed) continue;
-		log$1.info("update_progress", {
-			job_id: input.jobId,
-			current: index + 1,
-			total: owned.length,
-			row_id: candidate.id
-		}, {
-			event_name: "sno_station_mem.rem-batch-executor.update.progress",
-			file: "packages/memory/src/sidecar/rem-batch-executor.ts",
-			function: "runUpdate",
-			site_id: "rem-batch-executor.runUpdate.dbf2a836db"
+	try {
+		const candidates = input.candidates;
+		const ports = createSnoStationMemRemPorts({
+			database: input.runtime.database,
+			memoryStore: input.runtime.store
 		});
-		try {
-			if (candidate.state === "ambiguous") {
-				lastRefusalReason = "ambiguous_unresolved";
-				appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, "ambiguous_unresolved");
-				completeCandidate(input.repository, claimed, candidate.content_hash, input.jobId, input.jobType);
-				continue;
-			}
-			if (candidate.state !== "transition") {
-				lastRefusalReason = "row_not_owned";
-				releaseCandidate(input.repository, claimed);
-				appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, "row_not_owned");
-				continue;
-			}
-			if (candidate.category !== "profile" && candidate.category !== "episodic" && candidate.category !== "state") {
-				lastRefusalReason = "missing_row_kind";
-				releaseCandidate(input.repository, claimed);
-				appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, "missing_row_kind");
-				continue;
-			}
-			const enumeratedMembers = enumerateRemUpdateMembers(candidate.text);
-			const prompt = renderRemUpdateJudgmentPrompt({
-				judgmentSkill: REM_UPDATE_JUDGMENT_SKILL.rewrite,
-				source: candidate.text,
-				...enumeratedMembers.length === 0 ? {} : { enumeratedMembers }
-			});
-			recordRemUpdateModelCall(budget, prompt);
-			llmCalls += 1;
-			const reply = await completeJsonStage(input.runtime, "rem-update-judgment", prompt);
-			const decision = decideRemUpdateFromReply(typeof reply === "string" ? reply : JSON.stringify(reply) ?? "");
-			log$1.info("update_decision_evaluated", {
+		const configurationSha256 = input.configuration === void 0 ? "0".repeat(64) : deriveRemConfigurationSha256(input.configuration);
+		const recovery = createSnoStationMemRemRecovery(input.runtime.database);
+		const mutationExecutor = createSnoStationMemRemMutationExecutor({
+			database: input.runtime.database,
+			jobType: input.jobType,
+			configurationSha256,
+			liveContentionRetries: input.configuration?.retries.liveContentionRetries ?? 0,
+			recovery,
+			applyTextVersion: (write, verification) => ports.conflict.writeTextVersion({
+				...write,
+				verification
+			})
+		});
+		await mutationExecutor.recoverPendingAttempts();
+		const relationEffects = await runProductionUpdateRelations({
+			...input,
+			budget,
+			candidates,
+			configurationSha256,
+			mutationExecutor,
+			recovery
+		});
+		let actionsApplied = relationEffects.actionsApplied;
+		let verdicts = relationEffects.verdicts;
+		let llmCalls = relationEffects.llmCalls;
+		let successfulLlmCalls = relationEffects.successfulLlmCalls;
+		let lastRefusalReason = relationEffects.lastRefusalReason;
+		const stampedRowIds = new Set(input.stampedRows.map((row) => row.id));
+		const owned = candidates.filter((candidate) => candidate.owner === "restate" && !stampedRowIds.has(candidate.id) && !relationEffects.handledRowIds.has(candidate.id));
+		for (const stampedRow of input.stampedRows) {
+			if (relationEffects.handledRowIds.has(stampedRow.id)) continue;
+			appendRefusal(input.repository, input.jobId, input.jobType, stampedRow.id, "already_stamped");
+		}
+		for (const [index, candidate] of owned.entries()) {
+			const claimed = claimCandidate(input.repository, candidate, "restate");
+			if (!claimed) continue;
+			log$1.info("update_progress", {
 				job_id: input.jobId,
-				row_id: candidate.id,
-				outcome: decision.outcome,
-				...decision.outcome === "refuse" ? { reason: decision.reason } : { retired_value_count: decision.retiredValues.length }
+				current: index + 1,
+				total: owned.length,
+				row_id: candidate.id
 			}, {
-				event_name: "sno_station_mem.rem-batch-executor.update.decision.evaluated",
+				event_name: "sno_station_mem.rem-batch-executor.update.progress",
 				file: "packages/memory/src/sidecar/rem-batch-executor.ts",
 				function: "runUpdate",
-				site_id: "rem-batch-executor.runUpdate.7dfc387204"
+				site_id: "rem-batch-executor.runUpdate.dbf2a836db"
 			});
-			if (decision.outcome === "refuse") {
-				if (decision.reason !== "model_response_invalid") {
-					successfulLlmCalls += 1;
-					if (decision.reason !== "no_retired_fact") verdicts += 1;
+			try {
+				if (candidate.state === "ambiguous") {
+					lastRefusalReason = "ambiguous_unresolved";
+					appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, "ambiguous_unresolved");
+					completeCandidate(input.repository, claimed, candidate.content_hash, input.jobId, input.jobType);
+					continue;
 				}
-				lastRefusalReason = decision.reason;
-				releaseCandidate(input.repository, claimed);
-				appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, decision.reason);
-				continue;
-			}
-			successfulLlmCalls += 1;
-			const verificationPrompt = renderRemUpdateVerificationPrompt({
-				judgmentSkill: REM_UPDATE_JUDGMENT_SKILL.verification,
-				source: candidate.text,
-				proposedCurrent: decision.proposedCurrent,
-				retiredValues: decision.retiredValues
-			});
-			recordRemUpdateModelCall(budget, verificationPrompt);
-			llmCalls += 1;
-			const verificationReply = await completeJsonStage(input.runtime, "rem-update-verification", verificationPrompt);
-			const verification = decideRemUpdateVerification(typeof verificationReply === "string" ? verificationReply : JSON.stringify(verificationReply) ?? "");
-			log$1.info("update_verification_evaluated", {
-				job_id: input.jobId,
-				row_id: candidate.id,
-				outcome: verification.outcome,
-				...verification.outcome === "refuse" ? { reason: verification.reason } : {}
-			}, {
-				event_name: "sno_station_mem.rem-batch-executor.update.verification.evaluated",
-				file: "packages/memory/src/sidecar/rem-batch-executor.ts",
-				function: "runUpdate",
-				site_id: "rem-batch-executor.runUpdate.7ffc737c24"
-			});
-			if (verification.outcome === "refuse") {
-				if (verification.reason !== "model_response_invalid") {
-					successfulLlmCalls += 1;
-					verdicts += 1;
+				if (candidate.state !== "transition") {
+					lastRefusalReason = "row_not_owned";
+					releaseCandidate(input.repository, claimed);
+					appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, "row_not_owned");
+					continue;
 				}
-				lastRefusalReason = verification.reason;
-				releaseCandidate(input.repository, claimed);
-				appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, verification.reason);
-				continue;
-			}
-			successfulLlmCalls += 1;
-			verdicts += 1;
-			const rewriteConfig = {
-				implementationVersion: input.implementationVersion ?? "rem-update-v1",
-				memoryKind: candidate.category,
-				locale: candidate.locale,
-				localeResource: getRemUpdateLocaleResource(candidate.locale)
-			};
-			const updateStamp = deriveRemUpdateStamp({
-				source: candidate.text,
-				...rewriteConfig
-			});
-			const evidenceId = `rem-update:${input.jobId}:${candidate.id}:rewrite`;
-			input.runtime.database.prepare(`INSERT OR REPLACE INTO nodix_rem_write_verdicts(
+				if (candidate.category !== "profile" && candidate.category !== "episodic" && candidate.category !== "state") {
+					lastRefusalReason = "missing_row_kind";
+					releaseCandidate(input.repository, claimed);
+					appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, "missing_row_kind");
+					continue;
+				}
+				const enumeratedMembers = enumerateRemUpdateMembers(candidate.text);
+				const prompt = renderRemUpdateJudgmentPrompt({
+					judgmentSkill: REM_UPDATE_JUDGMENT_SKILL.rewrite,
+					source: candidate.text,
+					...enumeratedMembers.length === 0 ? {} : { enumeratedMembers }
+				});
+				if (!recordRemUpdateModelCall(budget, prompt)) {
+					releaseCandidate(input.repository, claimed);
+					break;
+				}
+				llmCalls += 1;
+				const reply = await completeJsonStage(input.runtime, "rem-update-judgment", prompt);
+				const decision = decideRemUpdateFromReply(typeof reply === "string" ? reply : JSON.stringify(reply) ?? "");
+				log$1.info("update_decision_evaluated", {
+					job_id: input.jobId,
+					row_id: candidate.id,
+					outcome: decision.outcome,
+					...decision.outcome === "refuse" ? { reason: decision.reason } : { retired_value_count: decision.retiredValues.length }
+				}, {
+					event_name: "sno_station_mem.rem-batch-executor.update.decision.evaluated",
+					file: "packages/memory/src/sidecar/rem-batch-executor.ts",
+					function: "runUpdate",
+					site_id: "rem-batch-executor.runUpdate.7dfc387204"
+				});
+				if (decision.outcome === "refuse") {
+					if (decision.reason !== "model_response_invalid") {
+						successfulLlmCalls += 1;
+						if (decision.reason !== "no_retired_fact") verdicts += 1;
+					}
+					lastRefusalReason = decision.reason;
+					releaseCandidate(input.repository, claimed);
+					appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, decision.reason);
+					continue;
+				}
+				successfulLlmCalls += 1;
+				const verificationPrompt = renderRemUpdateVerificationPrompt({
+					judgmentSkill: REM_UPDATE_JUDGMENT_SKILL.verification,
+					source: candidate.text,
+					proposedCurrent: decision.proposedCurrent,
+					retiredValues: decision.retiredValues
+				});
+				if (!recordRemUpdateModelCall(budget, verificationPrompt)) {
+					releaseCandidate(input.repository, claimed);
+					break;
+				}
+				llmCalls += 1;
+				const verificationReply = await completeJsonStage(input.runtime, "rem-update-verification", verificationPrompt);
+				const verification = decideRemUpdateVerification(typeof verificationReply === "string" ? verificationReply : JSON.stringify(verificationReply) ?? "");
+				log$1.info("update_verification_evaluated", {
+					job_id: input.jobId,
+					row_id: candidate.id,
+					outcome: verification.outcome,
+					...verification.outcome === "refuse" ? { reason: verification.reason } : {}
+				}, {
+					event_name: "sno_station_mem.rem-batch-executor.update.verification.evaluated",
+					file: "packages/memory/src/sidecar/rem-batch-executor.ts",
+					function: "runUpdate",
+					site_id: "rem-batch-executor.runUpdate.7ffc737c24"
+				});
+				if (verification.outcome === "refuse") {
+					if (verification.reason !== "model_response_invalid") {
+						successfulLlmCalls += 1;
+						verdicts += 1;
+					}
+					lastRefusalReason = verification.reason;
+					releaseCandidate(input.repository, claimed);
+					appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, verification.reason);
+					continue;
+				}
+				successfulLlmCalls += 1;
+				verdicts += 1;
+				const rewriteConfig = {
+					implementationVersion: input.implementationVersion ?? "rem-update-v1",
+					memoryKind: candidate.category,
+					locale: candidate.locale,
+					localeResource: getRemUpdateLocaleResource(candidate.locale)
+				};
+				const updateStamp = deriveRemUpdateStamp({
+					source: candidate.text,
+					...rewriteConfig
+				});
+				const evidenceId = `rem-update:${input.jobId}:${candidate.id}:rewrite`;
+				input.runtime.database.prepare(`INSERT OR REPLACE INTO nodix_rem_write_verdicts(
 						evidence_id, winner_row_id, loser_row_id, target_row_id,
 						retired_fact_atoms_json, recorded_at
 					) VALUES (?, ?, ?, ?, ?, ?)`).run(evidenceId, candidate.id, candidate.id, candidate.id, JSON.stringify([candidate.text]), ports.clock.now());
-			const handle = await mutationExecutor.openAttempt({
-				jobId: input.jobId,
-				stage: "rem-update",
-				rowId: candidate.id,
-				writer: "writeTextVersion",
-				authorization: {
+				const handle = await mutationExecutor.openAttempt({
+					jobId: input.jobId,
+					stage: "rem-update",
 					rowId: candidate.id,
-					preWriteContentSha256: candidate.content_hash,
-					proposedTextSha256: sha256(decision.proposedCurrent),
-					evidenceId,
-					configurationSha256
+					writer: "writeTextVersion",
+					authorization: {
+						rowId: candidate.id,
+						preWriteContentSha256: candidate.content_hash,
+						proposedTextSha256: sha256(decision.proposedCurrent),
+						evidenceId,
+						configurationSha256
+					}
+				});
+				const resolution = await mutationExecutor.mutateAttempt(handle, {
+					kind: "writeTextVersion",
+					replacementText: decision.proposedCurrent,
+					historyText: candidate.text,
+					supersededItems: decision.retiredValues,
+					sourceVersion: candidate.text,
+					rewriteConfig,
+					idempotencyKey: updateStamp,
+					reason: "REM update accepted the model judgment and mechanical source checks.",
+					timestamp: ports.clock.now()
+				});
+				const outcome = await mutationExecutor.closeAttempt(handle, resolution);
+				if (outcome.outcome !== "succeeded") {
+					releaseCandidate(input.repository, claimed);
+					appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, outcome.reasonCode ?? "mutation_failed");
+					continue;
 				}
-			});
-			const resolution = await mutationExecutor.mutateAttempt(handle, {
-				kind: "writeTextVersion",
-				replacementText: decision.proposedCurrent,
-				historyText: candidate.text,
-				supersededItems: decision.retiredValues,
-				sourceVersion: candidate.text,
-				rewriteConfig,
-				idempotencyKey: updateStamp,
-				reason: "REM update accepted the model judgment and mechanical source checks.",
-				timestamp: ports.clock.now()
-			});
-			const outcome = await mutationExecutor.closeAttempt(handle, resolution);
-			if (outcome.outcome !== "succeeded") {
+				if (outcome.postWriteContentSha256 === null) throw new Error("successful REM write attempt omitted its post-write content hash");
+				actionsApplied += 1;
+				completeCandidate(input.repository, claimed, outcome.postWriteContentSha256, input.jobId, input.jobType);
+			} catch (error) {
 				releaseCandidate(input.repository, claimed);
-				appendRefusal(input.repository, input.jobId, input.jobType, candidate.id, outcome.reasonCode ?? "mutation_failed");
-				continue;
+				throw error;
 			}
-			if (outcome.postWriteContentSha256 === null) throw new Error("successful REM write attempt omitted its post-write content hash");
-			actionsApplied += 1;
-			completeCandidate(input.repository, claimed, outcome.postWriteContentSha256, input.jobId, input.jobType);
-		} catch (error) {
-			releaseCandidate(input.repository, claimed);
-			throw error;
 		}
+		if (llmCalls > 0 && successfulLlmCalls === 0) throw new Error(`REM LLM calls all failed: ${lastRefusalReason ?? input.runtime.llm.getLastError() ?? "unknown"}`);
+		const updateRows = appliedUnitStatistics(owned.length, actionsApplied - relationEffects.actionsApplied);
+		const relationPairs = appliedUnitStatistics(relationEffects.pairsScanned, relationEffects.actionsApplied);
+		input.repository.appendJournal(input.jobId, input.jobType, {
+			stage: "update-rows",
+			outcome: updateRows.applied > 0 ? "done" : "no-action",
+			pairsScanned: updateRows.considered,
+			verdicts: 0,
+			actionsApplied: updateRows.applied
+		});
+		input.repository.appendJournal(input.jobId, input.jobType, {
+			stage: "update-relation-pairs",
+			outcome: relationPairs.applied > 0 ? "done" : "no-action",
+			pairsScanned: relationPairs.considered,
+			verdicts: 0,
+			actionsApplied: relationPairs.applied
+		});
+		return {
+			...journal(input.jobType, relationEffects.pairsScanned, verdicts, actionsApplied),
+			updateRows,
+			relationPairs,
+			measurements: {
+				rowsConsidered: candidates.length,
+				pairsBuilt: 0,
+				pairCapBinding: budget.modelCalls >= (input.configuration?.budgets.maxPairs ?? 0),
+				modelCalls: budget.modelCalls,
+				modelTokens: budget.tokens,
+				wallMs: Date.now() - budget.startedAtMs
+			}
+		};
+	} catch (error) {
+		if (!(error instanceof ModelCallRefusedError) || error.destination !== "host") throw error;
+		const entries = input.repository.listJournal(input.jobId, input.jobType);
+		const applied = input.runtime.database.prepare(`SELECT count(*) AS count FROM (
+			SELECT row_id FROM nodix_rem_write_attempts
+			WHERE job_id = ? AND stage LIKE 'rem-update%' AND outcome = 'succeeded'
+			  AND writer IN ('softClose', 'writeTextVersion')
+			UNION
+			SELECT json_extract(detail, '$.targetRowId') FROM nodix_rem_journal
+			WHERE job_id = ? AND job_type = 'rem-update' AND outcome = 'done'
+			  AND stage LIKE 'update-retirement-target:%'
+		)`).get(input.jobId, input.jobId);
+		return {
+			...journal(input.jobType, entries.reduce((total, entry) => total + entry.pairsScanned, 0), entries.reduce((total, entry) => total + entry.verdicts, 0), applied.count),
+			hostRefusal: error,
+			measurements: {
+				rowsConsidered: input.candidates.length,
+				pairsBuilt: 0,
+				pairCapBinding: true,
+				modelCalls: budget.modelCalls,
+				modelTokens: budget.tokens,
+				wallMs: Date.now() - budget.startedAtMs
+			}
+		};
 	}
-	if (llmCalls > 0 && successfulLlmCalls === 0) throw new Error(`REM LLM calls all failed: ${lastRefusalReason ?? input.runtime.llm.getLastError() ?? "unknown"}`);
-	const updateRows = appliedUnitStatistics(owned.length, actionsApplied - relationEffects.actionsApplied);
-	const relationPairs = appliedUnitStatistics(relationEffects.pairsScanned, relationEffects.actionsApplied);
-	input.repository.appendJournal(input.jobId, input.jobType, {
-		stage: "update-rows",
-		outcome: updateRows.applied > 0 ? "done" : "no-action",
-		pairsScanned: updateRows.considered,
-		verdicts: 0,
-		actionsApplied: updateRows.applied
-	});
-	input.repository.appendJournal(input.jobId, input.jobType, {
-		stage: "update-relation-pairs",
-		outcome: relationPairs.applied > 0 ? "done" : "no-action",
-		pairsScanned: relationPairs.considered,
-		verdicts: 0,
-		actionsApplied: relationPairs.applied
-	});
-	return {
-		...journal(input.jobType, relationEffects.pairsScanned, verdicts, actionsApplied),
-		updateRows,
-		relationPairs,
-		measurements: {
-			rowsConsidered: candidates.length,
-			pairsBuilt: 0,
-			pairCapBinding: false,
-			modelCalls: budget.modelCalls,
-			modelTokens: budget.tokens,
-			wallMs: Date.now() - budget.startedAtMs
-		}
-	};
 }
 function appliedUnitStatistics(considered, applied) {
 	return {
@@ -29991,6 +30613,7 @@ async function runProductionUpdateRelations(input) {
 	let successfulLlmCalls = 0;
 	let verdicts = 0;
 	for (let workIndex = 0; workIndex < relationWork.length; workIndex += 1) {
+		if (input.budget.modelCalls >= input.configuration.budgets.maxPairs) break;
 		const work = relationWork[workIndex];
 		if (work === void 0) continue;
 		const { candidates } = work;
@@ -29998,6 +30621,7 @@ async function runProductionUpdateRelations(input) {
 		let retirementApplied = retirementPair !== void 0;
 		const nominatedRows = candidates.filter((candidate) => candidate.owner === "restate" || candidate.state === "pure-negation").sort((left, right) => compareMemorySourceOrder(rowOrderKey(right), rowOrderKey(left)) || right.id.localeCompare(left.id));
 		for (const nominatedRow of retirementPair === void 0 ? nominatedRows : []) {
+			if (input.budget.modelCalls >= input.configuration.budgets.maxPairs) break;
 			if (handledRowIds.has(nominatedRow.id)) continue;
 			const candidateSet = await buildRemRetirementCandidateSet({
 				runtime: input.runtime,
@@ -30059,7 +30683,7 @@ async function runProductionUpdateRelations(input) {
 			predecessorTexts: [prior.text],
 			successorTexts: linked.map((candidate) => candidate.text)
 		});
-		recordRemUpdateModelCall(input.budget, prompt);
+		if (!recordRemUpdateModelCall(input.budget, prompt)) break;
 		llmCalls += 1;
 		const reply = await completeTextStage(input.runtime, "rem-update-relation-judgment", prompt);
 		let relation = decideRemUpdateRelationFromReply(reply ?? "");
@@ -30099,7 +30723,7 @@ async function runProductionUpdateRelations(input) {
 				source: prior.text,
 				supersedingText: relationCandidate.text
 			});
-			recordRemUpdateModelCall(input.budget, rewritePrompt);
+			if (!recordRemUpdateModelCall(input.budget, rewritePrompt)) break;
 			llmCalls += 1;
 			const rewriteReply = await completeJsonStage(input.runtime, "rem-update-judgment", rewritePrompt);
 			const rewrite = decideRemUpdateFromReply(typeof rewriteReply === "string" ? rewriteReply : JSON.stringify(rewriteReply) ?? "");
@@ -30120,7 +30744,7 @@ async function runProductionUpdateRelations(input) {
 				proposedCurrent: rewrite.proposedCurrent,
 				retiredValues: rewrite.retiredValues
 			});
-			recordRemUpdateModelCall(input.budget, verificationPrompt);
+			if (!recordRemUpdateModelCall(input.budget, verificationPrompt)) break;
 			llmCalls += 1;
 			const verificationReply = await completeJsonStage(input.runtime, "rem-update-verification", verificationPrompt);
 			const verification = decideRemUpdateVerification(typeof verificationReply === "string" ? verificationReply : JSON.stringify(verificationReply) ?? "");
@@ -30152,7 +30776,7 @@ async function runProductionUpdateRelations(input) {
 				retiredValues: [prior.text],
 				retractionText: retraction.text
 			});
-			recordRemUpdateModelCall(input.budget, verificationPrompt);
+			if (!recordRemUpdateModelCall(input.budget, verificationPrompt)) break;
 			llmCalls += 1;
 			const verificationReply = await completeJsonStage(input.runtime, "rem-update-verification", verificationPrompt);
 			const verification = decideRemUpdateVerification(typeof verificationReply === "string" ? verificationReply : JSON.stringify(verificationReply) ?? "");
@@ -30370,7 +30994,7 @@ async function runRemRetirementTargetGate(input) {
 				text: candidate.text
 			}))
 		});
-		recordRemUpdateModelCall(input.budget, prompt);
+		if (!recordRemUpdateModelCall(input.budget, prompt)) break;
 		llmCalls += 1;
 		let reply = null;
 		try {
@@ -31145,7 +31769,19 @@ async function runReplace(input) {
 				claimToken: candidate.claimToken
 			}));
 		}
-		throw error;
+		if (!(error instanceof ModelCallRefusedError) || error.destination !== "host") throw error;
+		return {
+			...journal(input.jobType, pairsScanned, verdicts, actionsApplied),
+			hostRefusal: error,
+			measurements: {
+				rowsConsidered: input.candidates.length,
+				pairsBuilt: indexedPairs.length,
+				pairCapBinding: true,
+				modelCalls: llmCalls,
+				modelTokens,
+				wallMs: Date.now() - startedAtMs
+			}
+		};
 	}
 	for (const candidate of participatingClaimed) {
 		const modified = completedContentHashes.has(candidate.id) || closedRowIds.has(candidate.id);
@@ -31303,7 +31939,7 @@ async function buildRemReplaceCandidateQueue(input) {
 					vectors = lookup.readVectors(projectCurrent.map((row) => row.id));
 					currentVectors.set(candidate.project_id, vectors);
 				}
-				found = pairWithNearest(pairs, candidate, projectCurrent, vector, vectors, 10) || found;
+				found = pairWithNearest(pairs, candidate, projectCurrent, vector, vectors, 3) || found;
 			}
 			matches = await lookup.searchSemantic(vector, {
 				category: candidate.category,
@@ -32015,6 +32651,28 @@ async function evaluateScope(input, auditStateDir, state, scope, candidateCount,
 	}
 	const correlationId = remAutomaticCorrelationId(trigger, scope, trigger === "daily" ? nextDue.toISOString() : localDate);
 	const priorAttempts = scopeState.attempts.identity === correlationId ? scopeState.attempts.count : 0;
+	if (priorAttempts >= 3) {
+		await recordDecision(auditStateDir, scope, "skipped", {
+			row: "attempt-limit",
+			trigger,
+			local_date: localDate,
+			correlation_id: correlationId,
+			attempts: priorAttempts
+		});
+		const nextState = replaceScopeState(state, scope, {
+			...scopeState,
+			last_volume_pass_date: localDate,
+			attempts: {
+				identity: null,
+				count: 0
+			}
+		});
+		await writeRemTriggerStateAtomic(input.stateDir, nextState);
+		return {
+			state: nextState,
+			dispatched: false
+		};
+	}
 	await recordDecision(auditStateDir, scope, "ok", {
 		row: "dispatch",
 		trigger,
@@ -32109,6 +32767,40 @@ async function dispatchRemWave(input, scope, correlationId) {
 	});
 }
 async function applyCompletedBaselines(auditStateDir, triggerStateDir, state) {
+	const durableCorrelations = /* @__PURE__ */ new Set();
+	try {
+		const completedJobs = await RemJobStore.readCompletedJobs(path.join(triggerStateDir, "rem-wave-jobs.jsonl"));
+		for (const job of completedJobs) {
+			durableCorrelations.add(job.correlation_id);
+			const current = state.scopes[job.scope];
+			if (!current || !job.correlation_id.startsWith("rem-auto-") || !job.started_at) continue;
+			const localDate = localDateAt(new Date(job.started_at), current.schedule_zone);
+			const measured = job.stats.measured;
+			const completedScope = {
+				...current,
+				last_pass_at: job.started_at > current.last_pass_at ? job.started_at : current.last_pass_at,
+				last_volume_pass_date: localDate > (current.last_volume_pass_date ?? "") ? localDate : current.last_volume_pass_date,
+				...current.attempts.identity === job.correlation_id ? { attempts: {
+					identity: null,
+					count: 0
+				} } : {},
+				...measured?.pair_cap_binding === false ? { last_covered_count: measured.rows_considered } : {}
+			};
+			if (JSON.stringify(current) === JSON.stringify(completedScope)) continue;
+			state = replaceScopeState(state, job.scope, completedScope);
+			await writeRemTriggerStateAtomic(triggerStateDir, state);
+		}
+	} catch (error) {
+		log.warn("REM completion jobs could not be read", {
+			error,
+			outcome: "partial"
+		}, {
+			event_name: "sidecar.trigger.completion_jobs.read.failed",
+			file: "packages/memory/src/sidecar/rem-trigger.ts",
+			function: "applyCompletedBaselines",
+			site_id: "sidecar.trigger.completion_jobs.read.failed"
+		});
+	}
 	let content;
 	try {
 		content = await readAuditTail(getAuditPath(auditStateDir));
@@ -32127,7 +32819,6 @@ async function applyCompletedBaselines(auditStateDir, triggerStateDir, state) {
 		return state;
 	}
 	const dispatched = /* @__PURE__ */ new Map();
-	const triesByCorrelation = /* @__PURE__ */ new Map();
 	let nextState = state;
 	let malformedCount = 0;
 	for (const line of content.split("\n")) {
@@ -32149,28 +32840,6 @@ async function applyCompletedBaselines(auditStateDir, triggerStateDir, state) {
 				});
 				continue;
 			}
-			if (entry["event"] === "rem_skipped" && typeof correlationId === "string") {
-				const skipped = dispatched.get(correlationId);
-				const tries = (triesByCorrelation.get(correlationId) ?? 0) + (typeof details?.["destination"] === "string" ? 1 : 0);
-				triesByCorrelation.set(correlationId, tries);
-				const skippedScopeState = skipped ? nextState.scopes[skipped.scope] : void 0;
-				if (skipped && skippedScopeState && tries >= 3 && isLocalDate(skipped.localDate) && (skippedScopeState.last_volume_pass_date ?? "") < skipped.localDate) nextState = replaceScopeState(nextState, skipped.scope, {
-					...skippedScopeState,
-					last_volume_pass_date: skipped.localDate,
-					attempts: {
-						identity: null,
-						count: 0
-					}
-				});
-				else if (skipped && skippedScopeState?.attempts.identity === correlationId) nextState = replaceScopeState(nextState, skipped.scope, {
-					...skippedScopeState,
-					attempts: {
-						identity: null,
-						count: 0
-					}
-				});
-				continue;
-			}
 			if (entry["event"] === "rem_failed" && details?.["source"] === "sidecar" && typeof correlationId === "string") {
 				const failed = dispatched.get(correlationId);
 				const failedScopeState = failed ? nextState.scopes[failed.scope] : void 0;
@@ -32184,15 +32853,15 @@ async function applyCompletedBaselines(auditStateDir, triggerStateDir, state) {
 				});
 				continue;
 			}
-			if (entry["event"] !== "rem_completed" || typeof correlationId !== "string") continue;
+			if (entry["event"] !== "rem_completed" || typeof correlationId !== "string" || durableCorrelations.has(correlationId)) 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 } : {},
+				...dispatch.trigger === "daily" && isValidInstant(dispatch.passAt) && dispatch.passAt > currentScopeState.last_pass_at ? { last_pass_at: dispatch.passAt } : {},
+				...dispatch.trigger === "daily" && isLocalDate(dispatch.localDate) && dispatch.localDate > (currentScopeState.last_volume_pass_date ?? "") ? { last_volume_pass_date: dispatch.localDate } : {},
+				...dispatch.trigger === "volume" && isLocalDate(dispatch.localDate) && dispatch.localDate > (currentScopeState.last_volume_pass_date ?? "") ? { last_volume_pass_date: dispatch.localDate } : {},
 				...currentScopeState.attempts.identity === correlationId ? { attempts: {
 					identity: null,
 					count: 0
@@ -32200,7 +32869,7 @@ async function applyCompletedBaselines(auditStateDir, triggerStateDir, state) {
 			};
 			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 = {
+			if ((!isValidInstant(dispatch.passAt) || dispatch.passAt >= currentScopeState.last_pass_at) && measured?.["pair_cap_binding"] === false && Number.isInteger(rowsConsidered) && Number(rowsConsidered) >= 0) completedScopeState = {
 				...completedScopeState,
 				last_covered_count: Number(rowsConsidered)
 			};
@@ -32396,4 +33065,4 @@ function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
-export { compareMemorySourceOrder as $, ATOMIC_EXTRACTION_SKILL as $t, recordTokenCounter as A, classifyLlmFailure as At, validateMemoryTelemetryMetadata as B, truncateGraphemes as Bt, resolveHookAgentId as C, createScopePolicy as Ct, closeAtomicArrivalRetirementTargets as D, createLlmClient as Dt, recordAtomicEntityIdentityJournal as E, ModelCallRefusedError as Et, AtomicExtractionCompletedElsewhere as F, clamp01 as Ft, parseRemOperationType as G, normalizeIsoDateTimeString as Gt, readChunkVecTableState as H, buildInsightMetadata as Ht, normalizeMemoryRelationPredicate as I, clampInt as It, orderAdapterAPair as J, AGGREGATION_OPERATIONS as Jt, adapterAViewFromRecord as K, parseIsoDateTimeMs as Kt, MemoryStore as L, stableHash as Lt, canonicalizeProfileSectionName as M, CODING_SKIN_LEDGER_MAX_CHARS as Mt, normalizeTopicToSectionName as N, CODING_SKIN_SESSION_QUERY as Nt, journalAtomicArrivalRetirementRefusal as O, isTerminalLlmFailure as Ot, getSnoStationMemDataDir as P, HOST_MODEL_DEADLINE_HEADER as Pt, renderAdapterAPrompt as Q, resolveLlmRoute as Qt, StaleSupersedeTargetError as R, stripHtmlTags as Rt, resolveTaskLifecycleEffectiveTime as S, MemoryScopePolicy as St, normalizeEntityName as T, LlmClientTerminalError as Tt, loadSqliteVecExtension as U, parseInsightMetadata as Ut, randomUUID$1 as V, redactSecrets as Vt, REM_BUILT_OPERATION_TYPES as W, stringifyInsightMetadata as Wt, prospectiveProfileView as X, normalizeCategory as Xt, parseAdapterAChatVerdict as Y, MEMORY_CATEGORIES as Yt, renderAdapterAChatPrompt as Z, pickLlmRoutingConfig as Zt, findUniqueActiveTaskByDescription as _, memoryFileWrite as _n, ALL_RESOURCES as _t, enumerateRemCandidateScopes as a, relations as an, runWithMemoryAudit as at, admitTaskLifecycleAssertion as b, forwardObserveLedgerUntilIdle as bn, SnoStationMemError as bt, runRemProductionOrderedWave as c, isCalendarLabel as cn, readJsonlLines as ct, MemoryRetriever as d, MEMORY_TELEMETRY_DELETE_REASONS as dn, resolveMemoryDate as dt, ATOMIC_EXTRACTION_SKILL_HASH as en, readMemorySourceOrderOrOldest as et, DEFAULT_RETRIEVAL_CONFIG as f, isMemoryTelemetryEventType as fn, unresolvedMemoryDate as ft, buildTaskLifecycleCandidateSet as g, checkMemoryOperation as gn, normalizeAmbientLearningText as gt, acceptsTaskLifecycleJudgment as h, openSqliteDatabaseReadonly as hn, stripEnvelopeMetadata as ht, createRemModelStageResponsePort as i, state_vocabulary_default as in, getAuditPath as it, canExtractorWrite as j, isTerminalLlmFailure$1 as jt, readAtomicArrivalRetirementCandidateSet as k, withProviderResponses as kt, runWithCanonicalStoreWriteMutex as l, sessionZoneCarriedBy as ln, parseSessionTimestamp as lt, Embedder as m, openSqliteDatabase as mn, buildIndexedText as mt, remNeedsHost as n, modelReplyJsonCandidates as nn, appendAuditEntryStrict as nt, readCandidates as o, calculateCalendarTime as on, runWithMemoryAuditSync as ot, AccessTracker as p, initSqliteRuntime as pn, boundSectionContent as pt, isAdapterAVerdictReply as q, deriveFactKey as qt, buildRemReplaceCandidateQueue as r, readModelReplyJson as rn, currentMutationAttemptId as rt, runRemBatchJob as s, calendarInstructionSchema as sn, runWithMutationAttempt as st, evaluateRemAutomaticTriggers as t, atomicExtractionSkillReference as tn, appendAuditEntry as tt, selectRemUpdateRelationCandidates as u, attribute_dictionary_default as un, serializeIntervalMetadata as ut, resolveTaskLifecycle as v, memoryOperationSignal as vn, RESOURCES_BY_LOCALE as vt, listAtomicMemoryEntityCandidates as w, parseAgentIdFromSessionKey$1 as wt, buildTaskLifecycleCommandClaim as x, StorageError as xt, taskLifecycleCandidateSetVersion as y, withMemoryOperation as yn, RetrievalError as yt, TaskLifecycleStaleResolutionError as z, stripRoleLabelPrefix as zt };
+export { renderAdapterAChatPrompt as $, MEMORY_CATEGORIES as $t, journalAtomicArrivalRetirementRefusal as A, getAuditPath as At, StaleSupersedeTargetError as B, debugContentPreview as Bt, buildTaskLifecycleCommandClaim as C, withMemoryOperation as Cn, withProviderResponses as Ct, normalizeEntityName as D, appendAuditEntryStrict as Dt, listAtomicMemoryEntityCandidates as E, appendAuditEntry as Et, normalizeTopicToSectionName as F, CODING_SKIN_LEDGER_MAX_CHARS as Ft, loadSqliteVecExtension as G, redactSecrets as Gt, validateMemoryTelemetryMetadata as H, stripHtmlTags as Ht, getSnoStationMemDataDir as I, CODING_SKIN_SESSION_QUERY as It, adapterAViewFromRecord as J, stringifyInsightMetadata as Jt, REM_BUILT_OPERATION_TYPES as K, buildInsightMetadata as Kt, AtomicExtractionCompletedElsewhere as L, HOST_MODEL_DEADLINE_HEADER as Lt, recordTokenCounter as M, runWithMemoryAuditSync as Mt, canExtractorWrite as N, runWithMutationAttempt as Nt, recordAtomicEntityIdentityJournal as O, compactAuditLog as Ot, canonicalizeProfileSectionName as P, readJsonlLines as Pt, prospectiveProfileView as Q, AGGREGATION_OPERATIONS as Qt, normalizeMemoryRelationPredicate as R, clamp01 as Rt, admitTaskLifecycleAssertion as S, memoryOperationSignal as Sn, isTerminalLlmFailure as St, resolveHookAgentId as T, isTerminalLlmFailure$1 as Tt, randomUUID$1 as U, stripRoleLabelPrefix as Ut, TaskLifecycleStaleResolutionError as V, stableHash as Vt, readChunkVecTableState as W, truncateGraphemes as Wt, orderAdapterAPair as X, parseIsoDateTimeMs as Xt, isAdapterAVerdictReply as Y, normalizeIsoDateTimeString as Yt, parseAdapterAChatVerdict as Z, deriveFactKey as Zt, acceptsTaskLifecycleJudgment as _, initSqliteRuntime as _n, createScopePolicy as _t, enumerateRemCandidateScopes as a, atomicExtractionSkillReference as an, resolveMemoryDate as at, resolveTaskLifecycle as b, checkMemoryOperation as bn, ModelCallRefusedError as bt, runRemProductionOrderedWave as c, state_vocabulary_default as cn, buildIndexedText as ct, RemJobStore as d, calendarInstructionSchema as dn, ALL_RESOURCES as dt, normalizeCategory as en, renderAdapterAPrompt as et, parseRemJobStats as f, isCalendarLabel as fn, RESOURCES_BY_LOCALE as ft, Embedder as g, isMemoryTelemetryEventType as gn, MemoryScopePolicy as gt, AccessTracker as h, MEMORY_TELEMETRY_DELETE_REASONS as hn, StorageError as ht, createRemModelStageResponsePort as i, ATOMIC_EXTRACTION_SKILL_HASH as in, serializeIntervalMetadata as it, readAtomicArrivalRetirementCandidateSet as j, runWithMemoryAudit as jt, closeAtomicArrivalRetirementTargets as k, currentMutationAttemptId as kt, runWithCanonicalStoreWriteMutex as l, relations as ln, stripEnvelopeMetadata as lt, DEFAULT_RETRIEVAL_CONFIG as m, attribute_dictionary_default as mn, SnoStationMemError as mt, remNeedsHost as n, resolveLlmRoute as nn, readMemorySourceOrderOrOldest as nt, readCandidates as o, modelReplyJsonCandidates as on, unresolvedMemoryDate as ot, MemoryRetriever as p, sessionZoneCarriedBy as pn, RetrievalError as pt, parseRemOperationType as q, parseInsightMetadata as qt, buildRemReplaceCandidateQueue as r, ATOMIC_EXTRACTION_SKILL as rn, parseSessionTimestamp as rt, runRemBatchJob as s, readModelReplyJson as sn, boundSectionContent as st, evaluateRemAutomaticTriggers as t, pickLlmRoutingConfig as tn, compareMemorySourceOrder as tt, selectRemUpdateRelationCandidates as u, calculateCalendarTime as un, normalizeAmbientLearningText as ut, buildTaskLifecycleCandidateSet as v, openSqliteDatabase as vn, parseAgentIdFromSessionKey$1 as vt, resolveTaskLifecycleEffectiveTime as w, forwardObserveLedgerUntilIdle as wn, classifyLlmFailure as wt, taskLifecycleCandidateSetVersion as x, memoryFileWrite as xn, createLlmClient as xt, findUniqueActiveTaskByDescription as y, openSqliteDatabaseReadonly as yn, LlmClientTerminalError as yt, MemoryStore as z, clampInt as zt };