@snoai/memory 0.0.0-stage → 1.0.0

package/dist/config-tSrvLXgV.js

@@ -0,0 +1,2577 @@
+import { createLogger } from "@snoai/utils/logger";
+import path, { dirname, join, resolve } from "node:path";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
+import { homedir, totalmem, userInfo } from "node:os";
+import { fileURLToPath } from "node:url";
+import { LRUCache } from "lru-cache";
+import { isLowercaseCanonicalUUIDv7 } from "@snoai/common-core";
+import { z } from "zod";
+import { CHUNKING_VERSION, DEFAULT_AGGREGATION_CONFIG, DEFAULT_CHUNK_CONFIG, HEAD_EXTRACT_MIN_CONTENT_TOKENS, HEAD_EXTRACT_OVERLAP_DROP_RATIO, HEAD_EXTRACT_TOKEN_BUDGET } from "@snoai/chunking";
+//#region ../embedder/dist/index.mjs
+/**
+* Shared embedding constants — single source of truth for all apps.
+* 1024-d is the ONLY supported dimension.
+*/
+const CONSTANTS_DIR = dirname(fileURLToPath(import.meta.url));
+/** Local ONNX model identifier (Hugging Face hub) */
+const LOCAL_EMBEDDING_MODEL = "tss-deposium/pplx-embed-v1-0.6b-onnx-int8-standard";
+/**
+* Pinned HuggingFace revision (commit SHA) for supply-chain integrity.
+* Update this when intentionally upgrading to a newer model version.
+*/
+const LOCAL_EMBEDDING_MODEL_REVISION = "a18fdffe7480e6ea5643acb7757142b33838817a";
+/** Default ONNX Runtime profile for constrained local agents. */
+const LOCAL_EMBEDDING_SESSION_OPTIONS_DEFAULT = {
+	graphOptimizationLevel: "extended",
+	enableMemPattern: false,
+	enableCpuMemArena: false
+};
+/**
+* Default local embedding model cache directory.
+* Absolute path anchored to the embedder package's own `.cache/models/` so it
+* resolves identically regardless of process CWD. Apps can override via
+* constructor config.
+*/
+const LOCAL_EMBEDDING_CACHE_DIR_DEFAULT = join(CONSTANTS_DIR, "..", ".cache", "models");
+/**
+* Local ONNX embedding provider — PPLX embed v1 0.6B INT8, 1024-d vectors.
+*
+* Self-contained: all params via constructor; no app-level config dependency.
+*/
+const log$1 = createLogger("embedder:local");
+let sharedExtractor;
+let sharedLoading;
+let sharedRefCount = 0;
+let sharedPipelineKey;
+function buildSessionOptions(options) {
+	const sessionOptions = {
+		graphOptimizationLevel: options.graphOptimizationLevel ?? LOCAL_EMBEDDING_SESSION_OPTIONS_DEFAULT.graphOptimizationLevel,
+		enableMemPattern: options.enableMemPattern ?? LOCAL_EMBEDDING_SESSION_OPTIONS_DEFAULT.enableMemPattern,
+		enableCpuMemArena: options.enableCpuMemArena ?? LOCAL_EMBEDDING_SESSION_OPTIONS_DEFAULT.enableCpuMemArena,
+		freeDimensionOverrides: { batch_size: 1 }
+	};
+	if (options.executionMode !== void 0) sessionOptions.executionMode = options.executionMode;
+	if (options.interOpNumThreads !== void 0) sessionOptions.interOpNumThreads = options.interOpNumThreads;
+	if (options.intraOpNumThreads !== void 0) sessionOptions.intraOpNumThreads = options.intraOpNumThreads;
+	return sessionOptions;
+}
+function buildPipelineKey(identity) {
+	return JSON.stringify({
+		cacheDir: identity.cacheDir,
+		modelId: identity.modelId,
+		revision: identity.revision,
+		dtype: identity.dtype,
+		sessionOptions: buildSessionOptions(identity.sessionOptions)
+	});
+}
+function isNumericTensorData(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return "length" in value && typeof value.length === "number";
+}
+function tensorDataToArray(data, length) {
+	if (!isNumericTensorData(data)) throw new Error("Local embedding returned non-array tensor data");
+	return typeof data.subarray === "function" ? Array.from(data.subarray(0, length)) : Array.from(data).slice(0, length);
+}
+var ModelNotFoundError = class extends Error {
+	constructor(modelId) {
+		super(`Local embedding model "${modelId}" not found in cacheDir. Download it via Hugging Face CLI or 'npm run model:pull'.`);
+		this.name = "ModelNotFoundError";
+	}
+};
+/** Thrown by `countTokens()` before the model (and its tokenizer) has loaded. */
+var ModelNotLoadedError = class extends Error {
+	constructor(modelId) {
+		super(`Local embedding model "${modelId}" is not loaded yet; await embed() or the embedder warmup before counting tokens.`);
+		this.name = "ModelNotLoadedError";
+	}
+};
+var LocalEmbedProvider = class LocalEmbedProvider {
+	_disposed = false;
+	cacheDir;
+	dtype;
+	modelId;
+	revision;
+	nativeDim;
+	outputDim;
+	pooling;
+	sessionOptions;
+	pipelineKey;
+	offline;
+	mirror;
+	/**
+	* Guard: transformers `env` is process-global — only one cacheDir is allowed per process.
+	* Intentionally never reset during normal operation; use `resetStaticState()` only in tests.
+	*/
+	static configuredCacheDir;
+	/** Reset static state — FOR TESTS ONLY. Not safe in production. */
+	static resetStaticState() {
+		LocalEmbedProvider.configuredCacheDir = void 0;
+		sharedExtractor = void 0;
+		sharedLoading = void 0;
+		sharedRefCount = 0;
+		sharedPipelineKey = void 0;
+	}
+	/** Output dimension exposed to consumers (after Matryoshka truncation, if any). */
+	get dimension() {
+		return this.outputDim;
+	}
+	constructor(config) {
+		this.cacheDir = resolve(config?.cacheDir ?? LOCAL_EMBEDDING_CACHE_DIR_DEFAULT);
+		this.dtype = config?.dtype ?? "q8";
+		this.modelId = config?.model ?? "tss-deposium/pplx-embed-v1-0.6b-onnx-int8-standard";
+		this.revision = config?.revision ?? (config?.model === void 0 ? "a18fdffe7480e6ea5643acb7757142b33838817a" : void 0);
+		this.nativeDim = config?.nativeDim ?? 1024;
+		this.outputDim = config?.outputDim ?? this.nativeDim;
+		if (this.outputDim > this.nativeDim) throw new Error(`outputDim (${this.outputDim}) cannot exceed nativeDim (${this.nativeDim}) — Matryoshka truncation only shrinks dimensions.`);
+		this.pooling = config?.pooling ?? "mean";
+		this.sessionOptions = config?.sessionOptions ?? {};
+		this.offline = config?.offline ?? false;
+		this.mirror = config?.mirror;
+		this.pipelineKey = buildPipelineKey({
+			cacheDir: this.cacheDir,
+			modelId: this.modelId,
+			revision: this.revision,
+			dtype: this.dtype,
+			sessionOptions: this.sessionOptions
+		});
+		sharedRefCount++;
+	}
+	async getExtractor() {
+		if (this._disposed) throw new Error("LocalEmbedProvider has been disposed");
+		this.assertCompatibleSharedPipeline();
+		if (sharedExtractor) return sharedExtractor;
+		if (sharedLoading) {
+			const extractor = await sharedLoading;
+			if (this._disposed) throw new Error("LocalEmbedProvider has been disposed");
+			if (!sharedExtractor) sharedExtractor = extractor;
+			return extractor;
+		}
+		sharedPipelineKey = this.pipelineKey;
+		sharedLoading = this.initPipeline();
+		try {
+			const extractor = await sharedLoading;
+			sharedExtractor = extractor;
+			if (this._disposed) throw new Error("LocalEmbedProvider has been disposed");
+			return extractor;
+		} finally {
+			sharedLoading = void 0;
+			if (!sharedExtractor && sharedRefCount === 0) sharedPipelineKey = void 0;
+		}
+	}
+	assertCompatibleSharedPipeline() {
+		if (sharedPipelineKey === void 0 || sharedPipelineKey === this.pipelineKey) return;
+		throw new Error("LocalEmbedProvider shared ONNX pipeline is already loaded with a different model, revision, dtype, cacheDir, or sessionOptions. Dispose all live providers before changing pipeline configuration.");
+	}
+	async initPipeline() {
+		if (LocalEmbedProvider.configuredCacheDir !== void 0 && LocalEmbedProvider.configuredCacheDir !== this.cacheDir) throw new Error(`transformers env is global; LocalEmbedProvider cacheDir must be consistent (existing: ${LocalEmbedProvider.configuredCacheDir}, requested: ${this.cacheDir})`);
+		LocalEmbedProvider.configuredCacheDir = this.cacheDir;
+		const { env, pipeline } = await import("@huggingface/transformers");
+		env.cacheDir = this.cacheDir;
+		env.allowRemoteModels = !this.offline;
+		env.localModelPath = this.cacheDir;
+		env.remotePathTemplate = `{model}/resolve/${this.revision ?? "main"}/`;
+		const hfEndpoint = this.mirror?.trim();
+		if (hfEndpoint) env.remoteHost = hfEndpoint.endsWith("/") ? hfEndpoint : `${hfEndpoint}/`;
+		log$1.info("loading ONNX model", {
+			model: this.modelId,
+			cacheDir: this.cacheDir,
+			dtype: this.dtype,
+			nativeDim: this.nativeDim,
+			outputDim: this.outputDim,
+			sessionOptions: buildSessionOptions(this.sessionOptions)
+		}, {
+			event_name: "embedder.local.provider.initpipeline",
+			file: "packages/embedder/src/local-provider.ts",
+			function: "initPipeline",
+			site_id: "embedder.local.provider.initpipeline.1"
+		});
+		const t0 = performance.now();
+		try {
+			const sessionOptions = buildSessionOptions(this.sessionOptions);
+			const extractor = await pipeline("feature-extraction", this.modelId, {
+				dtype: this.dtype,
+				device: "cpu",
+				session_options: sessionOptions
+			});
+			const durationMs = Math.round(performance.now() - t0);
+			log$1.info("ONNX model loaded", {
+				durationMs,
+				model: this.modelId
+			}, {
+				event_name: "embedder.local.provider.initpipeline",
+				file: "packages/embedder/src/local-provider.ts",
+				function: "initPipeline",
+				site_id: "embedder.local.provider.initpipeline.2"
+			});
+			return extractor;
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			if (msg.includes("no such file") || msg.includes("ENOENT") || msg.includes("not found") || msg.includes("Could not locate file")) {
+				log$1.error("ONNX model not found", {
+					cacheDir: this.cacheDir,
+					model: this.modelId
+				}, {
+					event_name: "embedder.local.provider.initpipeline",
+					file: "packages/embedder/src/local-provider.ts",
+					function: "initPipeline",
+					site_id: "embedder.local.provider.initpipeline.3"
+				});
+				throw new ModelNotFoundError(this.modelId);
+			}
+			log$1.error("ONNX model init failed", { error }, {
+				event_name: "embedder.local.provider.initpipeline",
+				file: "packages/embedder/src/local-provider.ts",
+				function: "initPipeline",
+				site_id: "embedder.local.provider.initpipeline.4"
+			});
+			throw error;
+		}
+	}
+	countTokens(text) {
+		if (this._disposed) throw new Error("LocalEmbedProvider has been disposed");
+		this.assertCompatibleSharedPipeline();
+		if (!sharedExtractor) throw new ModelNotLoadedError(this.modelId);
+		return sharedExtractor.tokenizer.encode(text, { add_special_tokens: false }).length;
+	}
+	async embed(text) {
+		const output = await (await this.getExtractor())(text, {
+			pooling: this.pooling,
+			normalize: true
+		});
+		const lastDimIndex = output.dims.length - 1;
+		if (lastDimIndex < 0) throw new Error("Local embedding returned empty tensor dims");
+		const dim = output.dims[lastDimIndex];
+		if (dim === void 0) throw new Error("Local embedding returned undefined dimension");
+		if (dim !== this.nativeDim) throw new Error(`Model "${this.modelId}" produced ${dim}-d native vectors, but provider was configured with nativeDim=${this.nativeDim}.`);
+		const native = tensorDataToArray(output.data, dim);
+		if (native.length !== this.nativeDim) throw new Error(`Expected ${this.nativeDim}-d native embedding, got ${native.length}-d`);
+		if (this.outputDim === this.nativeDim) return native;
+		return truncateAndRenormalize(native, this.outputDim);
+	}
+	async embedDocuments(texts) {
+		if (texts.length === 0) return [];
+		log$1.debug("batch local embedding", { count: texts.length }, {
+			event_name: "embedder.local.provider.embeddocuments",
+			file: "packages/embedder/src/local-provider.ts",
+			function: "embedDocuments",
+			site_id: "embedder.local.provider.embeddocuments.5"
+		});
+		const results = new Array(texts.length);
+		for (let i = 0; i < texts.length; i++) {
+			const text = texts[i];
+			if (text === void 0) throw new Error(`Missing text at batch index ${i}`);
+			results[i] = await this.embed(text);
+		}
+		return results;
+	}
+	async dispose() {
+		if (this._disposed) return;
+		log$1.debug("disposing local embedding provider", {}, {
+			event_name: "embedder.local.provider.dispose",
+			file: "packages/embedder/src/local-provider.ts",
+			function: "dispose",
+			site_id: "embedder.local.provider.dispose.6"
+		});
+		this._disposed = true;
+		sharedRefCount = Math.max(0, sharedRefCount - 1);
+		if (sharedRefCount > 0) return;
+		const pending = sharedLoading;
+		if (pending) {
+			const extractor = await pending.catch(() => void 0);
+			if (sharedRefCount > 0) {
+				if (extractor && !sharedExtractor) sharedExtractor = extractor;
+				return;
+			}
+			if (extractor && extractor !== sharedExtractor) await extractor.dispose();
+		}
+		if (sharedRefCount > 0) return;
+		if (sharedExtractor) {
+			await sharedExtractor.dispose();
+			sharedExtractor = void 0;
+		}
+		if (sharedLoading === void 0) sharedPipelineKey = void 0;
+	}
+	async warmup() {
+		await this.embed("warmup");
+	}
+};
+/**
+* Slice the leading `outputDim` floats and re-L2-normalize.
+*
+* Qwen3 embedding models are trained with Matryoshka representation learning,
+* so the head of a unit-length native vector remains a meaningful (but no
+* longer unit-length) embedding. Re-normalizing keeps cosine similarity
+* comparable across stored vectors of the same truncated dim.
+*/
+function truncateAndRenormalize(native, outputDim) {
+	if (outputDim <= 0 || outputDim > native.length) throw new Error(`truncateAndRenormalize: outputDim=${outputDim} out of range for native length ${native.length}`);
+	const head = native.slice(0, outputDim);
+	let normSq = 0;
+	for (let i = 0; i < outputDim; i++) {
+		const v = head[i] ?? 0;
+		normSq += v * v;
+	}
+	const norm = Math.sqrt(normSq);
+	if (norm === 0) return head;
+	for (let i = 0; i < outputDim; i++) head[i] = (head[i] ?? 0) / norm;
+	return head;
+}
+/**
+* LRU-cached embedding provider wrapper.
+*
+* Wraps any EmbeddingProvider with an LRU cache (TTL + max-size eviction).
+* Extracted from mem-claw's Embedder cache pattern,
+* upgraded to use the `lru-cache` package instead of a hand-rolled Map.
+*/
+/** Shared key prefix for single-text and document-batch cache entries. */
+const PASSAGE_PREFIX = "p:";
+var CachedEmbeddingProvider = class {
+	inner;
+	cache;
+	inflight = /* @__PURE__ */ new Map();
+	get dimension() {
+		return this.inner.dimension;
+	}
+	countTokens(text) {
+		return this.inner.countTokens(text);
+	}
+	constructor(provider, config) {
+		this.inner = provider;
+		this.cache = new LRUCache({
+			max: config?.maxSize ?? 256,
+			ttl: config?.ttlMs ?? 18e5
+		});
+	}
+	async getOrLoad(key, load) {
+		const cached = this.cache.get(key);
+		if (cached) return [...cached];
+		const pending = this.inflight.get(key);
+		if (pending) return [...await pending];
+		const created = (async () => {
+			const cloned = [...await load()];
+			this.cache.set(key, cloned);
+			return cloned;
+		})();
+		this.inflight.set(key, created);
+		try {
+			return [...await created];
+		} catch (error) {
+			if (this.inflight.get(key) === created) this.inflight.delete(key);
+			throw error;
+		} finally {
+			if (this.inflight.get(key) === created) this.inflight.delete(key);
+		}
+	}
+	async embed(text) {
+		const key = `${PASSAGE_PREFIX}${text}`;
+		return this.getOrLoad(key, async () => this.inner.embed(text));
+	}
+	async embedDocuments(texts) {
+		if (texts.length === 0) return [];
+		const results = new Array(texts.length);
+		const batchKeys = [];
+		const batchTexts = [];
+		const batchIndicesByKey = /* @__PURE__ */ new Map();
+		for (let i = 0; i < texts.length; i++) {
+			const text = texts[i];
+			if (text === void 0) continue;
+			const key = `${PASSAGE_PREFIX}${text}`;
+			const cached = this.cache.get(key);
+			if (cached) {
+				results[i] = Promise.resolve([...cached]);
+				continue;
+			}
+			const pending = this.inflight.get(key);
+			if (pending) {
+				results[i] = pending.then((embedding) => [...embedding]);
+				continue;
+			}
+			const existingBatch = batchIndicesByKey.get(key);
+			if (existingBatch) {
+				existingBatch.push(i);
+				continue;
+			}
+			batchKeys.push(key);
+			batchTexts.push(text);
+			batchIndicesByKey.set(key, [i]);
+		}
+		if (batchTexts.length > 0) {
+			const batchPromises = /* @__PURE__ */ new Map();
+			const freshEmbeddingsPromise = this.inner.embedDocuments(batchTexts).then((freshEmbeddings) => {
+				if (freshEmbeddings.length !== batchTexts.length) throw new Error(`inner.embedDocuments returned ${freshEmbeddings.length} results for ${batchTexts.length} inputs`);
+				return freshEmbeddings.map((embedding) => [...embedding]);
+			});
+			for (let j = 0; j < batchKeys.length; j++) {
+				const key = batchKeys[j];
+				if (key === void 0) continue;
+				const indices = batchIndicesByKey.get(key);
+				if (indices === void 0) continue;
+				const keyPromise = freshEmbeddingsPromise.then((freshEmbeddings) => {
+					const embedding = freshEmbeddings[j];
+					if (embedding === void 0) throw new Error(`Missing fresh embedding at batch index ${j}`);
+					this.cache.set(key, embedding);
+					return embedding;
+				});
+				batchPromises.set(key, keyPromise);
+				this.inflight.set(key, keyPromise);
+				for (const idx of indices) results[idx] = keyPromise.then((embedding) => [...embedding]);
+			}
+			const clearInflight = () => {
+				for (const [key, keyPromise] of batchPromises) if (this.inflight.get(key) === keyPromise) this.inflight.delete(key);
+			};
+			freshEmbeddingsPromise.then(clearInflight, clearInflight);
+		}
+		return Promise.all(results.map((result, index) => {
+			if (result === void 0) throw new Error(`Missing embedding at index ${index}`);
+			return result;
+		}));
+	}
+	async dispose() {
+		this.cache.clear();
+		this.inflight.clear();
+		if ("dispose" in this.inner && typeof this.inner.dispose === "function") await this.inner.dispose();
+	}
+	/** Clear the cache without disposing the inner provider */
+	clear() {
+		this.cache.clear();
+		this.inflight.clear();
+	}
+	/** Current cache size */
+	get size() {
+		return this.cache.size;
+	}
+};
+/**
+* model-download.ts — Shared ONNX model download utility.
+*
+* Idempotent: skips download when a .download-complete marker and .onnx files
+* exist in cacheDir. Interrupted downloads (no marker) trigger re-download.
+* User-facing progress goes to stderr (not stdout) so it doesn't interfere
+* with structured log output or piped commands.
+*/
+const log$2 = createLogger("embedder:model-download");
+/** Marker file written after a successful download to distinguish complete vs partial cache. */
+const DOWNLOAD_COMPLETE_MARKER = ".download-complete";
+/** Lock file for cross-process download serialization (O_EXCL based). */
+const DOWNLOAD_LOCK_FILE = ".download-lock";
+/** Max time (ms) to wait for another process's download before giving up. */
+const LOCK_WAIT_TIMEOUT_MS = 6e5;
+/** Poll interval (ms) when waiting for a competing download to finish. */
+const LOCK_POLL_INTERVAL_MS = 2e3;
+/** Stale lock threshold (ms) — locks older than this are assumed abandoned. */
+const LOCK_STALE_MS = 9e5;
+/** Lock heartbeat interval (ms) while owning the download lock. */
+const LOCK_HEARTBEAT_INTERVAL_MS = 5e3;
+function parseDownloadMarker(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		const model = parsed.model;
+		const revision = parsed.revision;
+		const dtype = parsed.dtype;
+		const completedAt = parsed.completedAt;
+		if (typeof model !== "string" || typeof revision !== "string" || typeof dtype !== "string" || typeof completedAt !== "string") return null;
+		return {
+			model,
+			revision,
+			dtype,
+			completedAt
+		};
+	} catch {
+		return null;
+	}
+}
+const DTYPE_SIZES = {
+	q4: "~400MB",
+	q8: "~639MB",
+	fp16: "~1.2GB",
+	fp32: "~2.4GB"
+};
+function getSystemRamGB() {
+	return Math.round(totalmem() / 1073741824);
+}
+/**
+* Check if a valid model download exists in cacheDir.
+*
+* When `expectedRevision` and/or `expectedDtype` are provided, the marker
+* metadata is validated against them — a mismatch (e.g. after model upgrade)
+* returns false so the caller re-downloads. Without these params the check
+* is structural only (marker + .onnx files), which is appropriate for
+* lock-wait polling where dtype/revision aren't available.
+*/
+function isModelCached(cacheDir, expectedRevision, expectedDtype) {
+	try {
+		if (!existsSync(cacheDir)) return false;
+		const markerPath = join(cacheDir, DOWNLOAD_COMPLETE_MARKER);
+		if (!existsSync(markerPath)) return false;
+		const onnxDir = join(cacheDir, LOCAL_EMBEDDING_MODEL, "onnx");
+		if (!existsSync(onnxDir) || !readdirSync(onnxDir).some((e) => e.endsWith(".onnx"))) return false;
+		if (expectedRevision !== void 0 || expectedDtype !== void 0) {
+			const marker = parseDownloadMarker(readFileSync(markerPath, "utf8"));
+			if (!marker) {
+				log$2.warn("download marker is corrupt, re-download needed", { cacheDir }, {
+					event_name: "embedder.model.download.ismodelcached",
+					file: "packages/embedder/src/model-download.ts",
+					function: "isModelCached",
+					site_id: "embedder.model.download.ismodelcached.1"
+				});
+				return false;
+			}
+			if (expectedRevision !== void 0 && marker.revision !== expectedRevision) {
+				log$2.info("cached model revision mismatch, re-download needed", {
+					cached: String(marker.revision),
+					expected: expectedRevision
+				}, {
+					event_name: "embedder.model.download.ismodelcached",
+					file: "packages/embedder/src/model-download.ts",
+					function: "isModelCached",
+					site_id: "embedder.model.download.ismodelcached.2"
+				});
+				return false;
+			}
+			if (expectedDtype !== void 0 && marker.dtype !== expectedDtype) {
+				log$2.info("cached model dtype mismatch, re-download needed", {
+					cached: String(marker.dtype),
+					expected: expectedDtype
+				}, {
+					event_name: "embedder.model.download.ismodelcached",
+					file: "packages/embedder/src/model-download.ts",
+					function: "isModelCached",
+					site_id: "embedder.model.download.ismodelcached.3"
+				});
+				return false;
+			}
+		}
+		return true;
+	} catch (error) {
+		log$2.warn("failed to inspect model cache directory", {
+			cacheDir,
+			error
+		}, {
+			event_name: "embedder.model.download.ismodelcached",
+			file: "packages/embedder/src/model-download.ts",
+			function: "isModelCached",
+			site_id: "embedder.model.download.ismodelcached.4"
+		});
+		return false;
+	}
+}
+function getDirSizeMB(dirPath) {
+	let total = 0;
+	try {
+		const entries = readdirSync(dirPath, { recursive: true });
+		for (const entry of entries) {
+			if (typeof entry !== "string") continue;
+			const fullPath = join(dirPath, entry);
+			try {
+				const stat = statSync(fullPath);
+				if (stat.isFile()) total += stat.size;
+			} catch {}
+		}
+	} catch (error) {
+		log$2.warn("failed to read directory for size calculation", {
+			dirPath,
+			error
+		}, {
+			event_name: "embedder.model.download.getdirsizemb",
+			file: "packages/embedder/src/model-download.ts",
+			function: "getDirSizeMB",
+			site_id: "embedder.model.download.getdirsizemb.5"
+		});
+	}
+	return Math.round(total / 1048576);
+}
+function getDtypeDisplaySize(dtype) {
+	return DTYPE_SIZES[dtype] ?? "unknown size";
+}
+/**
+* Acquire an exclusive download lock using O_EXCL (atomic create-if-not-exists).
+* Returns true if lock acquired, false if another process holds it.
+*/
+function tryAcquireLock(cacheDir) {
+	const lockPath = join(cacheDir, DOWNLOAD_LOCK_FILE);
+	try {
+		mkdirSync(cacheDir, { recursive: true });
+		const fd = openSync(lockPath, "wx");
+		writeFileSync(fd, `${process.pid}\n${Date.now()}\n`);
+		closeSync(fd);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "EEXIST") return false;
+		throw error;
+	}
+}
+function releaseLock(cacheDir) {
+	try {
+		unlinkSync(join(cacheDir, DOWNLOAD_LOCK_FILE));
+	} catch {}
+}
+function heartbeatLock(cacheDir) {
+	const lockPath = join(cacheDir, DOWNLOAD_LOCK_FILE);
+	try {
+		const now = /* @__PURE__ */ new Date();
+		utimesSync(lockPath, now, now);
+	} catch {}
+}
+function isLockStale(cacheDir) {
+	const lockPath = join(cacheDir, DOWNLOAD_LOCK_FILE);
+	try {
+		const stat = statSync(lockPath);
+		if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) return true;
+		const pid = Number.parseInt(readFileSync(lockPath, "utf8").split("\n")[0] ?? "", 10);
+		if (!Number.isInteger(pid) || pid <= 0) return false;
+		try {
+			process.kill(pid, 0);
+			return false;
+		} catch (error) {
+			return error instanceof Error && "code" in error && error.code === "ESRCH";
+		}
+	} catch {
+		return true;
+	}
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Wait for an existing download lock to be released (another process finishing).
+* If the lock is stale (abandoned), break it and return so the caller can retry.
+*
+* `expectedRevision` / `expectedDtype` are forwarded to `isModelCached` so a
+* concurrent revision/dtype upgrade is not satisfied by a stale matching-shape
+* cache from the previous version. Without them, two processes upgrading the
+* same cacheDir can both return "finished" on the old artifacts.
+*/
+async function waitForLock(cacheDir, expectedRevision, expectedDtype) {
+	const lockPath = join(cacheDir, DOWNLOAD_LOCK_FILE);
+	const deadline = Date.now() + LOCK_WAIT_TIMEOUT_MS;
+	log$2.info("another process is downloading the model, waiting...", { cacheDir }, {
+		event_name: "embedder.model.download.waitforlock",
+		file: "packages/embedder/src/model-download.ts",
+		function: "waitForLock",
+		site_id: "embedder.model.download.waitforlock.6"
+	});
+	process.stderr.write("  Waiting for another download to finish...\n");
+	while (Date.now() < deadline) {
+		if (!existsSync(lockPath)) return;
+		if (isModelCached(cacheDir, expectedRevision, expectedDtype)) return;
+		if (isLockStale(cacheDir)) {
+			log$2.warn("breaking stale download lock", { cacheDir }, {
+				event_name: "embedder.model.download.waitforlock",
+				file: "packages/embedder/src/model-download.ts",
+				function: "waitForLock",
+				site_id: "embedder.model.download.waitforlock.7"
+			});
+			releaseLock(cacheDir);
+			return;
+		}
+		await sleep(LOCK_POLL_INTERVAL_MS);
+	}
+	throw new Error(`Timed out (${LOCK_WAIT_TIMEOUT_MS / 1e3}s) waiting for model download lock. Another process may still be downloading. Check ${join(cacheDir, DOWNLOAD_LOCK_FILE)}`);
+}
+/**
+* Ensure the local ONNX embedding model is downloaded. Idempotent.
+*
+* - If .download-complete marker + .onnx files exist in cacheDir, logs "already cached" and returns.
+* - Otherwise, downloads with progress output to stderr.
+* - Resets `env.allowRemoteModels = false` after download to prevent
+*   surprise network calls during inference.
+*/
+async function ensureModelDownloaded(opts) {
+	const cacheDir = opts?.cacheDir ?? LOCAL_EMBEDDING_CACHE_DIR_DEFAULT;
+	const ramGB = getSystemRamGB();
+	const dtype = opts?.dtype ?? "q8";
+	if (isModelCached(cacheDir, "a18fdffe7480e6ea5643acb7757142b33838817a", dtype)) {
+		const sizeMB = getDirSizeMB(cacheDir);
+		log$2.info("local embedding model already cached", {
+			sizeMB,
+			cacheDir
+		}, {
+			event_name: "embedder.model.download.ensuremodeldownloaded",
+			file: "packages/embedder/src/model-download.ts",
+			function: "ensureModelDownloaded",
+			site_id: "embedder.model.download.ensuremodeldownloaded.8"
+		});
+		return;
+	}
+	if (opts?.offline) return;
+	const lockWasPresent = existsSync(join(cacheDir, DOWNLOAD_LOCK_FILE));
+	if (!tryAcquireLock(cacheDir)) {
+		await waitForLock(cacheDir, LOCAL_EMBEDDING_MODEL_REVISION, dtype);
+		if (isModelCached(cacheDir, "a18fdffe7480e6ea5643acb7757142b33838817a", dtype)) {
+			const sizeMB = getDirSizeMB(cacheDir);
+			log$2.info("local embedding model already cached (downloaded by another process)", {
+				sizeMB,
+				cacheDir
+			}, {
+				event_name: "embedder.model.download.ensuremodeldownloaded",
+				file: "packages/embedder/src/model-download.ts",
+				function: "ensureModelDownloaded",
+				site_id: "embedder.model.download.ensuremodeldownloaded.9"
+			});
+			return;
+		}
+		if (!tryAcquireLock(cacheDir)) throw new Error(`Failed to acquire model download lock after waiting. Another process may still be downloading. Check ${join(cacheDir, DOWNLOAD_LOCK_FILE)}`);
+	}
+	const modelDir = join(cacheDir, LOCAL_EMBEDDING_MODEL);
+	let completed = false;
+	let startedEmpty = false;
+	const lockHeartbeat = setInterval(() => heartbeatLock(cacheDir), LOCK_HEARTBEAT_INTERVAL_MS);
+	try {
+		heartbeatLock(cacheDir);
+		if (lockWasPresent) {
+			rmSync(join(cacheDir, DOWNLOAD_COMPLETE_MARKER), { force: true });
+			rmSync(modelDir, {
+				recursive: true,
+				force: true
+			});
+		} else if (!existsSync(join(cacheDir, DOWNLOAD_COMPLETE_MARKER)) && existsSync(modelDir) && existsSync(join(modelDir, "onnx")) && readdirSync(join(modelDir, "onnx")).some((e) => e.endsWith(".onnx"))) {
+			writeFileSync(join(cacheDir, DOWNLOAD_COMPLETE_MARKER), JSON.stringify({
+				model: LOCAL_EMBEDDING_MODEL,
+				revision: LOCAL_EMBEDDING_MODEL_REVISION,
+				dtype,
+				completedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}));
+			completed = true;
+			return;
+		}
+		startedEmpty = !existsSync(modelDir);
+		const banner = [
+			"",
+			"Downloading local embedding model (first run only)",
+			`${"─".repeat(52)}`,
+			`  Model:     ${LOCAL_EMBEDDING_MODEL}`,
+			`  Revision:  ${LOCAL_EMBEDDING_MODEL_REVISION.slice(0, 12)}`,
+			`  Dtype:     ${dtype} (${getDtypeDisplaySize(dtype)})`,
+			`  RAM:       ${ramGB}GB`,
+			`  Cache dir: ${cacheDir}`,
+			"",
+			"  This may take a few minutes on the first run...",
+			""
+		];
+		process.stderr.write(`${banner.join("\n")}\n`);
+		log$2.info("starting model download", {
+			model: LOCAL_EMBEDDING_MODEL,
+			revision: LOCAL_EMBEDDING_MODEL_REVISION,
+			dtype,
+			cacheDir
+		}, {
+			event_name: "embedder.model.download.ensuremodeldownloaded",
+			file: "packages/embedder/src/model-download.ts",
+			function: "ensureModelDownloaded",
+			site_id: "embedder.model.download.ensuremodeldownloaded.10"
+		});
+		const { env, pipeline } = await import("@huggingface/transformers");
+		const prevCacheDir = env.cacheDir;
+		const prevAllowRemote = env.allowRemoteModels;
+		const prevLocalModelPath = env.localModelPath;
+		const prevRemoteHost = env.remoteHost;
+		const prevRemotePathTemplate = env.remotePathTemplate;
+		env.cacheDir = cacheDir;
+		env.allowRemoteModels = true;
+		env.localModelPath = cacheDir;
+		env.remotePathTemplate = `{model}/resolve/${LOCAL_EMBEDDING_MODEL_REVISION}/`;
+		if (opts?.mirror) env.remoteHost = opts.mirror.endsWith("/") ? opts.mirror : `${opts.mirror}/`;
+		let lastProgress = 0;
+		const startTime = performance.now();
+		try {
+			await pipeline("feature-extraction", LOCAL_EMBEDDING_MODEL, {
+				dtype,
+				device: "cpu",
+				progress_callback: (progress) => {
+					if (progress.status === "progress" && typeof progress.progress === "number") {
+						const pct = Math.round(progress.progress);
+						if (pct >= lastProgress + 10) {
+							lastProgress = pct;
+							process.stderr.write(`  ${pct}% — ${progress.file ?? ""}\n`);
+						}
+					} else if (progress.status === "done" && progress.file) process.stderr.write(`  done ${progress.file}\n`);
+				}
+			});
+		} finally {
+			env.cacheDir = prevCacheDir;
+			env.allowRemoteModels = prevAllowRemote;
+			env.localModelPath = prevLocalModelPath;
+			env.remoteHost = prevRemoteHost;
+			env.remotePathTemplate = prevRemotePathTemplate;
+		}
+		writeFileSync(join(cacheDir, DOWNLOAD_COMPLETE_MARKER), JSON.stringify({
+			model: LOCAL_EMBEDDING_MODEL,
+			revision: LOCAL_EMBEDDING_MODEL_REVISION,
+			dtype,
+			completedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}));
+		completed = true;
+		const elapsedSec = Math.round((performance.now() - startTime) / 1e3);
+		const finalSizeMB = getDirSizeMB(cacheDir);
+		const summary = [
+			"",
+			"  Download complete!",
+			`  Size: ${finalSizeMB}MB | Time: ${elapsedSec}s`,
+			`  Location: ${cacheDir}`,
+			""
+		];
+		process.stderr.write(`${summary.join("\n")}\n`);
+		log$2.info("model download complete", {
+			model: LOCAL_EMBEDDING_MODEL,
+			revision: LOCAL_EMBEDDING_MODEL_REVISION,
+			dtype,
+			sizeMB: finalSizeMB,
+			elapsedSec,
+			cacheDir
+		}, {
+			event_name: "embedder.model.download.ensuremodeldownloaded",
+			file: "packages/embedder/src/model-download.ts",
+			function: "ensureModelDownloaded",
+			site_id: "embedder.model.download.ensuremodeldownloaded.11"
+		});
+	} finally {
+		clearInterval(lockHeartbeat);
+		if (!completed && startedEmpty) rmSync(modelDir, {
+			recursive: true,
+			force: true
+		});
+		releaseLock(cacheDir);
+	}
+}
+//#endregion
+//#region config/index.ts
+/**
+* Sno Station Memory centralized configuration.
+* Shared tunable constants for every memory skin.
+* Organized by domain: Scoring → Retrieval → Storage → Backup → Cache → Session → Capture → Reflection
+*/
+/** Maximum wait for sidecar requests and resource cleanup during shutdown. */
+const MEMORY_SHUTDOWN_TIMEOUT_MS = 5e3;
+/** Default importance score for new memories (0.0–1.0) */
+const DEFAULT_IMPORTANCE = .7;
+/** Default scope for memories without explicit scope */
+const DEFAULT_SCOPE = "global";
+/** Default embedding vector dimension (Voyage AI 1024-d) */
+const VECTOR_DIMENSION_DEFAULT = 1024;
+/** Production sno.ai host origin used by @snoai/observability. */
+const SNO_OBSERVE_DEFAULT_BASE_URL = "https://www.sno.ai";
+/** Default observability agent id for OpenClaw plugin emits. */
+const SNO_OBSERVE_DEFAULT_AGENT_ID = "openclaw";
+/** Bounded lifecycle observe flush — enough headroom for the SDK to complete one HTTP POST batch. */
+const SNO_OBSERVE_FLUSH_TIMEOUT_MS = 8e3;
+/** Default and minimum character-estimated token budgets for one recall result. */
+const DEFAULT_RECALL_TOKEN_BUDGET = 7e3;
+const MIN_RECALL_TOKEN_BUDGET = 5e3;
+/** Weight for vector (semantic) branch in hybrid score fusion */
+const DEFAULT_VECTOR_WEIGHT = .7;
+/** Weight for BM25 (keyword) branch in hybrid score fusion */
+const DEFAULT_BM25_WEIGHT = .3;
+/**
+* Hard ceiling for candidate pool expansion. Also the retrieval limit `memory_recall` asks for,
+* so it bounds how much of a live store one answer can see. Raised 100 → 512 on 2026-09-06 (owner
+* order): atomic rows are small and many, and at 100 a 159-row live store served 76 rows per
+* question, cutting live to-dos the question asked for; at 512 the whole store came back for
+* 3,476 tokens, half the recall token budget. Raised again 512 -> 2048 on 2026-09-15: the pool is
+* `max(candidatePoolSize, limit * 2)` clamped here, so at 512 a caller asking for more than 256
+* memories silently got fewer, and the ceiling — not the ranking — decided what the model saw.
+*/
+const MAX_CANDIDATE_POOL_SIZE = 2048;
+/**
+* Measurement-only overrides for the block 210 retrieval-breadth experiment.
+*
+* Both are OFF unless the named environment variable is set, and neither is
+* reachable from the plugin configuration schema, so a deployed plugin cannot
+* turn them on: the experiment harness sets them on the process it starts and
+* nothing else does. They exist because the runtime and the schema both stop
+* the candidate pool at `MAX_CANDIDATE_POOL_SIZE`, which makes the pool-200
+* cell impossible to run at all without one enabling edit (PRD 210 DEC-1).
+*
+* Read at call time, not at import time, so a harness that sets the variable
+* after this module loads still gets the value it asked for.
+*/
+function experimentCandidatePoolOverride() {
+	const raw = process.env.MEM_CLAW_EXPERIMENT_CANDIDATE_POOL_SIZE?.trim();
+	if (!raw) return void 0;
+	const parsed = Number(raw);
+	if (!Number.isSafeInteger(parsed) || parsed < 1) return void 0;
+	return parsed;
+}
+/** True only while the block 210 experiment harness has asked for MMR off. */
+function experimentMmrDisabled() {
+	return process.env.MEM_CLAW_EXPERIMENT_DISABLE_MMR?.trim() === "1";
+}
+/**
+* Token budget for the aggregation payload ONE consumer receives.
+*
+* Derived, and every number is a measurement. The answering engine's context is 64K tokens (owner,
+* 2026-08-14, raised from 32K with the Qwen 3.8 rollout); half is reserved for the question, the
+* surrounding prompt and the answer, leaving 32K for recalled evidence. Measured with
+* `dev-scripts/census-aggregation-payload.mts` against the largest real store
+* (`academic_researcher_weekly`, 138 active profile/episodic rows): the ENTIRE population renders in
+* 43,699 characters ~= 10,925 tokens, a sixth of the context. A complete aggregation is therefore
+* the ordinary case on real data, not an aspiration.
+*
+* The HALF is the load-bearing part, not the literal number. When the context moved to 64K this
+* constant did not move with it for one commit, and a budget that stays put while its derivation
+* doubles silently becomes a quarter of the context — a tightening nobody decided and nobody would
+* find. That is the same shape as defect 2 below. If the context changes again, this changes.
+*
+* Known trade, stated rather than discovered later: widening this window is what raised aggregation
+* from 0.045 to 0.744 on 2026-08-13, and it is also what dropped FAA 0.647 -> 0.600 in the same
+* run, because retired rows the old ceiling had hidden came back into view. The answer to that is
+* REM removing them (PRD 30/40), never a smaller recall window — shrinking this to protect FAA
+* re-severs the counting path, which is the defect this constant exists to record.
+*
+* This replaces three ceilings that stacked on one path and severed it. Measured on the full
+* benchmark run of 2026-08-13: 30 counting questions scored 0.045 mean with 28 of them exactly
+* 0.000, while the same personas' other 60 questions scored 0.748. The model was not wrong — asked
+* for a week of steps it answered "14,392 steps (recorded on June 7). No other step data is logged
+* for the rest of the week", because 8 rows of 138 reached it. A model cannot total rows it was
+* never shown. The three were:
+*
+*   1. `MAX_AGGREGATION_OUTPUT_ROWS = 8` — no derivation anywhere; 5.8% of a population handed to a
+*      question whose entire job is to total that population.
+*   2. `MAX_AGGREGATION_TOOL_RESULT_CHARS = 16_384` — a unit error. 16,384 was the OLD 16K context
+*      in TOKENS, applied as a CHARACTER count, binding 3-4x tighter than it read.
+*   3. Charging each consumer for the other's copy: the budget measured `JSON.stringify(result)`,
+*      which carries every row twice — once rendered, once in `memories` — while the OpenClaw host
+*      reads only the rendered text and the eval reads only `memories`.
+*
+* So this budget is counted in tokens, against the larger of the two consumer views, never a sum.
+*/
+const MAX_AGGREGATION_RESULT_TOKENS = 32768;
+/** Additive recency boost magnitude */
+const RECENCY_WEIGHT = .1;
+/** Maximum allowed recency weight */
+const RECENCY_WEIGHT_MAX = .5;
+/** Base multiplier for importance weighting (score * (base + importance * base)) */
+const IMPORTANCE_WEIGHT_BASE = .7;
+/** Minimum time decay multiplier (floor for very old entries) */
+const TIME_DECAY_FLOOR = .6;
+/**
+* Relevance vs diversity tradeoff for MMR (0.7 = 70% relevance, 30% diversity).
+* `applyMmrDiversity` normalizes the relevance term to [0,1] (batch-max) before
+* applying this weight — without that normalization, the shrinker chain above
+* compresses relevance so far below the [0,1] cosine-similarity diversity term
+* that this ratio was moot (diversity always won). Fixed 2026-07-05.
+*/
+const MMR_LAMBDA = .7;
+/** Weight for fusion score in rerank blend */
+const RERANK_BLEND_VECTOR = .3;
+/** Weight for cross-encoder score in rerank blend */
+const RERANK_BLEND_CROSS = .7;
+/** Fusion-score weight in local cosine-blend rerank */
+const LIGHTWEIGHT_FUSION_WEIGHT = .7;
+/** Cosine-similarity weight in local cosine-blend rerank */
+const LIGHTWEIGHT_COSINE_WEIGHT = .3;
+/** Default rerank model identifier */
+const DEFAULT_RERANK_MODEL = "rerank-2";
+/** Default timeout for rerank API calls in milliseconds */
+const DEFAULT_RERANK_TIMEOUT_MS = 15e3;
+/**
+* Maximum allowed list query page size; also caps each search branch
+* (`memory-store-search-api.ts` clamps both the semantic and the keyword branch to it), so it
+* stays >= the pool ceiling. Derived, not written: left at a literal 512 when the pool ceiling
+* went 512 -> 2048 on 2026-09-15, every branch silently returned at most 512 candidates while
+* retrieval asked for up to 2048, and the ceiling decided what ranking never saw.
+*/
+const MAX_LIST_LIMIT = MAX_CANDIDATE_POOL_SIZE;
+const MAX_RECALLED_TODO_TOKENS = 1e3;
+/**
+* Ceiling for chunk-level fetch budgets (semantic/keyword chunk search).
+* Deliberately independent of MAX_LIST_LIMIT: memory-level wrappers overfetch
+* chunks (limit * 8) so one high-recall parent cannot collapse parent diversity.
+*/
+const MAX_CHUNK_FETCH_LIMIT = 4096;
+/** Minimum score threshold for forget-query matches */
+const FORGET_QUERY_MIN_SCORE = .8;
+/**
+* Minimum age of the newest backup before another is taken (1 day). A backup is a full copy of
+* the store, so an hourly cadence cost a 1.7 GB store 40 GB of disk a day.
+*/
+const BACKUP_INTERVAL_MS = 864e5;
+/**
+* Share of the backup volume that must stay free. Before a backup is written the oldest backups are
+* deleted until the copy fits above this floor, and again afterwards if the volume is still under
+* it; the newest backup is always kept, and when even that is not enough the backup is skipped.
+*/
+const BACKUP_MIN_FREE_DISK_RATIO = .1;
+/** How often the maintenance timer wakes to see which jobs are due (1 hour). */
+const MAINTENANCE_TICK_MS = 36e5;
+/** Full-page integrity sweep (1 hour). */
+const INTEGRITY_CHECK_INTERVAL_MS = 36e5;
+/** Usage-telemetry outbox drain and quarantine cleanup (1 hour). */
+const USAGE_OUTBOX_INTERVAL_MS = 36e5;
+/** Pruning of expired recall/inject usage events (1 hour). */
+const USAGE_EVENT_RETENTION_INTERVAL_MS = 36e5;
+/** Full-text index segment merge (1 hour). */
+const FTS_MERGE_INTERVAL_MS = 36e5;
+/** Query-planner statistics refresh (1 hour). */
+const PLANNER_STATISTICS_INTERVAL_MS = 36e5;
+/**
+* How often the automatic REM trigger is evaluated (1 hour). Evaluating is only a check: REM
+* itself runs on its own daily schedule and volume rule in src/sidecar/rem-trigger.ts.
+*/
+const REM_TRIGGER_CHECK_INTERVAL_MS = 36e5;
+/** Embedder LRU cache TTL in milliseconds (30 minutes) */
+const CACHE_TTL_MS = 18e5;
+/** Transcript budget shared by an atomic window and its preceding context. */
+const ATOMIC_EXTRACTION_MAX_INPUT_TOKENS = 4096;
+const ATOMIC_ENRICHMENT_OUTPUT_TOKEN_BUDGET = 1400;
+/**
+* Output cap of one capture call. The capture reply lists every claim and then every fact with
+* its quote, roughly 70 tokens per fact; at 4,096 a 35-turn session replayed as one turn hit the
+* cap and lost the whole window (43 of 272 LoCoMo sessions, measured 2026-09-13). A window is
+* split by turns when a reply truncates, so a single long turn (a pasted document, a replayed
+* session) has only this cap between it and total loss. Sized from the budget, not the failure:
+* the prompt (skill, calendar reference, response schema, dictionaries) is about 10K tokens, the
+* transcript at most ATOMIC_EXTRACTION_MAX_INPUT_TOKENS, and the model serves a 64K context, so
+* 16,384 keeps the whole call near 30K; the longest LoCoMo session (40 messages, ~100 facts)
+* needs about 10K, which 8,192 only just covered.
+*/
+const ATOMIC_CAPTURE_OUTPUT_TOKEN_BUDGET = 16384;
+/**
+* Wall time one capture call is given. The generic client timeout is what an installation sets
+* for short judgments (30s by default, 60s on the LoCoMo VM) and does not know this call's output
+* budget, so raising the budget silently made the call unfinishable: measured 2026-09-20, four
+* sessions produced `LlmClientTerminalError category=timeout` at 60s after 105-130s of work and
+* stored nothing. Sized from the budget at the extraction model's measured ~60 output tokens per
+* second, with the same headroom the budget carries.
+*/
+const ATOMIC_CAPTURE_TIMEOUT_MS = 3e5;
+/** Maximum character length of auto-recall query before truncation */
+const DEFAULT_AUTO_RECALL_MAX_QUERY_LENGTH = 2e3;
+/** Maximum input characters for reflection prompt */
+const DEFAULT_REFLECTION_MAX_INPUT_CHARS = 24e3;
+/** Timeout for individual reflection LLM calls in milliseconds */
+const DEFAULT_REFLECTION_TIMEOUT_MS = 2e4;
+/** Session TTL in reflection tracking map (30 minutes) */
+const DEFAULT_REFLECTION_SESSION_TTL_MS = 18e5;
+/** Maximum chars scanned for error signals in conversation */
+const DEFAULT_REFLECTION_ERROR_SCAN_MAX_CHARS = 8e3;
+/** Cache TTL for loaded reflection slices in milliseconds */
+const REFLECTION_SLICE_CACHE_TTL_MS = 15e3;
+const RETRIEVAL_STORAGE_CHUNK_PROFILE = {
+	minTokens: 256,
+	targetTokens: 384,
+	maxTokens: 448,
+	overlapTokens: 32
+};
+/** Minimum tokens per chunk before merge (mirrors RETRIEVAL_STORAGE_CHUNK_PROFILE). */
+const CHUNK_MIN_TOKENS = RETRIEVAL_STORAGE_CHUNK_PROFILE.minTokens;
+/** Target tokens per chunk (mirrors RETRIEVAL_STORAGE_CHUNK_PROFILE). */
+const CHUNK_TARGET_TOKENS = RETRIEVAL_STORAGE_CHUNK_PROFILE.targetTokens;
+/** Max tokens per chunk before split (mirrors RETRIEVAL_STORAGE_CHUNK_PROFILE). */
+const CHUNK_MAX_TOKENS = RETRIEVAL_STORAGE_CHUNK_PROFILE.maxTokens;
+/** Overlap tokens between adjacent chunks (mirrors RETRIEVAL_STORAGE_CHUNK_PROFILE). */
+const CHUNK_OVERLAP_TOKENS = RETRIEVAL_STORAGE_CHUNK_PROFILE.overlapTokens;
+/** Tokenizer mode used by the chunker (mirrors DEFAULT_CHUNK_CONFIG.tokenizerMode). */
+const CHUNK_TOKENIZER_MODE = DEFAULT_CHUNK_CONFIG.tokenizerMode;
+/**
+* Diagnostic threshold for intra-memory chunk cosine similarity (PRD §8.1).
+* Pairs above this score are flagged as redundant during eval / introspection.
+*/
+const INTRA_MEMORY_COSINE_THRESHOLD = .92;
+/** Alias for VECTOR_DIMENSION_DEFAULT — the embedder output dimension. */
+const EMBEDDER_DIM = VECTOR_DIMENSION_DEFAULT;
+/** Default embedder provider id stamped into chunk provenance. */
+const EMBEDDER_PROVIDER_DEFAULT = "local-onnx";
+/**
+* Default embedder model id stamped into chunk provenance.
+*
+* Codex 2026-04-30 (batch-C C1): the previous hard-coded
+* `qwen3-embedding-4b@1024` did not match the actual local default
+* (`LOCAL_EMBEDDING_MODEL`, the bundled local embedding model), which would
+* mislabel every default-provider chunk in eval traces. Tracking the
+* embedder package's constant keeps provenance honest by construction.
+*/
+const EMBEDDER_MODEL_DEFAULT = LOCAL_EMBEDDING_MODEL;
+/** Per-hit bonus for repeated chunk hits inside one parent. */
+const MULTI_HIT_BONUS_PER_HIT = DEFAULT_AGGREGATION_CONFIG.multiHitBonusPerHit;
+/** Cap on the cumulative multi-hit bonus per parent. */
+const MULTI_HIT_BONUS_CAP = DEFAULT_AGGREGATION_CONFIG.multiHitBonusCap;
+/** Per-pair bonus for adjacent chunk hits within one parent. */
+const ADJACENCY_BONUS_PER_PAIR = DEFAULT_AGGREGATION_CONFIG.adjacencyBonusPerPair;
+/** Cap on the cumulative adjacency bonus per parent. */
+const ADJACENCY_BONUS_CAP = DEFAULT_AGGREGATION_CONFIG.adjacencyBonusCap;
+/** Invariant: bonusTotalInvariant >= MULTI_HIT_BONUS_CAP + ADJACENCY_BONUS_CAP. */
+const BONUS_TOTAL_INVARIANT = DEFAULT_AGGREGATION_CONFIG.bonusTotalInvariant;
+/** Filename for per-QA retrieval traces emitted during eval runs. */
+const EVAL_QA_TRACES_FILENAME = "qa_traces.jsonl";
+/** Multiplicative penalty applied to unreturned candidates after rerank. */
+const LIGHTWEIGHT_RERANK_PENALTY = .8;
+/**
+* Zod schema for the `recallLifecycle` config block. The whole block defaults
+* to `{}` so existing configs without it continue to parse and behave
+* bit-for-bit identically to the pre-Phase-0 baseline.
+*
+* Spec: openspec/changes/mem-lifecycle/specs/config/spec.md.
+*/
+const recallLifecycleSchema = z.object({
+	retentionScorer: z.boolean().default(true),
+	tierPromoter: z.boolean().default(true),
+	autoRecallAccessTracking: z.boolean().default(true),
+	traceEnabled: z.boolean().default(true),
+	tierFloorMode: z.enum(["bare", "withFloor"]).default("bare"),
+	tierPromotionTopK: z.number().int().positive().default(3),
+	accessRateLimitMs: z.number().int().nonnegative().default(36e5),
+	accessCountCeiling: z.number().int().positive().default(20)
+}).prefault({});
+/**
+* Resolved default `recallLifecycle` config. Use in code paths that need a
+* literal default object instead of re-parsing the schema each time.
+*/
+const DEFAULT_RECALL_LIFECYCLE = recallLifecycleSchema.parse(void 0);
+//#endregion
+//#region src/engine/i18n/locales.ts
+const SUPPORTED_LOCALES = [
+	"en",
+	"de",
+	"es",
+	"fr",
+	"zh",
+	"zh-Hant",
+	"ja",
+	"ko",
+	"ru"
+];
+const SUPPORTED_SET = new Set(SUPPORTED_LOCALES);
+function isSupportedLocale(value) {
+	return SUPPORTED_SET.has(value);
+}
+//#endregion
+//#region config/plugin-config-mode-schema.ts
+/**
+* Product LLM modes, tier-ordered: Local First (selected calls on host) → Agent
+* Native (every call borrows the host agent's model) → REM Enhanced (top
+* tier: SNO-REM-MEM serves the LoRA-covered calls, the host model covers
+* the rest).
+*/
+const PRODUCT_MODES = [
+	"local-first",
+	"agent-native",
+	"rem-enhanced"
+];
+const DEFAULT_MODEL_MODE = "agent-native";
+const remEnhancedConfigSchema = z.object({ trigger: z.object({ tick: z.boolean().default(true) }).strict().prefault({}) }).strict().prefault({});
+const llmRoutingConfigSchema = z.object({
+	mode: z.enum(PRODUCT_MODES),
+	language: z.enum(SUPPORTED_LOCALES).default("en"),
+	modelCalls: z.record(z.string(), z.record(z.enum(PRODUCT_MODES), z.enum([
+		"off",
+		"host",
+		"sno-gpu"
+	]))).optional()
+}).strict();
+//#endregion
+//#region config/plugin-config-embedding-schema.ts
+const localEmbedSessionOptionsSchema = z.object({
+	graphOptimizationLevel: z.enum([
+		"disabled",
+		"basic",
+		"extended",
+		"all"
+	]).default("extended"),
+	enableMemPattern: z.boolean().default(false),
+	enableCpuMemArena: z.boolean().default(false),
+	executionMode: z.enum(["sequential", "parallel"]).optional(),
+	interOpNumThreads: z.number().int().positive().optional(),
+	intraOpNumThreads: z.number().int().positive().optional()
+}).strict().prefault({});
+const embeddingConfigSchema = z.object({
+	provider: z.enum(["local-onnx"]).default("local-onnx"),
+	/** Hugging Face model id. Defaults to the bundled PPLX INT8 model. */
+	model: z.string().optional(),
+	/** Output dimension after optional truncation and re-normalization. */
+	dimensions: z.number().int().positive().default(VECTOR_DIMENSION_DEFAULT),
+	/** Native dimension produced by the local model. */
+	nativeDim: z.number().int().positive().optional(),
+	/** Pinned HuggingFace revision (commit SHA) for local-onnx supply-chain integrity. */
+	revision: z.string().optional(),
+	/**
+	* Pooling strategy for local-onnx. Read from the model's
+	* `1_Pooling/config.json`. Omit to use the provider default; the bundled
+	* PPLX model uses `mean`.
+	*/
+	pooling: z.enum([
+		"last_token",
+		"mean",
+		"cls"
+	]).optional(),
+	normalized: z.boolean().optional(),
+	/** Local ONNX model cache directory */
+	cacheDir: z.string().optional(),
+	offline: z.boolean().optional(),
+	mirror: z.string().optional(),
+	/** Quantization dtype: q4 | q8 | fp16 | fp32 */
+	dtype: z.enum([
+		"q4",
+		"q8",
+		"fp16",
+		"fp32"
+	]).default("q8"),
+	/** ONNX Runtime session options for local low-memory operation. */
+	sessionOptions: localEmbedSessionOptionsSchema,
+	/** Enable text chunking for long passages (default: true) */
+	chunking: z.boolean().default(true)
+}).prefault({});
+//#endregion
+//#region src/model/signed-registry-constants.ts
+/** Fixed signed, persisted, and host protocol values. Change only with their external authority. */
+const FIXED_EXTERNAL_VALUE_49 = "database contains both mem_claw_memories and nodix_memories";
+const FIXED_EXTERNAL_VALUE_51 = "PRAGMA table_info(mem_claw_memories)";
+const FIXED_EXTERNAL_VALUE_52 = "cannot read vec_mem_claw_chunks dimension";
+const FIXED_EXTERNAL_VALUE_53 = "vec_mem_claw_chunks does not match the current schema (configured dim ";
+const FIXED_EXTERNAL_VALUE_54 = "DROP TABLE mem_claw_chunks_fts";
+const FIXED_EXTERNAL_VALUE_55 = "database contains both vec_mem_claw_chunks and nodix_memory_chunk_vectors";
+const FIXED_EXTERNAL_VALUE_56 = "INSERT INTO nodix_memory_chunk_vectors(id, project_id, embedding) SELECT id, project_id, embedding FROM vec_mem_claw_chunks";
+const FIXED_EXTERNAL_VALUE_57 = "INSERT INTO nodix_memory_chunk_vectors(id, project_id, embedding)\n			SELECT vectors.id, memories.project_id, vectors.embedding\n			FROM vec_mem_claw_chunks AS vectors\n			JOIN nodix_memory_chunks AS chunks ON chunks.chunk_id = vectors.id\n			JOIN nodix_memories AS memories ON memories.id = chunks.memory_id";
+const FIXED_EXTERNAL_VALUE_58 = ";\n		DROP TABLE vec_mem_claw_chunks;\n	";
+const FIXED_EXTERNAL_VALUE_62 = "mem_claw.unplaced-candidate-migration.relocated.non.active.memory.rows.into.the.unplaced.candidate.table";
+const FIXED_EXTERNAL_VALUE_8 = "https://www.sno.ai/.well-known/sno-mem-openclaw-release.json";
+const FIXED_EXTERNAL_VALUE_9 = "did:web:www.sno.ai#sno-mem-openclaw-release";
+const FIXED_IDX_MEMORY = "idx_mem_claw";
+const FIXED_IDX_MEMORY_ACTIVE_TASK_CURRENT_REVISION = "idx_mem_claw_active_task_current_revision";
+const FIXED_IDX_MEMORY_ACTIVE_TASK_EVIDENCE_INSTANCE = "idx_mem_claw_active_task_evidence_instance";
+const FIXED_IDX_MEMORY_ACTIVE_TASK_INSTANCES_PROJECTION = "idx_mem_claw_active_task_instances_projection";
+const FIXED_IDX_MEMORY_MEMORIES_CATEGORY = "idx_mem_claw_memories_category";
+const FIXED_IDX_MEMORY_MEMORIES_CONTENT_HASH = "idx_mem_claw_memories_content_hash";
+const FIXED_IDX_MEMORY_MEMORIES_FACT_ID = "idx_mem_claw_memories_fact_id";
+const FIXED_IDX_MEMORY_MEMORIES_LANE_PROJECT = "idx_mem_claw_memories_lane_project";
+const FIXED_IDX_MEMORY_MEMORIES_PROJECT = "idx_mem_claw_memories_project";
+const FIXED_IDX_MEMORY_MEMORIES_PROJECT_CONTENT_HASH = "idx_mem_claw_memories_project_content_hash";
+const FIXED_IDX_MEMORY_MEMORIES_PROJECT_FACT_KEY_ACTIVE = "idx_mem_claw_memories_project_fact_key_active";
+const FIXED_IDX_MEMORY_MEMORIES_PROJECT_TIMESTAMP = "idx_mem_claw_memories_project_timestamp";
+const FIXED_MEMORY = "mem_claw";
+const FIXED_MEMORY_ACTIVE_TASK_EVIDENCE = "mem_claw_active_task_evidence";
+const FIXED_MEMORY_ACTIVE_TASK_INSTANCES = "mem_claw_active_task_instances";
+const FIXED_MEMORY_ACTIVE_TASK_MIGRATION_EVIDENCE = "mem_claw_active_task_migration_evidence";
+const FIXED_MEMORY_ACTIVE_TASK_MIGRATION_MANIFESTS = "mem_claw_active_task_migration_manifests";
+const FIXED_MEMORY_ACTIVE_TASK_REVISIONS = "mem_claw_active_task_revisions";
+const FIXED_MEMORY_ACTIVE_TASK_TRANSITIONS = "mem_claw_active_task_transitions";
+const FIXED_MEMORY_CHUNKS = "mem_claw_chunks";
+const FIXED_MEMORY_CHUNKS_AD = "mem_claw_chunks_ad";
+const FIXED_MEMORY_CHUNKS_AI = "mem_claw_chunks_ai";
+const FIXED_MEMORY_CHUNKS_AU = "mem_claw_chunks_au";
+const FIXED_MEMORY_CHUNKS_FTS = "mem_claw_chunks_fts";
+const FIXED_MEMORY_CHUNKS_MEM_FACET_IDX = "mem_claw_chunks_mem_facet_idx";
+const FIXED_MEMORY_CHUNKS_MEM_IDX = "mem_claw_chunks_mem_idx";
+const FIXED_MEMORY_CHUNKS_MEMORY_ID_IDX = "mem_claw_chunks_memory_id_idx";
+const FIXED_MEMORY_EXTRACTION_TIMESTAMPS = "mem_claw_extraction_timestamps";
+const FIXED_MEMORY_MEMORIES = "mem_claw_memories";
+const FIXED_MEMORY_MEMORIES_FACT_ID_INSERT_GUARD = "mem_claw_memories_fact_id_insert_guard";
+const FIXED_MEMORY_MEMORIES_FACT_ID_UPDATE_GUARD = "mem_claw_memories_fact_id_update_guard";
+const FIXED_MEMORY_MIGRATION_MARKERS = "mem_claw_migration_markers";
+const FIXED_MEMORY_PROFILE_RECOVERY_ENTRIES = "mem_claw_profile_recovery_entries";
+const FIXED_MEMORY_PROVIDER_AGENT_MAPPINGS = "mem_claw_provider_agent_mappings";
+const FIXED_MEMORY_PROVIDER_PROJECT_AGENTS = "mem_claw_provider_project_agents";
+const FIXED_MEMORY_PROVIDER_PROJECT_MAPPINGS = "mem_claw_provider_project_mappings";
+const FIXED_MEMORY_ROW_PATH_PATTERN = /^mem-claw\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.md$/;
+const FIXED_MEMORY_SNO_AI_EXTRACT = "mem_claw/sno_ai_extract";
+const FIXED_MEMORY_SNO_CONFLICT_VERDICT = "mem_claw/sno_conflict_verdict";
+const FIXED_MEMORY_SNO_EXTRACT_CHAT = "mem_claw/sno_extract_chat";
+const FIXED_MEMORY_SNO_EXTRACT_PROFILE = "mem_claw/sno_extract_profile";
+const FIXED_MEMORY_TASK_LIFECYCLE_COMMANDS = "mem_claw_task_lifecycle_commands";
+const FIXED_MEMORY_UNPLACED_CANDIDATES = "mem_claw_unplaced_candidates";
+const FIXED_PROTOCOL_VALUE_63 = "mem-claw-internal-llm";
+const FIXED_PROTOCOL_VALUE_64 = ".openclaw";
+const FIXED_PROTOCOL_VALUE_65 = "SELECT project_id FROM nodix_provider_project_mappings WHERE user_id = ? AND external_system = 'openclaw' AND external_project_key = ? LIMIT 1";
+const FIXED_PROTOCOL_VALUE_66 = "SELECT agent_id FROM nodix_provider_agent_mappings WHERE user_id = ? AND external_system = 'openclaw' AND external_agent_key = ? LIMIT 1";
+const FIXED_PROTOCOL_VALUE_67 = "INSERT OR IGNORE INTO nodix_provider_project_mappings(user_id, external_system, external_project_key, project_id, created_at_ms) VALUES (?, 'openclaw', ?, ?, ?)";
+const FIXED_PROTOCOL_VALUE_68 = "INSERT OR IGNORE INTO nodix_provider_agent_mappings(user_id, external_system, external_agent_key, agent_id, created_at_ms) VALUES (?, 'openclaw', ?, ?, ?)";
+const FIXED_PROTOCOL_VALUE_69 = "http://localhost:8070/codex/v1";
+const FIXED_PROTOCOL_VALUE_70 = "hermes";
+const FIXED_PROTOCOL_VALUE_71 = "claude-code";
+const FIXED_PROTOCOL_VALUE_72 = "codex";
+const FIXED_PROTOCOL_VALUE_73 = "mem-claw:atomic-card:v1";
+const FIXED_PROTOCOL_VALUE_74 = "sno-mem-claw";
+const FIXED_PROTOCOL_VALUE_75 = "mem-claw/self_improvement_log";
+const FIXED_PROTOCOL_VALUE_76 = "Provider authority externalSystem must be openclaw";
+const FIXED_PROTOCOL_VALUE_77 = "mem-claw/";
+const FIXED_PROTOCOL_VALUE_78 = "mem-claw/reflection/";
+const FIXED_PROTOCOL_VALUE_79 = "Stable rules inherited from mem-claw reflections. Treat as long-term behavioral constraints unless user overrides.";
+const FIXED_VEC_MEMORY = "vec_mem_claw";
+const FIXED_VEC_MEMORY_CHUNKS = "vec_mem_claw_chunks";
+const PERSISTED_CANDIDATE_HASH_V1 = "mem-claw:unplaced-candidate:legacy:v1";
+const PERSISTED_CONTENT_HASH_V1 = "mem-claw:hash:v1";
+const PERSISTED_CONTENT_HASH_V3 = "mem-claw:hash:v3";
+const PERSISTED_PROVIDER_SYSTEM = "openclaw";
+//#endregion
+//#region src/model/llm-client-types.ts
+const LLM_PRESETS = [
+	FIXED_MEMORY_SNO_AI_EXTRACT,
+	FIXED_MEMORY_SNO_EXTRACT_CHAT,
+	FIXED_MEMORY_SNO_EXTRACT_PROFILE,
+	FIXED_MEMORY_SNO_CONFLICT_VERDICT
+];
+//#endregion
+//#region config/plugin-config-feature-schema.ts
+const sessionMemoryConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	messageCount: z.number().int().min(1).max(100).default(15)
+}).prefault({});
+const selfImprovementConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	beforeResetNote: z.boolean().default(true),
+	skipSubagentBootstrap: z.boolean().default(true),
+	ensureLearningFiles: z.boolean().default(true)
+}).prefault({});
+const extractionConfigSchema = z.object({ llm: z.object({
+	preset: z.enum(LLM_PRESETS).default(FIXED_MEMORY_SNO_AI_EXTRACT),
+	/** Overrides provider default / env baseURL if set. */
+	baseURL: z.string().optional(),
+	/** Overrides provider-native env if set. */
+	apiKey: z.string().optional(),
+	timeoutMs: z.number().int().min(1e3).max(3e5).default(3e4)
+}).strict().prefault({}) }).strict().prefault({});
+const memoryReflectionConfigSchema = z.object({
+	messageCount: z.number().int().min(1).max(500).default(120),
+	maxInputChars: z.number().int().min(1e3).max(2e5).default(DEFAULT_REFLECTION_MAX_INPUT_CHARS),
+	timeoutMs: z.number().int().min(5e3).max(3e5).default(DEFAULT_REFLECTION_TIMEOUT_MS),
+	errorReminderMaxEntries: z.number().int().min(0).max(50).default(3),
+	dedupeErrorSignals: z.boolean().default(true),
+	injectMode: z.enum([
+		"inheritance+derived",
+		"inheritance-only",
+		"none"
+	]).default("inheritance+derived"),
+	storeToDb: z.boolean().default(true),
+	/**
+	* Inject reflection invariants/derived slices into agent prompts at recall
+	* time. Default `false` until the LoCoMo paired-arm gate validates eval-
+	* neutrality (PRD §4.4.1, §5 eval gate). Permanent kill switch even after
+	* the default flips.
+	*/
+	injectIntoPrompt: z.boolean().default(false),
+	agentId: z.string().optional()
+}).prefault({});
+//#endregion
+//#region config/plugin-config-observe-schema.ts
+const AGENT_IDS = [
+	PERSISTED_PROVIDER_SYSTEM,
+	FIXED_PROTOCOL_VALUE_70,
+	FIXED_PROTOCOL_VALUE_71,
+	FIXED_PROTOCOL_VALUE_72
+];
+const observeAgentIdSchema = z.enum(AGENT_IDS, { error: () => `observe.agentId must be one of ${AGENT_IDS.join(", ")}` });
+/** The observe agent id a skin reports under; a skin id outside the SDK's set is a hard error. */
+function observeAgentId(skinId) {
+	return observeAgentIdSchema.parse(skinId);
+}
+function isObserveAgentId(skinId) {
+	return observeAgentIdSchema.safeParse(skinId).success;
+}
+function isLoopbackUrl(url) {
+	return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1" || url.hostname === "[::1]";
+}
+function validateObserveBaseUrl(value, ctx) {
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["baseUrl"],
+			message: `Invalid observe.baseUrl: "${value}"`
+		});
+		return;
+	}
+	const normalized = parsed.origin;
+	if (process.env.SNO_STATION_MEM_NODE_ENV === "test" && isLoopbackUrl(parsed)) {
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["baseUrl"],
+			message: "observe.baseUrl test fixture must use http or https"
+		});
+		return;
+	}
+	if (normalized !== "https://www.sno.ai") ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["baseUrl"],
+		message: `observe.baseUrl must be ${SNO_OBSERVE_DEFAULT_BASE_URL} outside loopback tests`
+	});
+}
+const observeConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	baseUrl: z.string().default(SNO_OBSERVE_DEFAULT_BASE_URL),
+	agentId: observeAgentIdSchema.default(SNO_OBSERVE_DEFAULT_AGENT_ID)
+}).prefault({}).superRefine((value, ctx) => {
+	if (value.enabled) validateObserveBaseUrl(value.baseUrl, ctx);
+});
+//#endregion
+//#region config/plugin-config-retrieval-schema.ts
+const log = createLogger("sno-station-mem:config:retrieval");
+const retrievalConfigSchema = z.object({
+	mode: z.enum(["precision-recall", "vector"]).default("precision-recall"),
+	/**
+	* Top-K memories injected per turn during auto-recall. Source of truth
+	* for the runtime retriever `limit`; AC5 drift test pins this default
+	* to AUTO_RECALL_INJECTION_TOP_K (currently 20). Lower (15) trades
+	* ~5pp accuracy for ~25% fewer prompt tokens.
+	*/
+	recallTopK: z.number().int().min(0).max(2e3).default(20),
+	vectorWeight: z.number().min(0).max(1).default(DEFAULT_VECTOR_WEIGHT),
+	bm25Weight: z.number().min(0).max(1).default(DEFAULT_BM25_WEIGHT),
+	minScore: z.number().min(0).max(1).default(0),
+	rerank: z.enum([
+		"cross-encoder",
+		"lightweight",
+		"none"
+	]).default("lightweight"),
+	candidatePoolSize: z.number().int().min(10).max(2e3).default(64),
+	rerankApiKey: z.string().optional(),
+	rerankModel: z.string().default(DEFAULT_RERANK_MODEL),
+	rerankTimeoutMs: z.number().int().min(1e3).max(12e4).default(DEFAULT_RERANK_TIMEOUT_MS),
+	recencyHalfLifeDays: z.number().min(0).max(365).default(14),
+	recencyWeight: z.number().min(0).max(RECENCY_WEIGHT_MAX).default(RECENCY_WEIGHT),
+	/** Drop memories past their valid_until timestamp (default OFF — needs A/B eval) */
+	temporalWeighting: z.boolean().default(false),
+	mmrWindowOnly: z.boolean().default(false),
+	temporalExpiry: z.boolean().default(false),
+	/** Dynamic memories decay 3× faster in time-decay scoring (default ON — low risk) */
+	temporalDecay: z.boolean().default(true),
+	lengthNormAnchor: z.number().int().min(0).max(5e3).default(0),
+	hardMinScore: z.number().min(0).max(1).default(0),
+	timeDecayHalfLifeDays: z.number().min(0).max(365).default(60),
+	/** Weight for fusion score in rerank blend */
+	rerankBlendVector: z.number().min(0).max(1).optional(),
+	/** Weight for cross-encoder score in rerank blend */
+	rerankBlendCross: z.number().min(0).max(1).optional(),
+	/** Fusion-score weight when rerank="lightweight" (local cosine blend) */
+	lightweightFusionWeight: z.number().min(0).max(1).optional(),
+	/** Cosine-score weight when rerank="lightweight" (local cosine blend) */
+	lightweightCosineWeight: z.number().min(0).max(1).optional(),
+	/** Base multiplier for importance weighting */
+	importanceWeightBase: z.number().min(0).max(1).optional(),
+	/** Minimum multiplier for old entries */
+	timeDecayFloor: z.number().min(0).max(1).optional(),
+	/** Relevance vs diversity tradeoff (default: 0.7) */
+	mmrLambda: z.number().min(0).max(1).optional(),
+	/** Custom rerank API endpoint URL. */
+	rerankEndpoint: z.string().optional(),
+	/** Rerank provider name */
+	rerankProvider: z.enum([
+		"jina",
+		"siliconflow",
+		"pinecone",
+		"voyage",
+		"dashscope",
+		"tei",
+		"custom"
+	]).optional(),
+	/** Hard cap on candidates sent per rerank API request (some deployments reject over-limit batches) */
+	rerankMaxCandidates: z.number().int().min(1).max(2e3).optional(),
+	/** Scaling factor for access-based reinforcement (0 = disabled, default: 0.5) */
+	reinforcementFactor: z.number().min(0).max(5).default(.5),
+	/** Hard cap: effective half-life <= baseHalfLife * maxHalfLifeMultiplier (default: 3) */
+	maxHalfLifeMultiplier: z.number().min(1).max(10).default(3)
+}).prefault({}).transform((ret, ctx) => {
+	if (ret.rerank === "none") return ret;
+	if ((ret.rerank === "cross-encoder" || ret.rerankEndpoint !== void 0) && ret.rerankProvider === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["rerankProvider"],
+		message: "retrieval.rerankProvider is required when retrieval.rerank is \"cross-encoder\" or retrieval.rerankEndpoint is set: the provider decides the request shape and the per-request batch limit"
+	});
+	if (ret.rerankEndpoint !== void 0) try {
+		new URL(ret.rerankEndpoint);
+	} catch {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["rerankEndpoint"],
+			message: `Invalid rerankEndpoint URL: "${ret.rerankEndpoint}"`
+		});
+	}
+	const rerankApiKey = ret.rerankApiKey;
+	if (ret.rerank === "cross-encoder" && !rerankApiKey?.trim()) {
+		log.error("memory.rerank.key.missing", { cause: "missing-rerank-key" }, {
+			event_name: "memory.rerank.key.missing",
+			file: "packages/memory/config/plugin-config-retrieval-schema.ts",
+			function: "retrievalConfigSchema",
+			site_id: "memory.rerank.key.missing"
+		});
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["rerankApiKey"],
+			message: "retrieval.rerankApiKey is required for cross-encoder reranking"
+		});
+	}
+	return ret;
+});
+//#endregion
+//#region config/session-strategy.ts
+/** @file session-strategy.ts
+* @purpose Defines session-memory strategy constants without importing plugin config schemas.
+* @boundary Shared literal values only; no schema or runtime registration dependencies.
+*/
+const SESSION_STRATEGIES = [
+	"memoryReflection",
+	"systemSessionMemory",
+	"none"
+];
+//#endregion
+//#region config/plugin-config-schema.ts
+const scopesConfigSchema = z.object({
+	default: z.string().default(DEFAULT_SCOPE),
+	definitions: z.record(z.string(), z.object({
+		description: z.string().optional(),
+		metadata: z.record(z.string(), z.unknown()).optional()
+	})).prefault({ global: { description: "Shared knowledge across all agents" } }),
+	agentAccess: z.record(z.string(), z.array(z.string())).default({})
+}).prefault({});
+const providerConfigSchema = z.object({ userId: z.string().trim().optional() }).strict().prefault({});
+const ONBOARDING_PROFILES = [
+	"local-active",
+	"capture-only",
+	"manual-only",
+	"custom"
+];
+const REM_OPERATIONS = ["rem-replace", "rem-update"];
+const pluginConfigSchema = z.object({
+	embedding: embeddingConfigSchema,
+	observe: observeConfigSchema,
+	dbPath: z.string().optional(),
+	provider: providerConfigSchema,
+	ambientLearning: z.boolean().default(true),
+	autoRecall: z.boolean().default(false),
+	/** Minimum query length for auto-recall to fire (default: 15) */
+	autoRecallMinLength: z.number().int().min(0).max(200).default(2),
+	/** Skip re-injecting a memory if it was shown within the last N turns (0 = no dedup) */
+	autoRecallMinRepeated: z.number().int().min(0).max(100).default(0),
+	/** Maximum character length of auto-recall query before truncation */
+	autoRecallMaxQueryLength: z.number().int().min(100).max(1e4).default(DEFAULT_AUTO_RECALL_MAX_QUERY_LENGTH),
+	/** Timeout in ms for the entire auto-recall pipeline (embed + search + rerank) */
+	autoRecallTimeoutMs: z.number().int().min(500).max(6e4).default(5e3),
+	/**
+	* Whitelist: if non-empty, ONLY these agentIds receive auto-recall injection.
+	* Takes precedence over autoRecallExcludeAgents when both are set. Entries
+	* are trimmed; empty strings are dropped.
+	*/
+	autoRecallIncludeAgents: z.array(z.string().transform((s) => s.trim())).transform((arr) => arr.filter((s) => s.length > 0)).default([]),
+	/**
+	* Blocklist: agentIds excluded from auto-recall injection. The implicit
+	* "main" fallback used when hook context lacks a parseable agent identity
+	* is evaluated against this blocklist too.
+	*/
+	autoRecallExcludeAgents: z.array(z.string().transform((s) => s.trim())).transform((arr) => arr.filter((s) => s.length > 0)).default([]),
+	captureAssistant: z.boolean().default(false),
+	retrieval: retrievalConfigSchema,
+	scopes: scopesConfigSchema,
+	enableManagementTools: z.boolean().default(false),
+	/**
+	* Optional user-facing language for tool descriptions and other static
+	* locale-bound surface that cannot be derived from query text.
+	*/
+	language: z.enum(SUPPORTED_LOCALES).optional(),
+	sessionStrategy: z.enum(SESSION_STRATEGIES).default("systemSessionMemory"),
+	sessionMemory: sessionMemoryConfigSchema,
+	compression: z.object({ enabled: z.boolean().default(false) }).optional(),
+	selfImprovement: selfImprovementConfigSchema,
+	extraction: extractionConfigSchema,
+	memoryReflection: memoryReflectionConfigSchema,
+	/**
+	* Phase 0 lifecycle stub channel. All flags default false; enabling any
+	* lights up its dedicated wire site without altering the others.
+	*/
+	recallLifecycle: recallLifecycleSchema,
+	memoryTelemetry: z.object({
+		enabled: z.boolean().default(true),
+		currentKeyVersion: z.number().int().positive().default(1),
+		key: z.string().default(""),
+		historicKeys: z.array(z.string()).default([])
+	}).prefault({}),
+	debugContent: z.boolean().default(false),
+	/**
+	* Product LLM mode, tier-ordered: local-first → agent-native →
+	* rem-enhanced. A true bare config defaults to agent-native; model route
+	* config requires an explicit product mode.
+	*/
+	mode: z.enum(PRODUCT_MODES).default(DEFAULT_MODEL_MODE),
+	modelCalls: z.record(z.string(), z.record(z.enum(PRODUCT_MODES), z.enum([
+		"off",
+		"host",
+		"sno-gpu"
+	]))).optional(),
+	remOperations: z.array(z.enum(REM_OPERATIONS)).min(1).max(2).default([...REM_OPERATIONS]),
+	remEnhanced: remEnhancedConfigSchema,
+	/**
+	* Installer completion marker (bin/_onboarding-core.js writes it into
+	* this same config block). The runtime never reads it, but the strict
+	* schema must accept it or every installer-onboarded config fails to
+	* load.
+	*/
+	onboarding: z.object({
+		version: z.number().int().positive(),
+		completedAt: z.string(),
+		profile: z.enum(ONBOARDING_PROFILES)
+	}).strict().optional()
+}).strict();
+//#endregion
+//#region src/model/model-call-table.ts
+const extract = {
+	"local-first": "off",
+	"agent-native": "host",
+	"rem-enhanced": "sno-gpu"
+};
+const host = {
+	"local-first": "off",
+	"agent-native": "host",
+	"rem-enhanced": "host"
+};
+const profile = {
+	"local-first": "host",
+	"agent-native": "host",
+	"rem-enhanced": "host"
+};
+const rem = {
+	"local-first": "host",
+	"agent-native": "host",
+	"rem-enhanced": "sno-gpu"
+};
+const remHost = {
+	"local-first": "host",
+	"agent-native": "host",
+	"rem-enhanced": "host"
+};
+const chat = FIXED_MEMORY_SNO_EXTRACT_CHAT;
+const verdict = FIXED_MEMORY_SNO_CONFLICT_VERDICT;
+const MODEL_CALLS = {
+	E1: {
+		description: "conversation extraction",
+		occasion: "memoryExtract",
+		destinations: extract,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	E2: {
+		description: "fact enrichment",
+		occasion: "memoryExtract",
+		destinations: extract,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	E3: {
+		description: "missed figure recovery",
+		occasion: "memoryExtract",
+		destinations: extract,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	E4: {
+		description: "compound record split",
+		occasion: "memoryExtract",
+		destinations: extract,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	E5: {
+		description: "missing half recovery",
+		occasion: "memoryExtract",
+		destinations: extract,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	E6: {
+		description: "subject check",
+		occasion: "memoryExtract",
+		destinations: extract,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	E7: {
+		description: "unresolved subject recovery",
+		occasion: "memoryExtract",
+		destinations: extract,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	E8: {
+		description: "same entity judgment",
+		occasion: "memoryExtract",
+		destinations: extract,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	E9: {
+		description: "profile keying",
+		occasion: "memoryExtract",
+		destinations: extract,
+		snoPreset: FIXED_MEMORY_SNO_EXTRACT_PROFILE,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "raw-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	E10: {
+		description: "arrival retirement judgment",
+		occasion: "conflictAdjudication",
+		destinations: extract,
+		snoPreset: verdict,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "raw-completions"
+		},
+		promptVariant: {
+			host: "adapter-a-chat",
+			snoGpu: "adapter-a-raw"
+		},
+		replyParser: {
+			host: "json-or-single-token-verdict",
+			snoGpu: "single-token-verdict"
+		}
+	},
+	E11: {
+		description: "date resolution",
+		occasion: "dateResolution",
+		destinations: host,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "text",
+			snoGpu: "text"
+		}
+	},
+	E12: {
+		description: "background state keying",
+		occasion: "memoryExtract",
+		destinations: extract,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	P1: {
+		description: "profile conflict judgment",
+		occasion: "conflictAdjudication",
+		destinations: extract,
+		snoPreset: verdict,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "raw-completions"
+		},
+		promptVariant: {
+			host: "adapter-a-chat",
+			snoGpu: "adapter-a-raw"
+		},
+		replyParser: {
+			host: "json-or-single-token-verdict",
+			snoGpu: "single-token-verdict"
+		}
+	},
+	P2: {
+		description: "profile lifecycle retirement",
+		occasion: "profileSectionMerge",
+		destinations: profile,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	P3: {
+		description: "profile retirement recheck",
+		occasion: "profileSectionMerge",
+		destinations: profile,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	P4: {
+		description: "profile section judgment",
+		occasion: "profileSectionMerge",
+		destinations: profile,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	P5: {
+		description: "profile section text",
+		occasion: "profileSectionMerge",
+		destinations: profile,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	P6: {
+		description: "retire by name",
+		occasion: "profileSectionMerge",
+		destinations: profile,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	T1: {
+		description: "active task classification and match",
+		occasion: "profileActiveTaskClassify",
+		destinations: host,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	R1: {
+		description: "session reflection",
+		occasion: "summaryBuild",
+		destinations: host,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "text",
+			snoGpu: "text"
+		}
+	},
+	R2: {
+		description: "label local sessions before the nightly cloud upload",
+		calledBy: "RSI skill",
+		destinations: host
+	},
+	R3: {
+		description: "upload sessions nightly for cloud experience and skill review",
+		calledBy: "RSI skill",
+		destinations: {
+			"local-first": "off",
+			"agent-native": "sno-gpu",
+			"rem-enhanced": "sno-gpu"
+		}
+	},
+	R4: {
+		description: "recall one relevant cloud experience on a session's first prompt",
+		calledBy: "RSI skill",
+		destinations: {
+			"local-first": "off",
+			"agent-native": "sno-gpu",
+			"rem-enhanced": "sno-gpu"
+		}
+	},
+	REM1: {
+		description: "replace conflict pair",
+		occasion: "conflictAdjudication",
+		destinations: rem,
+		snoPreset: verdict,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "raw-completions"
+		},
+		promptVariant: {
+			host: "adapter-a-chat",
+			snoGpu: "adapter-a-raw"
+		},
+		replyParser: {
+			host: "json-or-single-token-verdict",
+			snoGpu: "single-token-verdict"
+		}
+	},
+	REM2: {
+		description: "replace clauses",
+		occasion: "memoryExtract",
+		destinations: remHost,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	REM3: {
+		description: "replace coverage",
+		occasion: "memoryExtract",
+		destinations: rem,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	REM4: {
+		description: "replace clause carry",
+		occasion: "memoryExtract",
+		destinations: rem,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	REM5: {
+		description: "update judgment",
+		occasion: "memoryExtract",
+		destinations: rem,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	REM6: {
+		description: "update verification",
+		occasion: "memoryExtract",
+		destinations: remHost,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	REM7: {
+		description: "update relation",
+		occasion: "memoryExtract",
+		destinations: remHost,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	},
+	REM8: {
+		description: "update retirement target",
+		occasion: "memoryExtract",
+		destinations: remHost,
+		snoPreset: chat,
+		transport: {
+			host: "agent-host-seam",
+			snoGpu: "chat-completions"
+		},
+		promptVariant: {
+			host: "standard",
+			snoGpu: "standard"
+		},
+		replyParser: {
+			host: "json",
+			snoGpu: "json"
+		}
+	}
+};
+function modelCallDestination(callId, mode, modelCalls) {
+	return modelCalls[callId][mode];
+}
+//#endregion
+//#region config/settings.ts
+const destination = z.enum([
+	"off",
+	"host",
+	"sno-gpu"
+]);
+const destinations = z.strictObject({
+	"local-first": destination,
+	"agent-native": destination,
+	"rem-enhanced": destination
+});
+const modelCalls = z.strictObject(Object.fromEntries(Object.keys(MODEL_CALLS).map((id) => [id, destinations])));
+const settingsSchema = z.strictObject({
+	mode: z.enum(PRODUCT_MODES),
+	modelCalls,
+	user: z.strictObject({
+		id: z.string().refine((id) => id === "" || isLowercaseCanonicalUUIDv7(id)),
+		language: z.enum(SUPPORTED_LOCALES)
+	}),
+	snoGpu: z.strictObject({
+		baseUrl: z.string(),
+		apiKey: z.string()
+	}),
+	rerank: z.strictObject({
+		mode: z.enum([
+			"lightweight",
+			"cross-encoder",
+			"none"
+		]),
+		provider: z.enum([
+			"jina",
+			"siliconflow",
+			"pinecone",
+			"voyage",
+			"dashscope",
+			"tei",
+			"custom"
+		]),
+		endpoint: z.string(),
+		model: z.string(),
+		apiKey: z.string(),
+		timeoutMs: z.number().int().min(1e3).max(12e4),
+		maxCandidates: z.number().int().min(1).max(2e3)
+	}),
+	store: z.strictObject({
+		path: z.string(),
+		encryptionKey: z.string().min(1).regex(/^[0-9a-f]{64}$/u)
+	}),
+	embedding: z.strictObject({
+		model: z.string(),
+		revision: z.string(),
+		dtype: z.enum([
+			"q4",
+			"q8",
+			"fp16",
+			"fp32"
+		]),
+		threads: z.number().int().nonnegative(),
+		cacheDir: z.string(),
+		offline: z.boolean(),
+		mirror: z.string()
+	}),
+	recall: z.strictObject({
+		auto: z.boolean(),
+		sessionStart: z.strictObject({
+			limit: z.number().int().nonnegative(),
+			maxChars: z.number().int().nonnegative(),
+			timeoutMs: z.number().int().nonnegative()
+		}),
+		prompt: z.strictObject({
+			limit: z.number().int().min(0).max(2e3),
+			maxChars: z.number().int().nonnegative(),
+			timeoutMs: z.number().int().min(500).max(6e4),
+			minChars: z.number().int().min(0).max(200),
+			minScore: z.number().min(0).max(1)
+		}),
+		explicitLimit: z.number().int().nonnegative()
+	}),
+	capture: z.strictObject({
+		assistant: z.boolean(),
+		ambient: z.boolean(),
+		sessionMemory: z.strictObject({
+			enabled: z.boolean(),
+			messageCount: z.number().int().min(1).max(100)
+		}),
+		sessionStrategy: z.enum(SESSION_STRATEGIES)
+	}),
+	rem: z.strictObject({
+		tick: z.boolean(),
+		operations: z.array(z.enum(["rem-replace", "rem-update"])).min(1).max(2)
+	}),
+	telemetry: z.strictObject({
+		memoryUsage: z.strictObject({
+			enabled: z.boolean(),
+			key: z.string(),
+			historicKeys: z.array(z.string())
+		}),
+		observe: z.strictObject({
+			enabled: z.boolean(),
+			baseUrl: z.string()
+		}),
+		redactionRules: z.array(z.string())
+	}),
+	logging: z.strictObject({
+		level: z.enum([
+			"debug",
+			"info",
+			"warn",
+			"error"
+		]),
+		file: z.string(),
+		debugContent: z.boolean()
+	}),
+	memoryPackage: z.strictObject({
+		path: z.string(),
+		node: z.string()
+	})
+});
+function defaultSettings() {
+	const engine = pluginConfigSchema.parse({});
+	return {
+		mode: engine.mode,
+		modelCalls: Object.fromEntries(Object.entries(MODEL_CALLS).map(([id, call]) => [id, call.destinations])),
+		user: {
+			id: "",
+			language: "en"
+		},
+		snoGpu: {
+			baseUrl: "https://rt3-llm.sno.ai",
+			apiKey: ""
+		},
+		rerank: {
+			mode: "lightweight",
+			provider: "voyage",
+			endpoint: "",
+			model: engine.retrieval.rerankModel,
+			apiKey: "",
+			timeoutMs: engine.retrieval.rerankTimeoutMs,
+			maxCandidates: 64
+		},
+		store: {
+			path: "",
+			encryptionKey: ""
+		},
+		embedding: {
+			model: EMBEDDER_MODEL_DEFAULT,
+			revision: LOCAL_EMBEDDING_MODEL_REVISION,
+			dtype: engine.embedding.dtype,
+			threads: 0,
+			cacheDir: "",
+			offline: false,
+			mirror: ""
+		},
+		recall: {
+			auto: true,
+			sessionStart: {
+				limit: 5,
+				maxChars: 3500,
+				timeoutMs: 8e3
+			},
+			prompt: {
+				limit: 3,
+				maxChars: 1500,
+				timeoutMs: 4e3,
+				minChars: 12,
+				minScore: 0
+			},
+			explicitLimit: 5
+		},
+		capture: {
+			assistant: true,
+			ambient: true,
+			sessionMemory: {
+				enabled: true,
+				messageCount: 15
+			},
+			sessionStrategy: "systemSessionMemory"
+		},
+		rem: {
+			tick: engine.remEnhanced?.trigger.tick ?? true,
+			operations: engine.remOperations
+		},
+		telemetry: {
+			memoryUsage: {
+				enabled: false,
+				key: "",
+				historicKeys: []
+			},
+			observe: {
+				enabled: true,
+				baseUrl: "https://www.sno.ai"
+			},
+			redactionRules: []
+		},
+		logging: {
+			level: "info",
+			file: "",
+			debugContent: false
+		},
+		memoryPackage: {
+			path: "",
+			node: ""
+		}
+	};
+}
+function settingsToPluginConfig(settings) {
+	return pluginConfigSchema.parse({
+		mode: settings.mode,
+		modelCalls: settings.modelCalls,
+		provider: { userId: settings.user.id || void 0 },
+		language: settings.user.language,
+		dbPath: settings.store.path,
+		embedding: {
+			model: settings.embedding.model,
+			revision: settings.embedding.revision || void 0,
+			dtype: settings.embedding.dtype,
+			cacheDir: settings.embedding.cacheDir || void 0,
+			offline: settings.embedding.offline,
+			mirror: settings.embedding.mirror,
+			sessionOptions: { intraOpNumThreads: settings.embedding.threads || void 0 }
+		},
+		retrieval: {
+			rerank: settings.rerank.mode,
+			rerankProvider: settings.rerank.provider,
+			recallTopK: settings.recall.prompt.limit,
+			minScore: settings.recall.prompt.minScore,
+			rerankEndpoint: settings.rerank.endpoint || void 0,
+			rerankModel: settings.rerank.model,
+			rerankApiKey: settings.rerank.apiKey,
+			rerankTimeoutMs: settings.rerank.timeoutMs,
+			rerankMaxCandidates: settings.rerank.maxCandidates
+		},
+		autoRecall: settings.recall.auto,
+		autoRecallTimeoutMs: settings.recall.prompt.timeoutMs,
+		autoRecallMinLength: settings.recall.prompt.minChars,
+		captureAssistant: settings.capture.assistant,
+		ambientLearning: settings.capture.ambient,
+		debugContent: settings.logging.debugContent,
+		sessionMemory: settings.capture.sessionMemory,
+		sessionStrategy: settings.capture.sessionStrategy,
+		remEnhanced: { trigger: { tick: settings.rem.tick } },
+		remOperations: settings.rem.operations,
+		memoryTelemetry: {
+			enabled: settings.telemetry.memoryUsage.enabled,
+			currentKeyVersion: settings.telemetry.memoryUsage.historicKeys.length + 1,
+			key: settings.telemetry.memoryUsage.key,
+			historicKeys: settings.telemetry.memoryUsage.historicKeys
+		},
+		observe: settings.telemetry.observe,
+		extraction: { llm: {
+			baseURL: settings.snoGpu.baseUrl,
+			apiKey: settings.snoGpu.apiKey
+		} }
+	});
+}
+//#endregion
+//#region src/contract/profile.ts
+function getStateDir(defaultStateDir) {
+	return path.resolve(process.env.SNO_PROFILE_DIR ?? defaultStateDir ?? path.join(homedir(), ".sno"));
+}
+function getSettingsPath() {
+	return path.join(getStateDir(), "settings.json");
+}
+var SettingsUnavailableError = class extends Error {};
+function readSettings() {
+	const settingsPath = getSettingsPath();
+	let raw;
+	try {
+		raw = JSON.parse(readFileSync(settingsPath, "utf8"));
+	} catch (error) {
+		throw new SettingsUnavailableError(`settings unavailable: ${settingsPath}: ${error instanceof Error && "code" in error && error.code === "ENOENT" ? "file" : error instanceof SyntaxError ? `JSON: ${error.message}` : "file"}; see https://github.com/sno-ai/sno-station/blob/main/docs/memory-setup.md`);
+	}
+	const parsed = settingsSchema.safeParse(raw);
+	if (!parsed.success) {
+		const issue = parsed.error.issues[0];
+		throw new SettingsUnavailableError(`settings unavailable: ${settingsPath}: ${issue?.code === "unrecognized_keys" ? [...issue.path, issue.keys[0]].join(".") : issue?.path.join(".") || "settings"}; see https://github.com/sno-ai/sno-station/blob/main/docs/memory-setup.md`);
+	}
+	return parsed.data;
+}
+function getSnoStationMemStateDir() {
+	return path.join(getStateDir(), "sno-station-mem");
+}
+function getPrincipal() {
+	return userInfo().username;
+}
+function getDiscoveryPath() {
+	return path.join(getStateDir(), "station", "sidecar.json");
+}
+function getSidecarSocketPath() {
+	return path.join(getStateDir(), "station", "sidecar.sock");
+}
+//#endregion
+//#region src/sidecar/config.ts
+/** @file config.ts
+* @purpose Centralizes the standalone REM sidecar's paths, protocol constants, and boot settings.
+* @boundary Environment and filesystem configuration for CLI discovery and local REM state.
+*/
+const REM_SIDECAR_HOST = "127.0.0.1";
+const REM_SIDECAR_ORIGIN = "http://127.0.0.1";
+const REM_SIDECAR_TOKEN_HEADER = "x-sidecar-token";
+const REM_CORRELATION_ID_HEADER = "x-rem-correlation-id";
+const REM_RUN_PATH = "/rem/run";
+const REM_JOBS_PATH_PREFIX = "/rem/jobs/";
+const HEALTH_PATH = "/healthz";
+const REM_SOURCE = "sidecar";
+const REM_MODEL_OUTPUT_TOKEN_CAP = 4096;
+const MEMORY_USAGE_FLUSH_INTERVAL_MS = 3e5;
+const SNO_REM_TEST_HOLD_MS_ENV = "SNO_STATION_MEM_REM_TEST_HOLD_MS";
+const SNO_REM_TRACE_ENV = "SNO_STATION_MEM_REM_TRACE";
+const REM_JOB_JOURNAL_NAME = "rem-wave-jobs.jsonl";
+const REM_TRACE_LOG_NAME = "rem-trace.jsonl";
+const REM_CHASSIS_JOURNAL_NAME = "rem-chassis-journal.jsonl";
+function getRemDiscoveryPath() {
+	return getDiscoveryPath();
+}
+function getRemJobJournalPath() {
+	return path.join(getSnoStationMemStateDir(), REM_JOB_JOURNAL_NAME);
+}
+function getRemChassisJournalPath() {
+	return path.join(getSnoStationMemStateDir(), REM_CHASSIS_JOURNAL_NAME);
+}
+function getRemTraceLogPath(stateRoot = getStateDir()) {
+	return path.join(stateRoot, "sno-station-mem", REM_TRACE_LOG_NAME);
+}
+function isRemTraceEnabled() {
+	return ![
+		"0",
+		"false",
+		"off"
+	].includes((process.env[SNO_REM_TRACE_ENV] ?? "1").toLowerCase());
+}
+function readRemTestHoldMs() {
+	const raw = process.env[SNO_REM_TEST_HOLD_MS_ENV];
+	if (raw === void 0) return 0;
+	const value = Number(raw);
+	if (!Number.isSafeInteger(value) || value < 0) {
+		reportConfigFailure(/* @__PURE__ */ new Error(`${SNO_REM_TEST_HOLD_MS_ENV} must be a non-negative integer`));
+		return 0;
+	}
+	return value;
+}
+const DEFAULT_REM_CONFIGURATION = {
+	profileId: "default",
+	operations: {
+		"rem-replace": true,
+		"rem-update": true,
+		"rem-distill": true,
+		"rem-retire": true
+	},
+	budgets: { maxPairs: 200 },
+	retrieval: {
+		neighborLimit: 10,
+		similarityThreshold: .8
+	},
+	coverage: { accuracyFloor: null },
+	retries: { liveContentionRetries: 1 },
+	facetPolicy: {
+		aggregationGrammar: "current-first-v1",
+		historyGrammar: "history-evidence-v1"
+	},
+	calibration: {
+		minimumPublishableScoreEffect: null,
+		minimumTargetCount: null,
+		minimumTargetPercent: null
+	},
+	enableGateDigests: {
+		"p5-production-config": "0".repeat(64),
+		"p6-monthly-non-regression": "0".repeat(64),
+		"p7-detector-gate-verdict": "0".repeat(64),
+		"population-routing": "0".repeat(64),
+		"rem-update": "0".repeat(64),
+		"rem-replace": "0".repeat(64)
+	}
+};
+function reportConfigFailure(error) {
+	createLogger("sno-station-mem:config").error("sidecar.config.failed", { error }, {
+		event_name: "sidecar.config.failed",
+		file: "packages/memory/src/sidecar/config.ts",
+		function: "reportConfigFailure",
+		site_id: "sidecar.config.failed"
+	});
+}
+function readRemOperationalConfig() {
+	return DEFAULT_REM_CONFIGURATION;
+}
+const MAINTENANCE_INTERVAL_ENV = "SNO_STATION_MEM_MAINTENANCE_INTERVAL_MS";
+const REM_CLOCK_OVERRIDE_ENV = "SNO_STATION_MEM_REM_CLOCK_OVERRIDE";
+const REM_VOLUME_THRESHOLD_ENV = "SNO_STATION_MEM_REM_VOLUME_THRESHOLD";
+function readMaintenanceOverrides() {
+	const positive = (name) => {
+		const raw = process.env[name];
+		if (raw === void 0) return void 0;
+		const value = Number(raw);
+		if (!Number.isSafeInteger(value) || value < 1) {
+			reportConfigFailure(/* @__PURE__ */ new Error(`${name} must be a positive integer`));
+			return;
+		}
+		return value;
+	};
+	const rawClock = process.env[REM_CLOCK_OVERRIDE_ENV];
+	const now = rawClock === void 0 ? void 0 : new Date(rawClock);
+	if (now && Number.isNaN(now.getTime())) {
+		reportConfigFailure(/* @__PURE__ */ new Error(`${REM_CLOCK_OVERRIDE_ENV} must be an ISO timestamp`));
+		return {};
+	}
+	return {
+		intervalMs: positive(MAINTENANCE_INTERVAL_ENV),
+		now,
+		volumeThreshold: positive(REM_VOLUME_THRESHOLD_ENV)
+	};
+}
+//#endregion
+export { FIXED_IDX_MEMORY_ACTIVE_TASK_CURRENT_REVISION as $, MAX_CANDIDATE_POOL_SIZE as $n, FIXED_PROTOCOL_VALUE_79 as $t, modelCallDestination as A, DEFAULT_REFLECTION_ERROR_SCAN_MAX_CHARS as An, FIXED_MEMORY_PROFILE_RECOVERY_ENTRIES as At, FIXED_EXTERNAL_VALUE_49 as B, FORGET_QUERY_MIN_SCORE as Bn, FIXED_PROTOCOL_VALUE_63 as Bt, getSidecarSocketPath as C, CHUNK_OVERLAP_TOKENS as Cn, CachedEmbeddingProvider as Cr, FIXED_MEMORY_CHUNKS_MEM_FACET_IDX as Ct, defaultSettings as D, DEFAULT_IMPORTANCE as Dn, LocalEmbedProvider as Dr, FIXED_MEMORY_MEMORIES_FACT_ID_INSERT_GUARD as Dt, readSettings as E, DEFAULT_BM25_WEIGHT as En, LOCAL_EMBEDDING_MODEL_REVISION as Er, FIXED_MEMORY_MEMORIES as Et, observeConfigSchema as F, DEFAULT_VECTOR_WEIGHT as Fn, FIXED_MEMORY_SNO_AI_EXTRACT as Ft, FIXED_EXTERNAL_VALUE_55 as G, IMPORTANCE_WEIGHT_BASE as Gn, FIXED_PROTOCOL_VALUE_68 as Gt, FIXED_EXTERNAL_VALUE_52 as H, HEAD_EXTRACT_MIN_CONTENT_TOKENS as Hn, FIXED_PROTOCOL_VALUE_65 as Ht, extractionConfigSchema as I, EMBEDDER_DIM as In, FIXED_MEMORY_SNO_EXTRACT_CHAT as It, FIXED_EXTERNAL_VALUE_58 as J, LIGHTWEIGHT_COSINE_WEIGHT as Jn, FIXED_PROTOCOL_VALUE_74 as Jt, FIXED_EXTERNAL_VALUE_56 as K, INTEGRITY_CHECK_INTERVAL_MS as Kn, FIXED_PROTOCOL_VALUE_69 as Kt, memoryReflectionConfigSchema as L, EMBEDDER_MODEL_DEFAULT as Ln, FIXED_MEMORY_SNO_EXTRACT_PROFILE as Lt, retrievalConfigSchema as M, DEFAULT_RERANK_MODEL as Mn, FIXED_MEMORY_PROVIDER_PROJECT_AGENTS as Mt, isObserveAgentId as N, DEFAULT_RERANK_TIMEOUT_MS as Nn, FIXED_MEMORY_PROVIDER_PROJECT_MAPPINGS as Nt, settingsToPluginConfig as O, DEFAULT_RECALL_LIFECYCLE as On, ensureModelDownloaded as Or, FIXED_MEMORY_MEMORIES_FACT_ID_UPDATE_GUARD as Ot, observeAgentId as P, DEFAULT_SCOPE as Pn, FIXED_MEMORY_ROW_PATH_PATTERN as Pt, FIXED_IDX_MEMORY as Q, MAX_AGGREGATION_RESULT_TOKENS as Qn, FIXED_PROTOCOL_VALUE_78 as Qt, selfImprovementConfigSchema as R, EMBEDDER_PROVIDER_DEFAULT as Rn, FIXED_MEMORY_TASK_LIFECYCLE_COMMANDS as Rt, getSettingsPath as S, CHUNK_MIN_TOKENS as Sn, recallLifecycleSchema as Sr, FIXED_MEMORY_CHUNKS_MEMORY_ID_IDX as St, getStateDir as T, CHUNK_TOKENIZER_MODE as Tn, LOCAL_EMBEDDING_MODEL as Tr, FIXED_MEMORY_EXTRACTION_TIMESTAMPS as Tt, FIXED_EXTERNAL_VALUE_53 as U, HEAD_EXTRACT_OVERLAP_DROP_RATIO as Un, FIXED_PROTOCOL_VALUE_66 as Ut, FIXED_EXTERNAL_VALUE_51 as V, FTS_MERGE_INTERVAL_MS as Vn, FIXED_PROTOCOL_VALUE_64 as Vt, FIXED_EXTERNAL_VALUE_54 as W, HEAD_EXTRACT_TOKEN_BUDGET as Wn, FIXED_PROTOCOL_VALUE_67 as Wt, FIXED_EXTERNAL_VALUE_8 as X, LIGHTWEIGHT_RERANK_PENALTY as Xn, FIXED_PROTOCOL_VALUE_76 as Xt, FIXED_EXTERNAL_VALUE_62 as Y, LIGHTWEIGHT_FUSION_WEIGHT as Yn, FIXED_PROTOCOL_VALUE_75 as Yt, FIXED_EXTERNAL_VALUE_9 as Z, MAINTENANCE_TICK_MS as Zn, FIXED_PROTOCOL_VALUE_77 as Zt, readRemOperationalConfig as _, BACKUP_MIN_FREE_DISK_RATIO as _n, USAGE_EVENT_RETENTION_INTERVAL_MS as _r, FIXED_MEMORY_CHUNKS as _t, REM_MODEL_OUTPUT_TOKEN_CAP as a, PERSISTED_PROVIDER_SYSTEM as an, MMR_LAMBDA as ar, FIXED_IDX_MEMORY_MEMORIES_LANE_PROJECT as at, getDiscoveryPath as b, CHUNKING_VERSION as bn, experimentCandidatePoolOverride as br, FIXED_MEMORY_CHUNKS_AU as bt, REM_SIDECAR_ORIGIN as c, SUPPORTED_LOCALES as cn, PLANNER_STATISTICS_INTERVAL_MS as cr, FIXED_IDX_MEMORY_MEMORIES_PROJECT_FACT_KEY_ACTIVE as ct, getRemChassisJournalPath as d, ADJACENCY_BONUS_PER_PAIR as dn, REM_TRIGGER_CHECK_INTERVAL_MS as dr, FIXED_MEMORY_ACTIVE_TASK_EVIDENCE as dt, FIXED_VEC_MEMORY as en, MAX_CHUNK_FETCH_LIMIT as er, FIXED_IDX_MEMORY_ACTIVE_TASK_EVIDENCE_INSTANCE as et, getRemDiscoveryPath as f, ATOMIC_CAPTURE_OUTPUT_TOKEN_BUDGET as fn, RERANK_BLEND_CROSS as fr, FIXED_MEMORY_ACTIVE_TASK_INSTANCES as ft, readMaintenanceOverrides as g, BACKUP_INTERVAL_MS as gn, TIME_DECAY_FLOOR as gr, FIXED_MEMORY_ACTIVE_TASK_TRANSITIONS as gt, isRemTraceEnabled as h, ATOMIC_EXTRACTION_MAX_INPUT_TOKENS as hn, SNO_OBSERVE_FLUSH_TIMEOUT_MS as hr, FIXED_MEMORY_ACTIVE_TASK_REVISIONS as ht, REM_JOBS_PATH_PREFIX as i, PERSISTED_CONTENT_HASH_V3 as in, MIN_RECALL_TOKEN_BUDGET as ir, FIXED_IDX_MEMORY_MEMORIES_FACT_ID as it, SESSION_STRATEGIES as j, DEFAULT_REFLECTION_SESSION_TTL_MS as jn, FIXED_MEMORY_PROVIDER_AGENT_MAPPINGS as jt, MODEL_CALLS as k, DEFAULT_RECALL_TOKEN_BUDGET as kn, FIXED_MEMORY_MIGRATION_MARKERS as kt, REM_SIDECAR_TOKEN_HEADER as l, isSupportedLocale as ln, RECENCY_WEIGHT as lr, FIXED_IDX_MEMORY_MEMORIES_PROJECT_TIMESTAMP as lt, getRemTraceLogPath as m, ATOMIC_ENRICHMENT_OUTPUT_TOKEN_BUDGET as mn, RETRIEVAL_STORAGE_CHUNK_PROFILE as mr, FIXED_MEMORY_ACTIVE_TASK_MIGRATION_MANIFESTS as mt, MEMORY_USAGE_FLUSH_INTERVAL_MS as n, PERSISTED_CANDIDATE_HASH_V1 as nn, MAX_RECALLED_TODO_TOKENS as nr, FIXED_IDX_MEMORY_MEMORIES_CATEGORY as nt, REM_RUN_PATH as o, embeddingConfigSchema as on, MULTI_HIT_BONUS_CAP as or, FIXED_IDX_MEMORY_MEMORIES_PROJECT as ot, getRemJobJournalPath as p, ATOMIC_CAPTURE_TIMEOUT_MS as pn, RERANK_BLEND_VECTOR as pr, FIXED_MEMORY_ACTIVE_TASK_MIGRATION_EVIDENCE as pt, FIXED_EXTERNAL_VALUE_57 as q, INTRA_MEMORY_COSINE_THRESHOLD as qn, FIXED_PROTOCOL_VALUE_73 as qt, REM_CORRELATION_ID_HEADER as r, PERSISTED_CONTENT_HASH_V1 as rn, MEMORY_SHUTDOWN_TIMEOUT_MS as rr, FIXED_IDX_MEMORY_MEMORIES_CONTENT_HASH as rt, REM_SIDECAR_HOST as s, llmRoutingConfigSchema as sn, MULTI_HIT_BONUS_PER_HIT as sr, FIXED_IDX_MEMORY_MEMORIES_PROJECT_CONTENT_HASH as st, HEALTH_PATH as t, FIXED_VEC_MEMORY_CHUNKS as tn, MAX_LIST_LIMIT as tr, FIXED_IDX_MEMORY_ACTIVE_TASK_INSTANCES_PROJECTION as tt, REM_SOURCE as u, ADJACENCY_BONUS_CAP as un, REFLECTION_SLICE_CACHE_TTL_MS as ur, FIXED_MEMORY as ut, readRemTestHoldMs as v, BONUS_TOTAL_INVARIANT as vn, USAGE_OUTBOX_INTERVAL_MS as vr, FIXED_MEMORY_CHUNKS_AD as vt, getSnoStationMemStateDir as w, CHUNK_TARGET_TOKENS as wn, LOCAL_EMBEDDING_CACHE_DIR_DEFAULT as wr, FIXED_MEMORY_CHUNKS_MEM_IDX as wt, getPrincipal as x, CHUNK_MAX_TOKENS as xn, experimentMmrDisabled as xr, FIXED_MEMORY_CHUNKS_FTS as xt, SettingsUnavailableError as y, CACHE_TTL_MS as yn, VECTOR_DIMENSION_DEFAULT as yr, FIXED_MEMORY_CHUNKS_AI as yt, sessionMemoryConfigSchema as z, EVAL_QA_TRACES_FILENAME as zn, FIXED_MEMORY_UNPLACED_CANDIDATES as zt };