@snoai/memory 1.2.13 → 1.5.0

package/dist/{config-D_KOwEyg.js → config-DWeuetYo.js}

@@ -1,8 +1,12 @@
 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 { closeSync, createReadStream, createWriteStream, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
+import { homedir, userInfo } from "node:os";
 import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+import http from "node:http";
+import https from "node:https";
+import { pipeline } from "node:stream/promises";
 import { LRUCache } from "lru-cache";
 import { isLowercaseCanonicalUUIDv7 } from "@snoai/common-core";
 import { z } from "zod";
@@ -94,13 +98,552 @@ const LOCAL_EMBEDDING_SESSION_OPTIONS_DEFAULT = {
 */
 const LOCAL_EMBEDDING_CACHE_DIR_DEFAULT = join(CONSTANTS_DIR, "..", ".cache", "models");
 /**
+* Downloads a model's files into <cacheDir>/<model>/<revision>/, the one place the loaders read a model from.
+*
+* A revision directory is complete when its marker names the same revision and file hashes and every file has its
+* expected size; the marker is written last, so an interrupted download is never mistaken for a complete one. One process
+* downloads a directory at a time (an O_EXCL lock with a heartbeat; a dead holder's lock is broken at once).
+*/
+const log$3 = createLogger("embedder:downloader");
+const HUB = "https://huggingface.co/";
+const HUB_HOSTS = /* @__PURE__ */ new Set(["huggingface.co", "hf.co"]);
+const MARKER = ".complete";
+const MAX_REDIRECTS = 5;
+/** A connection that sends nothing for this long is dropped (Node's own limit is five minutes). */
+const STALL_MS = 3e4;
+/** Tries per file; network errors, stalls, 408, 429 and 5xx wait 1, 2, 4, 8 s (or the server's Retry-After). */
+const ATTEMPTS = 5;
+const RETRY_AFTER_CAP_MS = 6e4;
+const LOCK_HEARTBEAT_MS = 5e3;
+const LOCK_POLL_MS = 2e3;
+/** A lock not touched for this long belongs to a holder that hung or died. */
+const LOCK_STALE_MS = 9e5;
+function modelDir(cacheDir, spec) {
+	return join(resolve(cacheDir), spec.id, revisionDirName(spec.revision));
+}
+/** One directory level per revision, so a ref such as `refs/pr/1` is not nested (and not mistaken for an older copy). */
+function revisionDirName(revision) {
+	return revision.replaceAll("/", "--");
+}
+/** Complete: the marker names this revision and the same hashes, and every file has its expected size. */
+function isDownloaded(cacheDir, spec) {
+	const dir = modelDir(cacheDir, spec);
+	try {
+		const marker = JSON.parse(readFileSync(join(dir, MARKER), "utf8"));
+		if (marker.revision !== spec.revision || marker.verify === true) return false;
+		const recorded = new Map((readMarkerFiles(dir) ?? []).map((file) => [file.path, file]));
+		return spec.files.every((file) => statSync(join(dir, file.path), { throwIfNoEntry: false })?.size === file.size && sameIdentity(file, recorded.get(file.path)));
+	} catch {
+		return false;
+	}
+}
+function sameIdentity(file, recorded) {
+	return (!file.sha256 || recorded?.sha256 === file.sha256) && (!file.oid || recorded?.oid === file.oid);
+}
+/**
+* For a loader that could not open the model: marks the download for checking, so the next start checks every file
+* again and fetches any that differ (a file kept despite a SHA-256 mismatch, a copy that went bad on disk). The marker
+* keeps its file list for offline use. Once per process: a load that keeps failing for another reason (memory, an
+* unsupported op) does not re-hash the files each time.
+*/
+function forgetDownload(cacheDir, spec) {
+	const dir = modelDir(cacheDir, spec);
+	if (forgotten.has(dir)) return;
+	forgotten.add(dir);
+	try {
+		const marker = JSON.parse(readFileSync(join(dir, MARKER), "utf8"));
+		writeFileSync(join(dir, MARKER), JSON.stringify({
+			...marker,
+			verify: true
+		}));
+	} catch {}
+}
+const forgotten = /* @__PURE__ */ new Set();
+const downloads = /* @__PURE__ */ new Map();
+/** Makes the model's revision directory complete and returns it. */
+function downloadModel(spec, options) {
+	const dir = modelDir(options.cacheDir, spec);
+	let download = downloads.get(dir);
+	if (!download) {
+		download = fetchModel(spec, options, dir).finally(() => downloads.delete(dir));
+		downloads.set(dir, download);
+	}
+	return download;
+}
+async function fetchModel(spec, options, dir) {
+	if (isDownloaded(options.cacheDir, spec)) return dir;
+	const lock = `${dir}.lock`;
+	await acquireLock(lock);
+	const heartbeat = setInterval(() => touch(lock), LOCK_HEARTBEAT_MS);
+	try {
+		if (isDownloaded(options.cacheDir, spec)) return dir;
+		const started = performance.now();
+		const host = hostOf(options.mirror);
+		log$3.info("model download started", {
+			model: spec.id,
+			revision: spec.revision,
+			cache_dir: dir
+		}, {
+			event_name: "embedder.downloader.started",
+			file: "packages/embedder/src/downloader.ts",
+			function: "fetchModel",
+			site_id: "embedder.downloader.started"
+		});
+		adoptFlatFiles(spec, options.cacheDir, dir);
+		const recorded = new Map((readMarkerFiles(dir) ?? []).map((file) => [file.path, file]));
+		for (const file of spec.files) {
+			const target = join(dir, file.path);
+			if (statSync(target, { throwIfNoEntry: false })?.size === file.size && (!file.oid || recorded.get(file.path)?.oid === file.oid) && (options.offline || (await hashCheck(target, file)).ok)) continue;
+			if (options.offline) throw new Error(`${spec.id}@${spec.revision.slice(0, 12)}: ${file.path} is not in ${dir} and downloads are off`);
+			await fetchFile(spec, `${host}${spec.id}/resolve/${encodeURIComponent(spec.revision)}/${file.path}`, target, file);
+		}
+		writeFileSync(join(dir, MARKER), JSON.stringify({
+			model: spec.id,
+			revision: spec.revision,
+			files: spec.files,
+			completedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}));
+		removeOlderCopies(spec, options.cacheDir);
+		log$3.info("model download complete", {
+			model: spec.id,
+			revision: spec.revision,
+			duration_ms: Math.round(performance.now() - started)
+		}, {
+			event_name: "embedder.downloader.complete",
+			file: "packages/embedder/src/downloader.ts",
+			function: "fetchModel",
+			site_id: "embedder.downloader.complete"
+		});
+		return dir;
+	} finally {
+		clearInterval(heartbeat);
+		rmSync(lock, { force: true });
+	}
+}
+/**
+* Releases before the revision directories kept one copy at <cacheDir>/<model>/<file>: a file of the expected size
+* there moves into the revision directory instead of being fetched again.
+*/
+function adoptFlatFiles(spec, cacheDir, dir) {
+	for (const file of spec.files) {
+		const flat = join(resolve(cacheDir), spec.id, file.path);
+		const target = join(dir, file.path);
+		if (statSync(target, { throwIfNoEntry: false })?.size === file.size) continue;
+		if (statSync(flat, { throwIfNoEntry: false })?.size !== file.size) continue;
+		mkdirSync(dirname(target), { recursive: true });
+		renameSync(flat, target);
+	}
+}
+/**
+* Everything else under <cacheDir>/<model>/ is an older copy, except another revision's complete download, which an
+* install of another version sharing this cache may still load; a copy that cannot be removed only costs disk.
+*/
+function removeOlderCopies(spec, cacheDir) {
+	const root = join(resolve(cacheDir), spec.id);
+	const keep = /* @__PURE__ */ new Set([revisionDirName(spec.revision), `${revisionDirName(spec.revision)}.lock`]);
+	const downloading = (entry) => !lockIsStale(join(root, entry.endsWith(".lock") ? entry : `${entry}.lock`));
+	const complete = (entry) => statSync(join(root, entry, MARKER), { throwIfNoEntry: false }) !== void 0;
+	const older = readdirSync(root).filter((entry) => !keep.has(entry) && !downloading(entry) && !complete(entry)).map((entry) => join(root, entry));
+	older.push(join(resolve(cacheDir), ".download-complete"));
+	for (const path of older) try {
+		rmSync(path, {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		log$3.warn("older model copy not removed", {
+			path,
+			error
+		}, {
+			event_name: "embedder.downloader.cleanup_failed",
+			file: "packages/embedder/src/downloader.ts",
+			function: "removeOlderCopies",
+			site_id: "embedder.downloader.cleanup_failed"
+		});
+	}
+}
+const DTYPE_SUFFIX = {
+	fp32: "",
+	fp16: "_fp16",
+	int8: "_int8",
+	uint8: "_uint8",
+	q8: "_quantized",
+	q4: "_q4",
+	q4f16: "_q4f16",
+	bnb4: "_bnb4"
+};
+const LOADER_FILES = /* @__PURE__ */ new Set([
+	"config.json",
+	"tokenizer.json",
+	"tokenizer_config.json",
+	"special_tokens_map.json"
+]);
+/**
+* The files transformers.js loads for a model that is not pinned in code, as the hub lists them at `revision`;
+* offline, as the marker of the last complete download lists them.
+*/
+async function hubModelSpec(id, revision, dtype, options) {
+	const dir = modelDir(options.cacheDir, {
+		id,
+		revision
+	});
+	if (options.offline) {
+		const files = readMarkerFiles(dir);
+		if (!files) throw new Error(`${id}@${revision} is not in ${dir} and downloads are off`);
+		return {
+			id,
+			revision,
+			files
+		};
+	}
+	const weights = `onnx/model${DTYPE_SUFFIX[dtype] ?? ""}.onnx`;
+	const url = `${hostOf(options.mirror)}api/models/${id}/tree/${encodeURIComponent(revision)}?recursive=true`;
+	const cached = readMarkerFiles(dir);
+	let tree;
+	try {
+		tree = cached ? await getText(url) : await withRetries(`${id} file list`, () => getText(url));
+	} catch (error) {
+		if (!cached) throw error;
+		log$3.warn("hub file list unavailable; using the copy on disk", {
+			model: id,
+			revision,
+			error
+		}, {
+			event_name: "embedder.downloader.hub_unavailable",
+			file: "packages/embedder/src/downloader.ts",
+			function: "hubModelSpec",
+			site_id: "embedder.downloader.hub_unavailable"
+		});
+		return {
+			id,
+			revision,
+			files: cached
+		};
+	}
+	const files = parseTree(tree).filter((file) => LOADER_FILES.has(file.path) || file.path === weights || file.path.startsWith(`${weights}_data`));
+	if (!files.some((file) => file.path === weights)) throw new Error(`${id}@${revision} has no ${weights}`);
+	return {
+		id,
+		revision,
+		files
+	};
+}
+function readMarkerFiles(dir) {
+	try {
+		const marker = JSON.parse(readFileSync(join(dir, MARKER), "utf8"));
+		return Array.isArray(marker.files) ? parseTree(marker.files.map((file) => ({
+			type: "file",
+			...file
+		}))) : void 0;
+	} catch {
+		return;
+	}
+}
+/** The hub's tree listing: [{ type, path, size, lfs?: { oid } }]; anything else is not a file it can serve. */
+function parseTree(raw) {
+	const entries = typeof raw === "string" ? JSON.parse(raw) : raw;
+	if (!Array.isArray(entries)) throw new Error("the hub's file list is not a list");
+	return entries.flatMap((entry) => {
+		if (typeof entry !== "object" || entry === null) return [];
+		const { type, path, size, lfs, sha256, oid } = entry;
+		if (type !== "file" || typeof path !== "string" || typeof size !== "number") return [];
+		const hash = typeof sha256 === "string" ? sha256 : typeof lfs?.oid === "string" ? lfs.oid : void 0;
+		return [{
+			path,
+			size,
+			...hash ? { sha256: hash } : {},
+			...typeof oid === "string" ? { oid } : {}
+		}];
+	});
+}
+function hostOf(mirror) {
+	const host = mirror?.trim() || HUB;
+	return host.endsWith("/") ? host : `${host}/`;
+}
+async function fetchFile(spec, url, target, file) {
+	mkdirSync(dirname(target), { recursive: true });
+	const part = `${target}.part`;
+	let mismatches = 0;
+	return withRetries(`${spec.id} ${file.path}`, async () => {
+		if ((statSync(part, { throwIfNoEntry: false })?.size ?? 0) < file.size) await get(url, part);
+		const size = statSync(part).size;
+		if (size > file.size) rmSync(part, { force: true });
+		if (size !== file.size) throw new Error(`got ${size} bytes, expected ${file.size} (${url})`);
+		if (!(await hashCheck(part, file)).ok && ++mismatches === 1) {
+			rmSync(part, { force: true });
+			throw new Error(`content does not match its SHA-256 (${url})`);
+		}
+		renameSync(part, target);
+	});
+}
+/**
+* Whether a file has its pinned SHA-256, and its actual hash. The check never blocks the model: a second fresh
+* download that still differs is kept with an error in the log, and a check that fails to run counts as a match.
+*/
+async function hashCheck(path, file) {
+	if (!file.sha256) return { ok: true };
+	try {
+		const hash = createHash("sha256");
+		await pipeline(createReadStream(path), hash);
+		const actual = hash.digest("hex");
+		if (actual === file.sha256) return {
+			ok: true,
+			actual
+		};
+		log$3.error("model file SHA-256 differs", {
+			path: file.path,
+			expected_sha256: file.sha256,
+			actual_sha256: actual
+		}, {
+			event_name: "embedder.downloader.sha256_mismatch",
+			file: "packages/embedder/src/downloader.ts",
+			function: "hashCheck",
+			site_id: "embedder.downloader.sha256_mismatch"
+		});
+		return {
+			ok: false,
+			actual
+		};
+	} catch (error) {
+		log$3.warn("model file SHA-256 not checked", {
+			path: file.path,
+			error
+		}, {
+			event_name: "embedder.downloader.sha256_unchecked",
+			file: "packages/embedder/src/downloader.ts",
+			function: "hashCheck",
+			site_id: "embedder.downloader.sha256_unchecked"
+		});
+		return { ok: true };
+	}
+}
+/** Runs `attemptOnce` until it succeeds, another try cannot help, or ATTEMPTS run out; the error names `label`. */
+async function withRetries(label, attemptOnce) {
+	for (let attempt = 1;; attempt += 1) try {
+		return await attemptOnce();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		const delay = attempt < ATTEMPTS ? retryDelay(error, attempt) : void 0;
+		if (delay === void 0) throw new Error(`${label}: ${message} after ${attempt} attempt${attempt === 1 ? "" : "s"}`, { cause: error });
+		log$3.warn("model download failed; retrying", {
+			download_label: label,
+			attempt,
+			delay_ms: delay,
+			error
+		}, {
+			event_name: "embedder.downloader.retry",
+			file: "packages/embedder/src/downloader.ts",
+			function: "withRetries",
+			site_id: "embedder.downloader.retry"
+		});
+		await new Promise((resolveWait) => setTimeout(resolveWait, delay));
+	}
+}
+var HttpError = class extends Error {
+	status;
+	retryAfterMs;
+	constructor(status, retryAfterMs, url) {
+		super(`HTTP ${status} (${url})`);
+		this.status = status;
+		this.retryAfterMs = retryAfterMs;
+	}
+};
+/** Milliseconds before the next try, or undefined when another try cannot help (404, 401, 403 and other 4xx). */
+function retryDelay(error, attempt) {
+	if (error instanceof HttpError) {
+		if (error.status !== 408 && error.status !== 429 && error.status < 500) return void 0;
+		if (error.retryAfterMs !== void 0) return Math.min(error.retryAfterMs, RETRY_AFTER_CAP_MS);
+	}
+	return 1e3 * 2 ** (attempt - 1);
+}
+/** Retry-After in seconds or as an HTTP date. */
+function retryAfterMs(header) {
+	if (!header) return void 0;
+	const seconds = Number(header);
+	const ms = Number.isFinite(seconds) ? seconds * 1e3 : Date.parse(header) - Date.now();
+	return Number.isFinite(ms) ? Math.max(0, ms) : void 0;
+}
+/** The response to `url` after redirects. A socket silent for STALL_MS errors the request and its response. */
+function open(url, headers, redirects = 0) {
+	return new Promise((resolvePromise, reject) => {
+		const client = url.startsWith("https:") ? https : http;
+		const agent = new client.Agent({ proxyEnv: process.env });
+		const token = HUB_HOSTS.has(new URL(url).hostname) ? process.env["HF_TOKEN"] ?? process.env["HF_ACCESS_TOKEN"] : void 0;
+		const auth = token ? { authorization: `Bearer ${token}` } : {};
+		const request = client.get(url, {
+			agent,
+			headers: {
+				"user-agent": "sno-station",
+				...auth,
+				...headers
+			}
+		}, (response) => {
+			const location = response.headers.location;
+			const status = response.statusCode ?? 0;
+			if (status < 300 || status >= 400 || !location) return resolvePromise(response);
+			response.resume();
+			if (redirects >= MAX_REDIRECTS) return reject(/* @__PURE__ */ new Error(`too many redirects (${url})`));
+			open(new URL(location, url).toString(), headers, redirects + 1).then(resolvePromise, reject);
+		});
+		request.setTimeout(STALL_MS, () => request.destroy(/* @__PURE__ */ new Error(`no data for ${STALL_MS / 1e3} s (${url})`)));
+		request.on("error", reject);
+	});
+}
+/** Streams one URL into `part`, resuming after the bytes already there. */
+async function get(url, part) {
+	const start = statSync(part, { throwIfNoEntry: false })?.size ?? 0;
+	const response = await open(url, start > 0 ? { range: `bytes=${start}-` } : {});
+	const status = response.statusCode ?? 0;
+	const resumed = status === 206 && response.headers["content-range"]?.startsWith(`bytes ${start}-`) === true;
+	if (status === 416 || status === 206 && !resumed) {
+		response.resume();
+		rmSync(part, { force: true });
+		throw new Error(`HTTP ${status}: the host did not resume at byte ${start} (${url})`);
+	}
+	if (status !== 200 && status !== 206) {
+		response.resume();
+		throw new HttpError(status, retryAfterMs(response.headers["retry-after"]), url);
+	}
+	await pipeline(response, createWriteStream(part, { flags: resumed ? "a" : "w" }));
+}
+async function getText(url) {
+	const response = await open(url, { accept: "application/json" });
+	if (response.statusCode !== 200) {
+		response.resume();
+		throw new HttpError(response.statusCode ?? 0, retryAfterMs(response.headers["retry-after"]), url);
+	}
+	let text = "";
+	for await (const chunk of response) text += String(chunk);
+	return text;
+}
+function touch(lock) {
+	try {
+		const now = /* @__PURE__ */ new Date();
+		utimesSync(lock, now, now);
+	} catch {}
+}
+function tryLock(lock) {
+	mkdirSync(dirname(lock), { recursive: true });
+	try {
+		const fd = openSync(lock, "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 lockIsStale(lock) {
+	try {
+		if (Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS) return true;
+		const pid = Number.parseInt(readFileSync(lock, "utf8").split("\n")[0] ?? "", 10);
+		if (!Number.isInteger(pid) || pid <= 0) return false;
+		process.kill(pid, 0);
+		return false;
+	} catch (error) {
+		return !(error instanceof Error && "code" in error && error.code === "EPERM");
+	}
+}
+/** Waits while a live holder keeps its lock fresh; breaks the lock of a holder that died or hung. */
+async function acquireLock(lock) {
+	while (!tryLock(lock)) {
+		if (lockIsStale(lock)) {
+			try {
+				unlinkSync(lock);
+			} catch {}
+			continue;
+		}
+		await new Promise((resolveWait) => setTimeout(resolveWait, LOCK_POLL_MS));
+	}
+}
+/**
+* model-download.ts — the bundled embedding model's files at its pinned revision, fetched through the shared
+* downloader. 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");
+const DTYPE_SIZES = {
+	q4: "~400MB",
+	q8: "~639MB",
+	fp16: "~1.2GB",
+	fp32: "~639MB"
+};
+const TOKENIZER_FILES = [
+	{
+		path: "config.json",
+		size: 1651,
+		sha256: "c851a73845113421a2dd85b34446371635844b3875859794fb0d5fc9aee9948d"
+	},
+	{
+		path: "tokenizer.json",
+		size: 11423016,
+		sha256: "db86c3db621fcbcb43e5dd8981d46a9b30b715a41ce8994a9420ec5c8c3797d3"
+	},
+	{
+		path: "tokenizer_config.json",
+		size: 768,
+		sha256: "62b1e4690e44d8c7bec7f22f228331db2d9886160ed7dc4b2068ca24af87d68a"
+	}
+];
+/** The weights for each dtype at the pinned revision; the repository ships one int8 file under both names. */
+const WEIGHTS = {
+	q8: {
+		path: "onnx/model_quantized.onnx",
+		size: 602401737,
+		sha256: "b514c342c20aec2431ea213bde1a03083e117ac3b6e77ba6eee57cac8b79cd29"
+	},
+	fp32: {
+		path: "onnx/model.onnx",
+		size: 602401737,
+		sha256: "b514c342c20aec2431ea213bde1a03083e117ac3b6e77ba6eee57cac8b79cd29"
+	}
+};
+/** The bundled embedding model's files at its pinned revision for one dtype. */
+function embeddingModelSpec(dtype = "q8") {
+	const weights = WEIGHTS[dtype];
+	if (!weights) throw new Error(`${LOCAL_EMBEDDING_MODEL} has no ${dtype} file at revision ${LOCAL_EMBEDDING_MODEL_REVISION}; use q8 or fp32`);
+	return {
+		id: LOCAL_EMBEDDING_MODEL,
+		revision: LOCAL_EMBEDDING_MODEL_REVISION,
+		files: [...TOKENIZER_FILES, weights]
+	};
+}
+function getDtypeDisplaySize(dtype) {
+	return DTYPE_SIZES[dtype] ?? "unknown size";
+}
+/** Downloads the bundled embedding model into cacheDir unless it is already complete there. */
+async function ensureModelDownloaded(opts) {
+	const cacheDir = opts?.cacheDir ?? LOCAL_EMBEDDING_CACHE_DIR_DEFAULT;
+	const dtype = opts?.dtype ?? "q8";
+	const spec = embeddingModelSpec(dtype);
+	const fetching = !opts?.offline && !isDownloaded(cacheDir, spec);
+	const started = performance.now();
+	if (fetching) process.stderr.write(`\nPreparing the local embedding model (a first run downloads ${getDtypeDisplaySize(dtype)})...\n`);
+	await downloadModel(spec, {
+		cacheDir,
+		offline: opts?.offline,
+		mirror: opts?.mirror
+	});
+	if (fetching) process.stderr.write(`  Ready in ${Math.round((performance.now() - started) / 1e3)}s: ${cacheDir}\n`);
+	log$2.info("local embedding model ready", {
+		cacheDir,
+		dtype
+	}, {
+		event_name: "embedder.model.download.complete",
+		file: "packages/embedder/src/model-download.ts",
+		function: "ensureModelDownloaded",
+		site_id: "embedder.model.download.complete"
+	});
+}
+/**
 * 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$1 = createLogger("embedder:local");
 let sharedExtractor;
-let sharedLoading;
+let sharedLoading$1;
 let sharedRefCount = 0;
 let sharedPipelineKey;
 function buildSessionOptions(options) {
@@ -167,7 +710,7 @@ var LocalEmbedProvider = class LocalEmbedProvider {
 	static resetStaticState() {
 		LocalEmbedProvider.configuredCacheDir = void 0;
 		sharedExtractor = void 0;
-		sharedLoading = void 0;
+		sharedLoading$1 = void 0;
 		sharedRefCount = 0;
 		sharedPipelineKey = void 0;
 	}
@@ -179,7 +722,7 @@ var LocalEmbedProvider = class LocalEmbedProvider {
 		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.revision = config?.revision ?? (this.modelId === "tss-deposium/pplx-embed-v1-0.6b-onnx-int8-standard" ? "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.`);
@@ -200,21 +743,21 @@ var LocalEmbedProvider = class LocalEmbedProvider {
 		if (this._disposed) throw new Error("LocalEmbedProvider has been disposed");
 		this.assertCompatibleSharedPipeline();
 		if (sharedExtractor) return sharedExtractor;
-		if (sharedLoading) {
-			const extractor = await sharedLoading;
+		if (sharedLoading$1) {
+			const extractor = await sharedLoading$1;
 			if (this._disposed) throw new Error("LocalEmbedProvider has been disposed");
 			if (!sharedExtractor) sharedExtractor = extractor;
 			return extractor;
 		}
 		sharedPipelineKey = this.pipelineKey;
-		sharedLoading = this.initPipeline();
+		sharedLoading$1 = this.initPipeline();
 		try {
-			const extractor = await sharedLoading;
+			const extractor = await sharedLoading$1;
 			sharedExtractor = extractor;
 			if (this._disposed) throw new Error("LocalEmbedProvider has been disposed");
 			return extractor;
 		} finally {
-			sharedLoading = void 0;
+			sharedLoading$1 = void 0;
 			if (!sharedExtractor && sharedRefCount === 0) sharedPipelineKey = void 0;
 		}
 	}
@@ -225,13 +768,7 @@ var LocalEmbedProvider = class LocalEmbedProvider {
 	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}/`;
+		const { pipeline } = await import("@huggingface/transformers");
 		log$1$1.info("loading ONNX model", {
 			model: this.modelId,
 			cacheDir: this.cacheDir,
@@ -248,10 +785,20 @@ var LocalEmbedProvider = class LocalEmbedProvider {
 		const t0 = performance.now();
 		try {
 			const sessionOptions = buildSessionOptions(this.sessionOptions);
-			const extractor = await pipeline("feature-extraction", this.modelId, {
+			const download = {
+				cacheDir: this.cacheDir,
+				offline: this.offline,
+				mirror: this.mirror
+			};
+			const spec = this.modelId === "tss-deposium/pplx-embed-v1-0.6b-onnx-int8-standard" && this.revision === "a18fdffe7480e6ea5643acb7757142b33838817a" ? embeddingModelSpec(this.dtype) : await hubModelSpec(this.modelId, this.revision ?? "main", this.dtype, download);
+			const extractor = await pipeline("feature-extraction", await downloadModel(spec, download), {
 				dtype: this.dtype,
 				device: "cpu",
-				session_options: sessionOptions
+				session_options: sessionOptions,
+				local_files_only: true
+			}).catch((error) => {
+				forgetDownload(this.cacheDir, spec);
+				throw error;
 			});
 			const durationMs = Math.round(performance.now() - t0);
 			log$1$1.info("ONNX model loaded", {
@@ -335,7 +882,7 @@ var LocalEmbedProvider = class LocalEmbedProvider {
 		this._disposed = true;
 		sharedRefCount = Math.max(0, sharedRefCount - 1);
 		if (sharedRefCount > 0) return;
-		const pending = sharedLoading;
+		const pending = sharedLoading$1;
 		if (pending) {
 			const extractor = await pending.catch(() => void 0);
 			if (sharedRefCount > 0) {
@@ -349,7 +896,7 @@ var LocalEmbedProvider = class LocalEmbedProvider {
 			await sharedExtractor.dispose();
 			sharedExtractor = void 0;
 		}
-		if (sharedLoading === void 0) sharedPipelineKey = void 0;
+		if (sharedLoading$1 === void 0) sharedPipelineKey = void 0;
 	}
 	async warmup() {
 		await this.embed("warmup");
@@ -502,397 +1049,180 @@ var CachedEmbeddingProvider = class {
 	}
 };
 /**
-* model-download.ts — Shared ONNX model download utility.
+* Local cross-encoder that scores how well each text answers a query, on the CPU.
 *
-* 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.
+* The model reads Chinese and English (and other languages). It downloads through the shared downloader and loads in
+* the background on first use: until it is ready, or if it cannot load (offline with nothing cached, say), `score`
+* answers undefined and the caller keeps its own order.
 */
-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);
-}
+const log$4 = createLogger("embedder:local-reranker");
 /**
-* 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.
+* Horizon-Labs/multilingual-reranker-small (Apache-2.0) in an 8-bit ONNX file Sno published; pinned revision and
+* file hashes, the same supply-chain rule as the embedding model.
 */
-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;
-			}
+const LOCAL_RERANK_MODEL = {
+	id: "sno-lab/multilingual-reranker-small-int8",
+	revision: "ce76796ae42628f54f501271aeac16df8ecc8a6f",
+	files: [
+		{
+			path: "config.json",
+			size: 1995,
+			sha256: "e9fd043628cd796a364020164a7a6ca78d29b0ec5cf135464489f54110f4b1da"
+		},
+		{
+			path: "special_tokens_map.json",
+			size: 636,
+			sha256: "baec30ea10906f16adb8c18af7a34023002c1746542612b8b41c9f09e1351351"
+		},
+		{
+			path: "tokenizer.json",
+			size: 34363439,
+			sha256: "7925f638b5444897efe3b4608eed56c1652f0ed39c2662c8302de1bc264c6088"
+		},
+		{
+			path: "tokenizer_config.json",
+			size: 46440,
+			sha256: "ea349495764b24570b4560fe2e4a557e5c0a47e6bce782c2409b1d6445cf8633"
+		},
+		{
+			path: "onnx/model_quantized.onnx",
+			size: 171363319,
+			sha256: "d2b03e74b3ea60ca486a118b4e2ab6bc96b173c64224a689d653e135753d89ad"
 		}
-		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;
+	]
+};
+const SCORE_BATCH = 5;
+const LOAD_RETRY_MS = 6e5;
+let shared;
+let sharedLoading = false;
+let sharedUsers = 0;
+let sharedFailedAt;
+let releases = 0;
+const scoring = /* @__PURE__ */ new Set();
+var LocalReranker = class {
+	options;
+	disposed = false;
+	constructor(options) {
+		this.options = options;
+		sharedUsers += 1;
 	}
-}
-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 {}
+	/**
+	* Raw relevance logits, one per text (higher is more relevant), or undefined while the model is not loaded.
+	* The first call starts the load and does not wait for it.
+	*/
+	async score(query, texts, signal) {
+		if (texts.length === 0) return [];
+		const loaded = shared;
+		if (!loaded) {
+			if (sharedFailedAt !== void 0 && Date.now() - sharedFailedAt >= LOAD_RETRY_MS) {
+				sharedFailedAt = void 0;
+				sharedLoading = false;
+			}
+			if (!sharedLoading) {
+				sharedLoading = true;
+				this.load();
+			}
+			return;
 		}
-	} 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;
+		const run = this.run(loaded, query, texts, signal);
+		scoring.add(run);
 		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;
+			return await run;
+		} finally {
+			scoring.delete(run);
 		}
-		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;
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		sharedUsers = Math.max(0, sharedUsers - 1);
+		if (sharedUsers > 0) return;
+		const loaded = shared;
+		releases += 1;
+		shared = void 0;
+		sharedLoading = false;
+		sharedFailedAt = void 0;
+		await Promise.allSettled(scoring);
+		await loaded?.dispose();
 	}
-	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"
+	async run(loaded, query, texts, signal) {
+		const order = texts.map((_, index) => index).sort((a, b) => (texts[a]?.length ?? 0) - (texts[b]?.length ?? 0));
+		const scores = new Array(texts.length).fill(0);
+		for (let start = 0; start < order.length; start += SCORE_BATCH) {
+			if (signal?.aborted) return void 0;
+			const run = order.slice(start, start + SCORE_BATCH);
+			const inputs = loaded.tokenizer(new Array(run.length).fill(query), {
+				text_pair: run.map((index) => texts[index] ?? ""),
+				padding: true,
+				truncation: true,
+				max_length: 512
 			});
-			return;
+			const { logits } = await loaded.model(inputs);
+			for (const [i, index] of run.entries()) scores[index] = Number(logits.data[i] ?? 0);
 		}
-		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)}`);
+		return scores;
 	}
-	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();
+	async load() {
+		const release = releases;
+		const started = 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`);
+			const { AutoModelForSequenceClassification, AutoTokenizer } = await import("@huggingface/transformers");
+			const dir = await downloadModel(LOCAL_RERANK_MODEL, this.options);
+			const open = async () => {
+				return {
+					tokenizer: await AutoTokenizer.from_pretrained(dir, { local_files_only: true }),
+					model: await AutoModelForSequenceClassification.from_pretrained(dir, {
+						dtype: "q8",
+						device: "cpu",
+						local_files_only: true,
+						session_options: {
+							...LOCAL_EMBEDDING_SESSION_OPTIONS_DEFAULT,
+							interOpNumThreads: 1,
+							...this.options.intraOpNumThreads ? { intraOpNumThreads: this.options.intraOpNumThreads } : {}
 						}
-					} else if (progress.status === "done" && progress.file) process.stderr.write(`  done ${progress.file}\n`);
+					})
+				};
+			};
+			const { tokenizer, model } = await open().catch((error) => {
+				forgetDownload(this.options.cacheDir, LOCAL_RERANK_MODEL);
+				throw error;
+			});
+			if (release !== releases) {
+				await model.dispose();
+				return;
+			}
+			shared = {
+				tokenizer: (texts, options) => tokenizer(texts, options),
+				model: (inputs) => model(inputs),
+				dispose: async () => {
+					await model.dispose();
 				}
+			};
+			log$4.info("local reranker loaded", {
+				duration_ms: Math.round(performance.now() - started),
+				model: LOCAL_RERANK_MODEL.id
+			}, {
+				event_name: "embedder.local_reranker.loaded",
+				file: "packages/embedder/src/local-reranker.ts",
+				function: "load",
+				site_id: "embedder.local_reranker.loaded"
 			});
-		} finally {
-			env.cacheDir = prevCacheDir;
-			env.allowRemoteModels = prevAllowRemote;
-			env.localModelPath = prevLocalModelPath;
-			env.remoteHost = prevRemoteHost;
-			env.remotePathTemplate = prevRemotePathTemplate;
+			return shared;
+		} catch (error) {
+			log$4.warn("local reranker unavailable; recall keeps its cosine order", {
+				error,
+				offline: this.options.offline === true
+			}, {
+				event_name: "embedder.local_reranker.unavailable",
+				file: "packages/embedder/src/local-reranker.ts",
+				function: "load",
+				site_id: "embedder.local_reranker.unavailable"
+			});
+			sharedFailedAt = Date.now();
+			return;
 		}
-		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
 /**
@@ -906,7 +1236,7 @@ const MEMORY_SHUTDOWN_TIMEOUT_MS = 5e3;
 const DEFAULT_IMPORTANCE = .7;
 /** Default scope for memories without explicit scope */
 const DEFAULT_SCOPE = "global";
-/** Default embedding vector dimension (Voyage AI 1024-d) */
+/** Default embedding vector dimension (the local PPLX embedder outputs 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";
@@ -1015,12 +1345,19 @@ const MMR_LAMBDA = .7;
 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;
+/**
+* Fusion-score weight in local cosine-blend rerank.
+*
+* The fused score keeps a keyword-only hit at its full keyword score, so a memory sharing one word with the query
+* outranks the one that answers it; at 0.7 the local ranking passed that order through almost unchanged. Measured
+* 2026-10-15 on LoCoMo (1,540 questions, the product store and retriever, weights fitted on half the conversations
+* and checked on the other half): the right memory in the first five went from 27% to 68% in English and from 9% to
+* 58% in a Chinese translation at 0.1 / 0.9. A candidate with no stored vector keeps its fused score and would now
+* rank high; none of 27,064 candidates in 299 real local rankings lacked one.
+*/
+const LIGHTWEIGHT_FUSION_WEIGHT = .1;
 /** Cosine-similarity weight in local cosine-blend rerank */
-const LIGHTWEIGHT_COSINE_WEIGHT = .3;
-/** Default rerank model identifier */
-const DEFAULT_RERANK_MODEL = "rerank-2";
+const LIGHTWEIGHT_COSINE_WEIGHT = .9;
 /** Default timeout for rerank API calls in milliseconds */
 const DEFAULT_RERANK_TIMEOUT_MS = 15e3;
 /**
@@ -1477,7 +1814,6 @@ const retrievalConfigSchema = z.object({
 	]).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),
@@ -1504,20 +1840,9 @@ const retrievalConfigSchema = z.object({
 	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. */
+	/** Address of Sno's reranker (the Sno GPU address plus `/rerank`). */
 	rerankEndpoint: z.string().optional(),
-	/** Rerank provider name */
-	rerankProvider: z.enum([
-		"jina",
-		"siliconflow",
-		"pinecone",
-		"voyage",
-		"dashscope",
-		"tei",
-		"sno-gpu",
-		"custom"
-	]).optional(),
-	/** Hard cap on candidates sent per rerank API request (some deployments reject over-limit batches) */
+	/** Cap on candidates sent to Sno's reranker in total */
 	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),
@@ -1525,11 +1850,6 @@ const retrievalConfigSchema = z.object({
 	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 {
@@ -2296,19 +2616,6 @@ const settingsSchema = z.strictObject({
 			"cross-encoder",
 			"none"
 		]),
-		provider: z.enum([
-			"jina",
-			"siliconflow",
-			"pinecone",
-			"voyage",
-			"dashscope",
-			"tei",
-			"sno-gpu",
-			"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)
 	}),
@@ -2401,10 +2708,6 @@ function defaultSettings() {
 		},
 		rerank: {
 			mode: "cross-encoder",
-			provider: "sno-gpu",
-			endpoint: "",
-			model: engine.retrieval.rerankModel,
-			apiKey: "",
 			timeoutMs: engine.retrieval.rerankTimeoutMs,
 			maxCandidates: 64
 		},
@@ -2474,18 +2777,11 @@ function defaultSettings() {
 	};
 }
 /**
-* The "sno-gpu" reranker is Sno's own: its address is the Sno GPU address and its key is the Sno GPU key, and nothing
-* else: a third-party key or address in the rerank settings is never sent to Sno. Only REM Enhanced calls Sno GPU;
-* any other mode, or no key yet, ranks locally, which is the configured strategy, not an error.
+* Recall ranking is local, or Sno's reranker: its address is the Sno GPU address and its key is the Sno GPU key. Only
+* REM Enhanced calls Sno GPU; any other mode, or no key yet, ranks locally, which is the configured strategy, not an error.
 */
 function rerankSettings(settings) {
 	const { rerank, snoGpu } = settings;
-	if (rerank.provider !== "sno-gpu") return {
-		rerank: rerank.mode,
-		provider: rerank.provider,
-		endpoint: rerank.endpoint || void 0,
-		apiKey: rerank.apiKey
-	};
 	let endpoint;
 	try {
 		endpoint = new URL("rerank", snoGpu.baseUrl.endsWith("/") ? snoGpu.baseUrl : `${snoGpu.baseUrl}/`).toString();
@@ -2500,7 +2796,6 @@ function rerankSettings(settings) {
 	const local = rerank.mode !== "cross-encoder" || settings.mode !== "rem-enhanced" || !snoGpu.apiKey || endpoint === void 0;
 	return {
 		rerank: local && rerank.mode === "cross-encoder" ? "lightweight" : rerank.mode,
-		provider: local ? void 0 : rerank.provider,
 		endpoint: local ? void 0 : endpoint,
 		apiKey: local ? "" : snoGpu.apiKey
 	};
@@ -2524,11 +2819,9 @@ function settingsToPluginConfig(settings) {
 		},
 		retrieval: {
 			rerank: sno.rerank,
-			rerankProvider: sno.provider,
 			recallTopK: settings.recall.prompt.limit,
 			minScore: settings.recall.prompt.minScore,
 			rerankEndpoint: sno.endpoint,
-			rerankModel: settings.rerank.model,
 			rerankApiKey: sno.apiKey,
 			rerankTimeoutMs: settings.rerank.timeoutMs,
 			rerankMaxCandidates: settings.rerank.maxCandidates
@@ -2712,4 +3005,4 @@ function readMaintenanceOverrides() {
 	};
 }
 //#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, MEMORY_CANCEL_ON_DISCONNECT_HEADER as Ar, 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, getSnoStationMemStateDir as C, CHUNK_OVERLAP_TOKENS as Cn, CachedEmbeddingProvider as Cr, FIXED_MEMORY_CHUNKS_MEM_FACET_IDX as Ct, settingsToPluginConfig as D, DEFAULT_IMPORTANCE as Dn, LocalEmbedProvider as Dr, FIXED_MEMORY_MEMORIES_FACT_ID_INSERT_GUARD as Dt, defaultSettings 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, MEMORY_SKIN_HEADER as Fr, 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, REM_SIDECAR_TOKEN_HEADER as Ir, 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, memoryMethod as Lr, FIXED_MEMORY_SNO_EXTRACT_PROFILE as Lt, retrievalConfigSchema as M, DEFAULT_RERANK_MODEL as Mn, MEMORY_ERROR_STATUS as Mr, FIXED_MEMORY_PROVIDER_PROJECT_AGENTS as Mt, isObserveAgentId as N, DEFAULT_RERANK_TIMEOUT_MS as Nn, MEMORY_RECONNECT_INTERVAL_MS as Nr, FIXED_MEMORY_PROVIDER_PROJECT_MAPPINGS as Nt, MODEL_CALLS 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, MEMORY_ROUTES as Pr, 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, getSidecarSocketPath as S, CHUNK_MIN_TOKENS as Sn, recallLifecycleSchema as Sr, FIXED_MEMORY_CHUNKS_MEMORY_ID_IDX as St, readSettings 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, readRemTestHoldMs 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, getPrincipal 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, getRemDiscoveryPath 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, getRemJobJournalPath as f, ATOMIC_CAPTURE_OUTPUT_TOKEN_BUDGET as fn, RERANK_BLEND_CROSS as fr, FIXED_MEMORY_ACTIVE_TASK_INSTANCES as ft, readRemOperationalConfig as g, BACKUP_INTERVAL_MS as gn, TIME_DECAY_FLOOR as gr, FIXED_MEMORY_ACTIVE_TASK_TRANSITIONS as gt, readMaintenanceOverrides 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, MEMORY_DEFAULT_SKIN_ID as jr, FIXED_MEMORY_PROVIDER_AGENT_MAPPINGS as jt, MODEL_CALL_WORKLOAD as k, DEFAULT_RECALL_TOKEN_BUDGET as kn, MEMORY_BODY_LIMIT_BYTES as kr, FIXED_MEMORY_MIGRATION_MARKERS as kt, REM_SOURCE as l, isSupportedLocale as ln, RECENCY_WEIGHT as lr, FIXED_IDX_MEMORY_MEMORIES_PROJECT_TIMESTAMP as lt, isRemTraceEnabled 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, getRemTraceLogPath 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, getRemChassisJournalPath as u, ADJACENCY_BONUS_CAP as un, REFLECTION_SLICE_CACHE_TTL_MS as ur, FIXED_MEMORY as ut, SettingsUnavailableError as v, BONUS_TOTAL_INVARIANT as vn, USAGE_OUTBOX_INTERVAL_MS as vr, FIXED_MEMORY_CHUNKS_AD as vt, getStateDir as w, CHUNK_TARGET_TOKENS as wn, LOCAL_EMBEDDING_CACHE_DIR_DEFAULT as wr, FIXED_MEMORY_CHUNKS_MEM_IDX as wt, getSettingsPath as x, CHUNK_MAX_TOKENS as xn, experimentMmrDisabled as xr, FIXED_MEMORY_CHUNKS_FTS as xt, getDiscoveryPath 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 };
+export { FIXED_IDX_MEMORY_ACTIVE_TASK_CURRENT_REVISION as $, MAX_CHUNK_FETCH_LIMIT as $n, FIXED_PROTOCOL_VALUE_79 as $t, modelCallDestination as A, DEFAULT_REFLECTION_ERROR_SCAN_MAX_CHARS as An, MEMORY_CANCEL_ON_DISCONNECT_HEADER as Ar, FIXED_MEMORY_PROFILE_RECOVERY_ENTRIES as At, FIXED_EXTERNAL_VALUE_49 as B, FTS_MERGE_INTERVAL_MS as Bn, FIXED_PROTOCOL_VALUE_63 as Bt, getSnoStationMemStateDir as C, CHUNK_OVERLAP_TOKENS as Cn, LOCAL_EMBEDDING_CACHE_DIR_DEFAULT as Cr, FIXED_MEMORY_CHUNKS_MEM_FACET_IDX as Ct, settingsToPluginConfig as D, DEFAULT_IMPORTANCE as Dn, LocalReranker as Dr, FIXED_MEMORY_MEMORIES_FACT_ID_INSERT_GUARD as Dt, defaultSettings as E, DEFAULT_BM25_WEIGHT as En, LocalEmbedProvider as Er, FIXED_MEMORY_MEMORIES as Et, observeConfigSchema as F, EMBEDDER_DIM as Fn, MEMORY_SKIN_HEADER as Fr, FIXED_MEMORY_SNO_AI_EXTRACT as Ft, FIXED_EXTERNAL_VALUE_55 as G, INTEGRITY_CHECK_INTERVAL_MS as Gn, FIXED_PROTOCOL_VALUE_68 as Gt, FIXED_EXTERNAL_VALUE_52 as H, HEAD_EXTRACT_OVERLAP_DROP_RATIO as Hn, FIXED_PROTOCOL_VALUE_65 as Ht, extractionConfigSchema as I, EMBEDDER_MODEL_DEFAULT as In, REM_SIDECAR_TOKEN_HEADER as Ir, FIXED_MEMORY_SNO_EXTRACT_CHAT as It, FIXED_EXTERNAL_VALUE_58 as J, LIGHTWEIGHT_FUSION_WEIGHT as Jn, FIXED_PROTOCOL_VALUE_74 as Jt, FIXED_EXTERNAL_VALUE_56 as K, INTRA_MEMORY_COSINE_THRESHOLD as Kn, FIXED_PROTOCOL_VALUE_69 as Kt, memoryReflectionConfigSchema as L, EMBEDDER_PROVIDER_DEFAULT as Ln, memoryMethod as Lr, FIXED_MEMORY_SNO_EXTRACT_PROFILE as Lt, retrievalConfigSchema as M, DEFAULT_RERANK_TIMEOUT_MS as Mn, MEMORY_ERROR_STATUS as Mr, FIXED_MEMORY_PROVIDER_PROJECT_AGENTS as Mt, isObserveAgentId as N, DEFAULT_SCOPE as Nn, MEMORY_RECONNECT_INTERVAL_MS as Nr, FIXED_MEMORY_PROVIDER_PROJECT_MAPPINGS as Nt, MODEL_CALLS as O, DEFAULT_RECALL_LIFECYCLE as On, ensureModelDownloaded as Or, FIXED_MEMORY_MEMORIES_FACT_ID_UPDATE_GUARD as Ot, observeAgentId as P, DEFAULT_VECTOR_WEIGHT as Pn, MEMORY_ROUTES as Pr, FIXED_MEMORY_ROW_PATH_PATTERN as Pt, FIXED_IDX_MEMORY as Q, MAX_CANDIDATE_POOL_SIZE as Qn, FIXED_PROTOCOL_VALUE_78 as Qt, selfImprovementConfigSchema as R, EVAL_QA_TRACES_FILENAME as Rn, FIXED_MEMORY_TASK_LIFECYCLE_COMMANDS as Rt, getSidecarSocketPath as S, CHUNK_MIN_TOKENS as Sn, CachedEmbeddingProvider as Sr, FIXED_MEMORY_CHUNKS_MEMORY_ID_IDX as St, readSettings as T, CHUNK_TOKENIZER_MODE as Tn, LOCAL_EMBEDDING_MODEL_REVISION as Tr, FIXED_MEMORY_EXTRACTION_TIMESTAMPS as Tt, FIXED_EXTERNAL_VALUE_53 as U, HEAD_EXTRACT_TOKEN_BUDGET as Un, FIXED_PROTOCOL_VALUE_66 as Ut, FIXED_EXTERNAL_VALUE_51 as V, HEAD_EXTRACT_MIN_CONTENT_TOKENS as Vn, FIXED_PROTOCOL_VALUE_64 as Vt, FIXED_EXTERNAL_VALUE_54 as W, IMPORTANCE_WEIGHT_BASE as Wn, FIXED_PROTOCOL_VALUE_67 as Wt, FIXED_EXTERNAL_VALUE_8 as X, MAINTENANCE_TICK_MS as Xn, FIXED_PROTOCOL_VALUE_76 as Xt, FIXED_EXTERNAL_VALUE_62 as Y, LIGHTWEIGHT_RERANK_PENALTY as Yn, FIXED_PROTOCOL_VALUE_75 as Yt, FIXED_EXTERNAL_VALUE_9 as Z, MAX_AGGREGATION_RESULT_TOKENS as Zn, FIXED_PROTOCOL_VALUE_77 as Zt, readRemTestHoldMs as _, BACKUP_MIN_FREE_DISK_RATIO as _n, USAGE_OUTBOX_INTERVAL_MS as _r, FIXED_MEMORY_CHUNKS as _t, REM_MODEL_OUTPUT_TOKEN_CAP as a, PERSISTED_PROVIDER_SYSTEM as an, MULTI_HIT_BONUS_CAP as ar, FIXED_IDX_MEMORY_MEMORIES_LANE_PROJECT as at, getPrincipal as b, CHUNKING_VERSION as bn, experimentMmrDisabled as br, FIXED_MEMORY_CHUNKS_AU as bt, REM_SIDECAR_ORIGIN as c, SUPPORTED_LOCALES as cn, RECENCY_WEIGHT as cr, FIXED_IDX_MEMORY_MEMORIES_PROJECT_FACT_KEY_ACTIVE as ct, getRemDiscoveryPath as d, ADJACENCY_BONUS_PER_PAIR as dn, RERANK_BLEND_CROSS as dr, FIXED_MEMORY_ACTIVE_TASK_EVIDENCE as dt, FIXED_VEC_MEMORY as en, MAX_LIST_LIMIT as er, FIXED_IDX_MEMORY_ACTIVE_TASK_EVIDENCE_INSTANCE as et, getRemJobJournalPath as f, ATOMIC_CAPTURE_OUTPUT_TOKEN_BUDGET as fn, RERANK_BLEND_VECTOR as fr, FIXED_MEMORY_ACTIVE_TASK_INSTANCES as ft, readRemOperationalConfig as g, BACKUP_INTERVAL_MS as gn, USAGE_EVENT_RETENTION_INTERVAL_MS as gr, FIXED_MEMORY_ACTIVE_TASK_TRANSITIONS as gt, readMaintenanceOverrides as h, ATOMIC_EXTRACTION_MAX_INPUT_TOKENS as hn, TIME_DECAY_FLOOR as hr, FIXED_MEMORY_ACTIVE_TASK_REVISIONS as ht, REM_JOBS_PATH_PREFIX as i, PERSISTED_CONTENT_HASH_V3 as in, MMR_LAMBDA as ir, FIXED_IDX_MEMORY_MEMORIES_FACT_ID as it, SESSION_STRATEGIES as j, DEFAULT_REFLECTION_SESSION_TTL_MS as jn, MEMORY_DEFAULT_SKIN_ID as jr, FIXED_MEMORY_PROVIDER_AGENT_MAPPINGS as jt, MODEL_CALL_WORKLOAD as k, DEFAULT_RECALL_TOKEN_BUDGET as kn, MEMORY_BODY_LIMIT_BYTES as kr, FIXED_MEMORY_MIGRATION_MARKERS as kt, REM_SOURCE as l, isSupportedLocale as ln, REFLECTION_SLICE_CACHE_TTL_MS as lr, FIXED_IDX_MEMORY_MEMORIES_PROJECT_TIMESTAMP as lt, isRemTraceEnabled as m, ATOMIC_ENRICHMENT_OUTPUT_TOKEN_BUDGET as mn, SNO_OBSERVE_FLUSH_TIMEOUT_MS as mr, FIXED_MEMORY_ACTIVE_TASK_MIGRATION_MANIFESTS as mt, MEMORY_USAGE_FLUSH_INTERVAL_MS as n, PERSISTED_CANDIDATE_HASH_V1 as nn, MEMORY_SHUTDOWN_TIMEOUT_MS as nr, FIXED_IDX_MEMORY_MEMORIES_CATEGORY as nt, REM_RUN_PATH as o, embeddingConfigSchema as on, MULTI_HIT_BONUS_PER_HIT as or, FIXED_IDX_MEMORY_MEMORIES_PROJECT as ot, getRemTraceLogPath as p, ATOMIC_CAPTURE_TIMEOUT_MS as pn, RETRIEVAL_STORAGE_CHUNK_PROFILE as pr, FIXED_MEMORY_ACTIVE_TASK_MIGRATION_EVIDENCE as pt, FIXED_EXTERNAL_VALUE_57 as q, LIGHTWEIGHT_COSINE_WEIGHT as qn, FIXED_PROTOCOL_VALUE_73 as qt, REM_CORRELATION_ID_HEADER as r, PERSISTED_CONTENT_HASH_V1 as rn, MIN_RECALL_TOKEN_BUDGET as rr, FIXED_IDX_MEMORY_MEMORIES_CONTENT_HASH as rt, REM_SIDECAR_HOST as s, llmRoutingConfigSchema as sn, PLANNER_STATISTICS_INTERVAL_MS as sr, FIXED_IDX_MEMORY_MEMORIES_PROJECT_CONTENT_HASH as st, HEALTH_PATH as t, FIXED_VEC_MEMORY_CHUNKS as tn, MAX_RECALLED_TODO_TOKENS as tr, FIXED_IDX_MEMORY_ACTIVE_TASK_INSTANCES_PROJECTION as tt, getRemChassisJournalPath as u, ADJACENCY_BONUS_CAP as un, REM_TRIGGER_CHECK_INTERVAL_MS as ur, FIXED_MEMORY as ut, SettingsUnavailableError as v, BONUS_TOTAL_INVARIANT as vn, VECTOR_DIMENSION_DEFAULT as vr, FIXED_MEMORY_CHUNKS_AD as vt, getStateDir as w, CHUNK_TARGET_TOKENS as wn, LOCAL_EMBEDDING_MODEL as wr, FIXED_MEMORY_CHUNKS_MEM_IDX as wt, getSettingsPath as x, CHUNK_MAX_TOKENS as xn, recallLifecycleSchema as xr, FIXED_MEMORY_CHUNKS_FTS as xt, getDiscoveryPath as y, CACHE_TTL_MS as yn, experimentCandidatePoolOverride as yr, FIXED_MEMORY_CHUNKS_AI as yt, sessionMemoryConfigSchema as z, FORGET_QUERY_MIN_SCORE as zn, FIXED_MEMORY_UNPLACED_CANDIDATES as zt };