@snoai/memory 1.2.13 → 1.5.0

package/dist/{retriever-CpyZs2ND.js → retriever-CsBW6MZv.js}

@@ -1,10 +1,9 @@
-import { CHUNKING_VERSION, DEFAULT_BM25_WEIGHT, DEFAULT_RECALL_LIFECYCLE, DEFAULT_RERANK_MODEL, DEFAULT_RERANK_TIMEOUT_MS, DEFAULT_VECTOR_WEIGHT, IMPORTANCE_WEIGHT_BASE, LIGHTWEIGHT_COSINE_WEIGHT, LIGHTWEIGHT_FUSION_WEIGHT, LIGHTWEIGHT_RERANK_PENALTY, MMR_LAMBDA, RECENCY_WEIGHT, RERANK_BLEND_CROSS, RERANK_BLEND_VECTOR, TIME_DECAY_FLOOR, experimentCandidatePoolOverride, experimentMmrDisabled } from "./internal/config/index.js";
+import { CHUNKING_VERSION, DEFAULT_BM25_WEIGHT, DEFAULT_RECALL_LIFECYCLE, DEFAULT_RERANK_TIMEOUT_MS, DEFAULT_VECTOR_WEIGHT, IMPORTANCE_WEIGHT_BASE, LIGHTWEIGHT_COSINE_WEIGHT, LIGHTWEIGHT_FUSION_WEIGHT, LIGHTWEIGHT_RERANK_PENALTY, MMR_LAMBDA, RECENCY_WEIGHT, RERANK_BLEND_CROSS, RERANK_BLEND_VECTOR, TIME_DECAY_FLOOR, experimentCandidatePoolOverride, experimentMmrDisabled } from "./internal/config/index.js";
 import "./internal/engine/shared/types.js";
 import { EmbeddingError, RetrievalError } from "./internal/engine/shared/errors.js";
 import { o as isMemoryExpired, s as parseInsightMetadata } from "./memory-metadata-codec-DL1sbJiN.js";
 import { clamp01 } from "./internal/engine/shared/utils.js";
 import { a as memoryOperationSignal } from "./operation-cancellation-QcwC4mDX.js";
-import { classifyLlmFailure } from "./internal/model/llm-failure.js";
 import { appendQaTrace, computeConfigHash, isTraceEnabled } from "./internal/engine/eval/trace.js";
 import { computeEffectiveHalfLife, parseAccessMetadata } from "./internal/engine/retrieval/access-tracker.js";
 import { createLogger as createLogger$1, currentLogContext, privateLogReference, withLogContext } from "@snoai/utils/logger";
@@ -219,9 +218,7 @@ const DEFAULT_RETRIEVAL_CONFIG = {
 	recencyWeight: RECENCY_WEIGHT,
 	temporalExpiry: false,
 	temporalDecay: true,
-	rerankModel: DEFAULT_RERANK_MODEL,
 	rerankTimeoutMs: DEFAULT_RERANK_TIMEOUT_MS,
-	rerankProvider: "voyage",
 	lengthNormAnchor: 0,
 	hardMinScore: 0,
 	timeDecayHalfLifeDays: 60,
@@ -244,12 +241,10 @@ const DEFAULT_RETRIEVAL_CONFIG = {
 *
 * - `missing_api_key`: cross-encoder configured but no rerankApiKey set;
 *   call routes through the lightweight cosine path instead.
-* - `no_endpoint`: provider has no known endpoint in `RERANK_DEFAULT_ENDPOINTS`
-*   and `rerankEndpoint` was not overridden; rerank was skipped.
-* - `http_error`: provider responded with a non-OK status that did not map
-*   to a fatal RetrievalError (i.e. degraded but not propagated).
-* - `invalid_response`: provider HTTP 2xx but response shape did not parse.
-* - `timeout`: the per-call AbortSignal fired before the provider responded.
+* - `no_endpoint`: no reranker address (`rerankEndpoint`) was set; rerank was skipped.
+* - `http_error`: the reranker responded with a non-OK status.
+* - `invalid_response`: the reranker answered HTTP 2xx but the response shape did not parse.
+* - `timeout`: the per-call AbortSignal fired before the reranker responded.
 * - `request_error`: any other thrown error inside the fetch path.
 * - `query_over_window`: the query alone fills the reranker's per-pair token window, so no
 *   document could be sent with it. Nothing was requested.
@@ -554,11 +549,10 @@ Object.assign(MemoryRetriever.prototype, {
 		this.throwIfAborted(context);
 		const rerankStageMetadata = rerankOutcome.fallback ? {
 			...rerankOutcome.stats,
-			rerankFallbackReason: rerankOutcome.fallback.reason,
-			rerankFallbackProvider: rerankOutcome.fallback.provider
+			rerankFallbackReason: rerankOutcome.fallback.reason
 		} : rerankOutcome.stats;
 		trace?.endStage(fused.map((r) => r.entry.id), fused.map((r) => r.score), rerankStageMetadata);
-		fused = this.applyScoringPipeline(fused, trace, context.limit);
+		fused = this.applyScoringPipeline(fused, trace, context.limit, rerankOutcome.modelOrder);
 		trace?.startStage("min_score_filter", fused.map((result) => result.entry.id));
 		fused = fused.filter((result) => result.score >= (context.minScore ?? this.config.minScore));
 		trace?.endStage(fused.map((result) => result.entry.id), fused.map((result) => result.score));
@@ -627,100 +621,31 @@ Object.assign(MemoryRetriever.prototype, {
 });
 //#endregion
 //#region src/engine/retrieval/retrieval-rerank-provider.ts
-/** @file retrieval-rerank-provider.ts
-* @purpose Adapts external rerank provider request and response formats.
-* @boundary HTTP payload shaping and response parsing only.
-*/
-const RERANK_DEFAULT_ENDPOINTS = {
-	voyage: "https://api.voyageai.com/v1/rerank",
-	jina: "https://api.jina.ai/v1/rerank",
-	pinecone: "https://api.pinecone.io/rerank",
-	dashscope: "https://dashscope.aliyuncs.com/api/v1/services/rerank"
-};
-function buildRerankHttpError(status) {
-	if (classifyLlmFailure({ status }).category === "auth") return new RetrievalError(`Rerank API failed with status ${status}`);
-}
-function buildRerankRequest(provider, apiKey, model, query, candidates, topN) {
-	switch (provider) {
-		case "tei":
-		case "sno-gpu": return {
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${apiKey}`,
-				...provider === "sno-gpu" ? {
-					"X-Sno-Source": "sno-station",
-					"X-Sno-Workload": "station-rerank"
-				} : {}
-			},
-			body: {
-				query,
-				texts: candidates,
-				raw_scores: true
-			}
-		};
-		case "dashscope": return {
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${apiKey}`
-			},
-			body: {
-				model,
-				input: {
-					query,
-					documents: candidates
-				}
-			}
-		};
-		case "pinecone": return {
-			headers: {
-				"Content-Type": "application/json",
-				"Api-Key": apiKey,
-				"X-Pinecone-API-Version": "2024-10"
-			},
-			body: {
-				model,
-				query,
-				documents: candidates.map((text) => ({ text })),
-				top_n: topN,
-				rank_fields: ["text"]
-			}
-		};
-		case "voyage": return {
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${apiKey}`
-			},
-			body: {
-				model,
-				query,
-				documents: candidates,
-				top_k: topN
-			}
-		};
-		default: return {
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${apiKey}`
-			},
-			body: {
-				model,
-				query,
-				documents: candidates,
-				top_n: topN
-			}
-		};
-	}
+function buildRerankRequest(apiKey, query, candidates) {
+	return {
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${apiKey}`,
+			"X-Sno-Source": "sno-station",
+			"X-Sno-Workload": "station-rerank"
+		},
+		body: {
+			query,
+			texts: candidates,
+			raw_scores: true
+		}
+	};
 }
-function parseRerankResponse(provider, data) {
-	/** Parses items into the normalized shape used by precision recall retrieval ranking. */
-	const parseItems = (items, scoreKeys) => {
+/** Sno's reranker answers a list of `{index, score}`, bare or under `results` / `data`. */
+function parseRerankResponse(data) {
+	const parseItems = (items) => {
 		if (!Array.isArray(items)) return void 0;
 		const parsed = [];
 		for (const raw of items) {
 			const index = typeof raw?.index === "number" ? raw.index : Number(raw?.index);
 			if (!Number.isFinite(index)) continue;
 			let score;
-			for (const key of scoreKeys) {
+			for (const key of ["score", "relevance_score"]) {
 				const value = raw?.[key];
 				const n = typeof value === "number" ? value : Number(value);
 				if (Number.isFinite(n)) {
@@ -737,18 +662,7 @@ function parseRerankResponse(provider, data) {
 		return parsed.length > 0 ? parsed : void 0;
 	};
 	const objectData = data && typeof data === "object" && !Array.isArray(data) ? data : void 0;
-	switch (provider) {
-		case "tei":
-		case "sno-gpu": return parseItems(data, ["score", "relevance_score"]) ?? parseItems(objectData?.results, ["score", "relevance_score"]) ?? parseItems(objectData?.data, ["score", "relevance_score"]);
-		case "dashscope": {
-			const output = objectData?.output;
-			if (output) return parseItems(output.results, ["relevance_score", "score"]);
-			return parseItems(objectData?.results, ["relevance_score", "score"]);
-		}
-		case "pinecone": return parseItems(objectData?.data, ["score", "relevance_score"]) ?? parseItems(objectData?.results, ["score", "relevance_score"]);
-		case "voyage": return parseItems(objectData?.data, ["relevance_score", "score"]) ?? parseItems(objectData?.results, ["relevance_score", "score"]);
-		default: return parseItems(objectData?.results, ["relevance_score", "score"]) ?? parseItems(objectData?.data, ["relevance_score", "score"]);
-	}
+	return parseItems(data) ?? parseItems(objectData?.results) ?? parseItems(objectData?.data);
 }
 //#endregion
 //#region src/engine/retrieval/retriever-rerank.ts
@@ -816,11 +730,9 @@ async function fetchRerankWithRetry(send, stop) {
 	for (let attempt = 1; attempt <= RERANK_TRANSIENT_ATTEMPTS; attempt += 1) {
 		let retryDelayMs = RERANK_TRANSIENT_BACKOFF_MS * attempt;
 		try {
-			const response = await send();
-			if (response.ok) return {
-				response,
-				data: await response.json()
-			};
+			const reply = await send();
+			const { response } = reply;
+			if (response.ok) return reply;
 			if (!RERANK_TRANSIENT_STATUSES.has(response.status) || attempt === RERANK_TRANSIENT_ATTEMPTS) return { response };
 			if (response.status === 429) {
 				const retryAfter = response.headers.get("retry-after");
@@ -852,13 +764,12 @@ Object.assign(MemoryRetriever.prototype, {
 	async rerank(query, candidates, queryVector, options) {
 		if (candidates.length === 0) return { candidates };
 		if (this.config.rerank === "none") return { candidates };
-		const provider = this.config.rerankProvider ?? "none";
-		const unranked = () => provider === "sno-gpu" ? this.rerankLightweight(candidates, queryVector) : candidates;
-		if (this.config.rerank === "cross-encoder" && !this.config.rerankApiKey) throw new RetrievalError(`rerank "cross-encoder" requires retrieval.rerankApiKey (provider: ${provider}); set the key, or set retrieval.rerank to "lightweight" to choose the local ranker`);
-		if (this.config.rerank === "lightweight" || !this.config.rerankApiKey) return { candidates: this.rerankLightweight(candidates, queryVector) };
-		const rerankEndpoint = this.config.rerankEndpoint ?? RERANK_DEFAULT_ENDPOINTS[provider];
+		const unranked = () => this.rerankLightweight(candidates, queryVector);
+		if (this.config.rerank === "cross-encoder" && !this.config.rerankApiKey) throw new RetrievalError("rerank \"cross-encoder\" requires retrieval.rerankApiKey; set the key, or set retrieval.rerank to \"lightweight\" to choose the local ranker");
+		if (this.config.rerank === "lightweight" || !this.config.rerankApiKey) return await this.rerankLocalModel(query, this.rerankLightweight(candidates, queryVector), options?.deadlineAt, options?.signal);
+		const rerankEndpoint = this.config.rerankEndpoint;
 		if (!rerankEndpoint) {
-			log.warn("rerank skipped: no endpoint for provider", { provider }, {
+			log.warn("rerank skipped: no reranker address", {}, {
 				event_name: "memory.retriever_rerank.diagnostic",
 				file: "packages/memory/src/engine/retrieval/retriever-rerank.ts",
 				function: "rerank",
@@ -866,15 +777,12 @@ Object.assign(MemoryRetriever.prototype, {
 			});
 			return {
 				candidates: unranked(),
-				fallback: {
-					reason: "no_endpoint",
-					provider
-				}
+				fallback: { reason: "no_endpoint" }
 			};
 		}
 		const rerankTimeoutMs = this.config.rerankTimeoutMs ?? 15e3;
-		const stepEnds = [options?.signal, provider === "sno-gpu" ? AbortSignal.timeout(Math.max(0, Math.floor(options?.deadlineAt === void 0 ? rerankTimeoutMs : options.deadlineAt - Date.now()))) : void 0].filter((each) => each !== void 0);
-		const stepStop = stepEnds.length > 0 ? AbortSignal.any(stepEnds) : void 0;
+		const stepBudget = AbortSignal.timeout(Math.max(0, Math.floor(options?.deadlineAt === void 0 ? rerankTimeoutMs : options.deadlineAt - Date.now())));
+		const stepStop = options?.signal ? AbortSignal.any([options.signal, stepBudget]) : stepBudget;
 		const rerankApiKey = this.config.rerankApiKey;
 		const maxCandidates = this.config.rerankMaxCandidates;
 		const overCap = maxCandidates !== void 0 && candidates.length > maxCandidates;
@@ -896,10 +804,7 @@ Object.assign(MemoryRetriever.prototype, {
 			});
 			return {
 				candidates: unranked(),
-				fallback: {
-					reason: "query_over_window",
-					provider
-				}
+				fallback: { reason: "query_over_window" }
 			};
 		}
 		let truncatedCandidates = 0;
@@ -922,20 +827,54 @@ Object.assign(MemoryRetriever.prototype, {
 			const runBatch = async (start) => {
 				let batchTexts = rerankTexts.slice(start, start + batchSize);
 				for (let pass = 0;; pass += 1) {
-					const { headers, body } = buildRerankRequest(provider, rerankApiKey, this.config.rerankModel ?? "rerank-2", query, batchTexts, batchTexts.length);
-					const { response, data } = await fetchRerankWithRetry(() => fetch(rerankEndpoint, {
-						method: "POST",
-						headers: provider === "sno-gpu" ? {
-							...headers,
-							"X-Request-ID": randomUUID()
-						} : headers,
-						body: JSON.stringify(body),
-						signal: stepStop ? AbortSignal.any([AbortSignal.timeout(rerankTimeoutMs), stepStop]) : AbortSignal.timeout(rerankTimeoutMs)
-					}), stepStop);
+					const { headers, body } = buildRerankRequest(rerankApiKey, query, batchTexts);
+					const sendAttempt = async () => {
+						const clientRequestId = randomUUID();
+						const attemptStarted = performance.now();
+						let outcome = "failed";
+						let statusCode;
+						try {
+							const attempt = await fetch(rerankEndpoint, {
+								method: "POST",
+								headers: {
+									...headers,
+									"X-Request-ID": clientRequestId
+								},
+								body: JSON.stringify(body),
+								signal: AbortSignal.any([AbortSignal.timeout(rerankTimeoutMs), stepStop])
+							});
+							statusCode = attempt.status;
+							if (!attempt.ok) {
+								outcome = "http_error";
+								return { response: attempt };
+							}
+							const data = await attempt.json();
+							outcome = "success";
+							return {
+								response: attempt,
+								data
+							};
+						} catch (error) {
+							outcome = isRerankTimeout(error) ? "timeout" : "failed";
+							throw error;
+						} finally {
+							log.info("Rerank request completed", {
+								outcome,
+								status_code: statusCode ?? "unavailable",
+								duration_ms: performance.now() - attemptStarted,
+								texts_sent: batchTexts.length,
+								client_request_id: clientRequestId
+							}, {
+								event_name: "rerank.request.completed",
+								file: "packages/memory/src/engine/retrieval/retriever-rerank.ts",
+								function: "runBatch",
+								site_id: "rerank.request.completed"
+							});
+						}
+					};
+					const { response, data } = await fetchRerankWithRetry(sendAttempt, stepStop);
 					if (!response.ok) {
 						const retryAfter = response.headers.get("retry-after");
-						const fatalError = buildRerankHttpError(response.status);
-						if (fatalError && provider !== "sno-gpu") throw fatalError;
 						const errorBody = await response.text().catch(() => "<unreadable body>");
 						const refusal = pass === 0 ? parseOverWindowRefusal(errorBody) : void 0;
 						if (refusal) {
@@ -977,10 +916,9 @@ Object.assign(MemoryRetriever.prototype, {
 						});
 						return "http_error";
 					}
-					const parsed = parseRerankResponse(provider, data);
+					const parsed = parseRerankResponse(data);
 					if (!parsed) {
 						log.warn("rerank API returned unparseable response", {
-							provider,
 							endpoint_hash: createHash("sha256").update(rerankEndpoint).digest("hex"),
 							batchStart: start
 						}, {
@@ -1012,10 +950,7 @@ Object.assign(MemoryRetriever.prototype, {
 				for (const outcome of settled) if (outcome.status === "rejected") throw outcome.reason;
 				for (const outcome of settled) if (outcome.status === "fulfilled" && typeof outcome.value === "string") return {
 					candidates: unranked(),
-					fallback: {
-						reason: outcome.value,
-						provider
-					}
+					fallback: { reason: outcome.value }
 				};
 				for (const outcome of settled) if (outcome.status === "fulfilled" && typeof outcome.value !== "string") items.push(...outcome.value);
 			}
@@ -1030,8 +965,7 @@ Object.assign(MemoryRetriever.prototype, {
 				const candidate = toRerank[item.index];
 				if (!candidate) continue;
 				const sourceScore = this.getRerankSourceScore(candidate);
-				let crossScore = item.score;
-				if (provider === "tei" || provider === "sno-gpu") crossScore = 1 / (1 + Math.exp(-item.score));
+				const crossScore = 1 / (1 + Math.exp(-item.score));
 				const blendedScore = clamp01(crossScore * blendCross + sourceScore * blendVector, 0);
 				reranked.push({
 					...candidate,
@@ -1050,8 +984,7 @@ Object.assign(MemoryRetriever.prototype, {
 			log.debug("reranked", {
 				totalCandidateCount: candidates.length,
 				sentToRerankCount: toRerank.length,
-				returnedCount: reranked.length,
-				provider
+				returnedCount: reranked.length
 			}, {
 				event_name: "memory.retriever_rerank.diagnostic",
 				file: "packages/memory/src/engine/retrieval/retriever-rerank.ts",
@@ -1094,10 +1027,7 @@ Object.assign(MemoryRetriever.prototype, {
 			}
 			return {
 				candidates: unranked(),
-				fallback: {
-					reason,
-					provider
-				}
+				fallback: { reason }
 			};
 		}
 	},
@@ -1106,8 +1036,8 @@ Object.assign(MemoryRetriever.prototype, {
 		if (candidates.length === 0) return candidates;
 		const chunkIds = candidates.map((c) => c.chunkId).filter((id) => id !== void 0);
 		const vectorMap = chunkIds.length > 0 ? this.store.getVectorsByIds(chunkIds) : /* @__PURE__ */ new Map();
-		const wF = this.config.lightweightFusionWeight ?? .7;
-		const wC = this.config.lightweightCosineWeight ?? .3;
+		const wF = this.config.lightweightFusionWeight ?? .1;
+		const wC = this.config.lightweightCosineWeight ?? .9;
 		let blendedCount = 0;
 		let dimMismatchCount = 0;
 		const reranked = candidates.map((candidate) => {
@@ -1168,6 +1098,58 @@ Object.assign(MemoryRetriever.prototype, {
 			return a.entry.id.localeCompare(b.entry.id);
 		});
 	},
+	/**
+	* The local reranker model reorders the first candidates of the local ranking. Their order is unchanged while the
+	* model is not loaded yet (the first call starts loading it), past the caller's deadline, and after a cancel.
+	*/
+	async rerankLocalModel(query, ordered, deadlineAt, signal) {
+		if (ordered.length < 2 || signal?.aborted || deadlineAt !== void 0 && Date.now() >= deadlineAt) return { candidates: ordered };
+		const head = ordered.slice(0, 15);
+		const started = performance.now();
+		const budgetMs = deadlineAt === void 0 ? this.config.rerankTimeoutMs ?? 15e3 : Math.max(0, Math.floor(deadlineAt - Date.now()));
+		const stop = signal ? AbortSignal.any([signal, AbortSignal.timeout(budgetMs)]) : AbortSignal.timeout(budgetMs);
+		const scoring = this.embedder.scoreRelevance(query, head.map((r) => r.entry.text), stop).catch((error) => {
+			log.warn("local reranker failed; recall keeps the local ranking order", { error }, {
+				event_name: "memory.retriever_rerank.diagnostic",
+				file: "packages/memory/src/engine/retrieval/retriever-rerank.ts",
+				function: "rerankLocalModel",
+				site_id: "retrieval.retriever-rerank.rerankLocalModel.failed"
+			});
+		});
+		const logits = await Promise.race([scoring, new Promise((resolve) => stop.addEventListener("abort", () => resolve(void 0), { once: true }))]);
+		if (!logits || signal?.aborted) return { candidates: ordered };
+		const blended = head.map((candidate, index) => ({
+			candidate,
+			value: logits[index] ?? Number.NEGATIVE_INFINITY
+		}));
+		blended.sort((a, b) => b.value - a.value || a.candidate.entry.id.localeCompare(b.candidate.entry.id));
+		const slots = head.map((candidate) => candidate.score).sort((a, b) => b - a);
+		const rescored = blended.map(({ candidate }, index) => {
+			const score = slots[index] ?? candidate.score;
+			return {
+				...candidate,
+				score,
+				rerankScore: score,
+				sources: {
+					...candidate.sources,
+					reranked: { score }
+				}
+			};
+		});
+		log.debug("local reranker applied", {
+			scored: head.length,
+			duration_ms: performance.now() - started
+		}, {
+			event_name: "memory.retriever_rerank.diagnostic",
+			file: "packages/memory/src/engine/retrieval/retriever-rerank.ts",
+			function: "rerankLocalModel",
+			site_id: "retrieval.retriever-rerank.rerankLocalModel.applied"
+		});
+		return {
+			candidates: [...rescored, ...ordered.slice(head.length)],
+			modelOrder: blended.map(({ candidate }) => candidate.entry.id)
+		};
+	},
 	getRerankSourceScore(result) {
 		return clamp01(Math.max(result.sources.bm25?.score ?? 0, result.sources.vector?.score ?? 0), 0);
 	}
@@ -1359,8 +1341,21 @@ function tracedStage(trace, name, skipReason, run, input) {
 	trace.endStage(output.map((result) => result.entry.id), output.map((result) => result.score), skipReason === void 0 ? void 0 : { skipped: skipReason });
 	return output;
 }
+/** The candidates the local reranker model scored take their own scores, highest first, in its order. */
+function orderByLocalModel(results, modelOrder) {
+	const present = new Set(results.map((result) => result.entry.id));
+	const order = modelOrder.filter((id) => present.has(id));
+	if (order.length < 2) return results;
+	const judged = new Set(order);
+	const slots = results.filter((result) => judged.has(result.entry.id)).map((result) => result.score).sort((a, b) => b - a);
+	const scores = new Map(order.map((id, index) => [id, slots[index] ?? 0]));
+	return results.map((result) => ({
+		...result,
+		score: scores.get(result.entry.id) ?? result.score
+	})).sort((a, b) => b.score - a.score);
+}
 Object.assign(MemoryRetriever.prototype, {
-	applyScoringPipeline(results, trace, limit = results.length) {
+	applyScoringPipeline(results, trace, limit = results.length, modelOrder) {
 		const stage = (name, skipReason, run, input) => tracedStage(trace, name, skipReason, run, input);
 		const temporalOff = !this.config.temporalWeighting;
 		let scored = stage("recency_boost", temporalOff ? "temporalWeighting" : this.config.recencyHalfLifeDays <= 0 ? "recencyHalfLifeDays" : this.config.recencyWeight <= 0 ? "recencyWeight" : void 0, (input) => temporalOff ? input : this.applyRecencyBoost(input), results);
@@ -1368,6 +1363,7 @@ Object.assign(MemoryRetriever.prototype, {
 		scored = stage("length_normalization", this.config.lengthNormAnchor <= 0 ? "lengthNormAnchor" : void 0, (input) => this.applyLengthNormalization(input), scored);
 		scored = stage("time_decay", temporalOff ? "temporalWeighting" : this.config.timeDecayHalfLifeDays <= 0 ? "timeDecayHalfLifeDays" : void 0, (input) => temporalOff ? input : this.applyTimeDecay(input), scored);
 		scored = stage("retention_boost", temporalOff ? "temporalWeighting" : this.config.recallLifecycle?.retentionScorer === true ? void 0 : "recallLifecycle.retentionScorer", (input) => temporalOff ? input : this.applyRetentionBoost(input), scored);
+		scored = stage("local_model_order", modelOrder ? void 0 : "modelOrder", (input) => modelOrder ? orderByLocalModel(input, modelOrder) : input, scored);
 		scored = stage("hard_min_score", void 0, (input) => input.filter((result) => result.score >= this.config.hardMinScore), scored);
 		const mmrOff = experimentMmrDisabled();
 		scored = stage("mmr_diversity", mmrOff ? "experiment.disableMmr" : void 0, (input) => {

package/dist/{retriever-DdikFSDC.d.ts → retriever-hTIkt3CJ.d.ts}

@@ -1,13 +1,13 @@
-import { h as MemoryCategory, l as DecayScore, r as AggregationQuery, u as DecayableMemory, x as RetrievalResult, y as MemorySearchResult } from "./types-DZGL4QXi.js";
-import { sn as RecallLifecycleConfig } from "./index-Pb9LrHgL.js";
-import { t as Embedder } from "./embedding-provider-client-vynZMuit.js";
+import { h as MemoryCategory, l as DecayScore, r as AggregationQuery, u as DecayableMemory, x as RetrievalResult, y as MemorySearchResult } from "./types-DBEwNYdR.js";
+import { sn as RecallLifecycleConfig } from "./index-BGu91bjB.js";
+import { t as Embedder } from "./embedding-provider-client-CELWtPgt.js";
 import "./trace-C1JxMfs-.js";
-import "./memory-metadata-codec-BQ8tBY-g.js";
+import "./memory-metadata-codec-CfP9JLVO.js";
 import { K as RemFacetPolicy } from "./index-DPfJrOFD.js";
-import { C as MemoryStore } from "./memory-store-base-CTAMKigD.js";
-import "./store-DraRJ-HI.js";
-import { n as AccessTracker } from "./access-tracker-CglGg8uS.js";
-import { r as TierPromoter } from "./memory-tier-promoter-CSGa4LBH.js";
+import { C as MemoryStore } from "./memory-store-base-upd9MuG6.js";
+import "./store-DEG06TLb.js";
+import { n as AccessTracker } from "./access-tracker-B1H2AJlH.js";
+import { r as TierPromoter } from "./memory-tier-promoter-Cq23yveQ.js";
 import "@snoai/utils/logger";
 //#region src/engine/retrieval/retrieval-trace.d.ts
 /** @file retrieval-trace.ts
@@ -209,7 +209,6 @@ declare class RetrievalStatsCollector {
 }
 //#endregion
 //#region src/engine/retrieval/retrieval-config.d.ts
-type RerankProvider = "jina" | "siliconflow" | "voyage" | "pinecone" | "dashscope" | "tei" | "sno-gpu";
 interface RetrievalConfig {
   /** Enable the historical recency, decay, and retention score transforms. */
   temporalWeighting: boolean;
@@ -228,7 +227,6 @@ interface RetrievalConfig {
   /** Dynamic memories decay 3× faster in time-decay scoring (default ON) */
   temporalDecay: boolean;
   rerankApiKey?: string;
-  rerankModel?: string;
   rerankTimeoutMs?: number;
   lengthNormAnchor: number;
   hardMinScore: number;
@@ -247,15 +245,10 @@ interface RetrievalConfig {
   timeDecayFloor?: number;
   /** Relevance vs diversity tradeoff (default: 0.7) */
   mmrLambda?: number;
-  /** Custom rerank API endpoint URL */
+  /** Address of Sno's reranker (the Sno GPU address plus `/rerank`) */
   rerankEndpoint?: string;
-  /** Rerank provider name */
-  rerankProvider?: RerankProvider | string;
   /**
-   * Hard cap on how many candidates are sent to the cross-encoder rerank API
-   * in one request. Some rerank deployments (e.g. this repo's Sno TEI
-   * reranker) reject a batch above a fixed size instead of truncating it, so
-   * an unset value here must never silently violate that limit. Candidates
+   * Cap on how many candidates are sent to Sno's reranker in total. Candidates
    * beyond the cap are NOT dropped — they still flow through the standard
    * `unreturned` preservation-floor path, same as a real reranker choosing
    * not to return them.
@@ -361,12 +354,10 @@ interface RetentionScorer {
  *
  * - `missing_api_key`: cross-encoder configured but no rerankApiKey set;
  *   call routes through the lightweight cosine path instead.
- * - `no_endpoint`: provider has no known endpoint in `RERANK_DEFAULT_ENDPOINTS`
- *   and `rerankEndpoint` was not overridden; rerank was skipped.
- * - `http_error`: provider responded with a non-OK status that did not map
- *   to a fatal RetrievalError (i.e. degraded but not propagated).
- * - `invalid_response`: provider HTTP 2xx but response shape did not parse.
- * - `timeout`: the per-call AbortSignal fired before the provider responded.
+ * - `no_endpoint`: no reranker address (`rerankEndpoint`) was set; rerank was skipped.
+ * - `http_error`: the reranker responded with a non-OK status.
+ * - `invalid_response`: the reranker answered HTTP 2xx but the response shape did not parse.
+ * - `timeout`: the per-call AbortSignal fired before the reranker responded.
  * - `request_error`: any other thrown error inside the fetch path.
  * - `query_over_window`: the query alone fills the reranker's per-pair token window, so no
  *   document could be sent with it. Nothing was requested.
@@ -375,10 +366,11 @@ declare const RERANK_FALLBACK_REASONS: readonly ["missing_api_key", "no_endpoint
 type RerankFallbackReason = (typeof RERANK_FALLBACK_REASONS)[number];
 interface RerankFallbackSignal {
   reason: RerankFallbackReason;
-  provider: string;
 }
 interface RerankOutcome {
   candidates: RetrievalResult[];
+  /** Ids of the candidates the local reranker model scored, in its order; the scoring pipeline restores it last. */
+  modelOrder?: string[];
   fallback?: RerankFallbackSignal;
   stats?: {
     rerankSentCount: number;
@@ -459,8 +451,9 @@ interface MemoryRetrieverInternals {
     deadlineAt?: number;
   }): Promise<RerankOutcome>;
   rerankLightweight(candidates: RetrievalResult[], queryVector: Float32Array): RetrievalResult[];
+  rerankLocalModel(query: string, ordered: RetrievalResult[], deadlineAt?: number, signal?: AbortSignal): Promise<RerankOutcome>;
   getRerankSourceScore(result: RetrievalResult): number;
-  applyScoringPipeline(results: RetrievalResult[], trace?: TraceCollector, limit?: number): RetrievalResult[];
+  applyScoringPipeline(results: RetrievalResult[], trace?: TraceCollector, limit?: number, modelOrder?: readonly string[]): RetrievalResult[];
   applyRecencyBoost(results: RetrievalResult[]): RetrievalResult[];
   applyImportanceWeight(results: RetrievalResult[]): RetrievalResult[];
   applyLengthNormalization(results: RetrievalResult[]): RetrievalResult[];
@@ -473,4 +466,4 @@ declare function createRetriever(store: MemoryStore, embedder: Embedder, logger?
   warn: (message: string, fields?: Record<string, unknown>) => void;
 }, config?: RetrievalConfig): MemoryRetriever;
 //#endregion
-export { RerankFallbackSignal as a, collectParallelStage as c, RetrievalConfig as d, RetrievalContext as f, RerankFallbackReason as i, DEFAULT_RETRIEVAL_CONFIG as l, MemoryRetrieverInternals as n, RerankOutcome as o, withServingValidityDefault as p, RERANK_FALLBACK_REASONS as r, createRetriever as s, MemoryRetriever as t, RerankProvider as u };
+export { RerankFallbackSignal as a, collectParallelStage as c, RetrievalContext as d, withServingValidityDefault as f, RerankFallbackReason as i, DEFAULT_RETRIEVAL_CONFIG as l, MemoryRetrieverInternals as n, RerankOutcome as o, RERANK_FALLBACK_REASONS as r, createRetriever as s, MemoryRetriever as t, RetrievalConfig as u };

package/dist/{runtime-audit-log-BVOxzkh7.d.ts → runtime-audit-log-eBrt_iPp.d.ts}

@@ -1,4 +1,4 @@
-import "./paths-B5y-npWs.js";
+import "./paths-qJqwGcKl.js";
 //#region src/engine/operations/runtime-audit-log.d.ts
 type AuditEvent = "tool_call" | "hook_trigger" | "kill_switch" | "startup" | "error" | "auto_recall" | "ambient_learning" | "session_summary" | "envelope_strip" | "storage_integrity" | "memory_injected" | "memory_searched" | "memory_read" | "memory_updated" | "memory_superseded" | "memory_deleted" | "memory_purged" | "rem_trigger_evaluated" | "rem_triggered" | "rem_completed" | "rem_failed";
 type AuditStatus = "ok" | "error" | "skipped" | "partial";

package/dist/{server-DOL3D6bb.js → server-BnBzsvMF.js}

@@ -1,16 +1,16 @@
-import { At as getAuditPath, Dt as appendAuditEntryStrict, K as REM_BUILT_OPERATION_TYPES, Ot as compactAuditLog, Pt as readJsonlLines, bt as ModelCallRefusedError, d as RemJobStore, f as parseRemJobStats, n as remNeedsHost, q as parseRemOperationType } from "./rem-trigger-B1P5_RqV.js";
-import { C as getSnoStationMemStateDir, Fr as MEMORY_SKIN_HEADER, Lr as memoryMethod, Mr as MEMORY_ERROR_STATUS, Pr as MEMORY_ROUTES, S as getSidecarSocketPath, _ as readRemTestHoldMs, c as REM_SIDECAR_ORIGIN, d as getRemDiscoveryPath, f as getRemJobJournalPath, g as readRemOperationalConfig, i as REM_JOBS_PATH_PREFIX, jr as MEMORY_DEFAULT_SKIN_ID, l as REM_SOURCE, r as REM_CORRELATION_ID_HEADER, rr as MEMORY_SHUTDOWN_TIMEOUT_MS, s as REM_SIDECAR_HOST, u as getRemChassisJournalPath, v as SettingsUnavailableError, y as getDiscoveryPath } from "./config-D_KOwEyg.js";
+import { At as getAuditPath, Dt as appendAuditEntryStrict, K as REM_BUILT_OPERATION_TYPES, Ot as compactAuditLog, Pt as readJsonlLines, bt as ModelCallRefusedError, d as RemJobStore, f as parseRemJobStats, n as remNeedsHost, q as parseRemOperationType } from "./rem-trigger-DL0MlLeo.js";
+import { C as getSnoStationMemStateDir, Fr as MEMORY_SKIN_HEADER, Lr as memoryMethod, Mr as MEMORY_ERROR_STATUS, Pr as MEMORY_ROUTES, S as getSidecarSocketPath, _ as readRemTestHoldMs, c as REM_SIDECAR_ORIGIN, d as getRemDiscoveryPath, f as getRemJobJournalPath, g as readRemOperationalConfig, i as REM_JOBS_PATH_PREFIX, jr as MEMORY_DEFAULT_SKIN_ID, l as REM_SOURCE, nr as MEMORY_SHUTDOWN_TIMEOUT_MS, r as REM_CORRELATION_ID_HEADER, s as REM_SIDECAR_HOST, u as getRemChassisJournalPath, v as SettingsUnavailableError, y as getDiscoveryPath } from "./config-DWeuetYo.js";
 import { t as ContractError } from "./error-D-wb-rZw.js";
 import { setImmediate } from "node:timers/promises";
 import { createLogger, currentLogContext, effectiveLogLevel, emitDiagnostic } from "@snoai/utils/logger";
 import path from "node:path";
 import { constants, existsSync, readFileSync, rmSync } from "node:fs";
-import { z } from "zod";
 import { randomBytes, randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import { z } from "zod";
 import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
 import { withLogContext as withLogContext$1 } from "@snoai/utils/log-context";
-import { createConnection, createServer } from "node:net";
-import { createServer as createServer$1 } from "node:http";
+import { createConnection, createServer as createServer$1 } from "node:net";
 import { tryLock } from "fs-native-extensions";
 //#region src/contract/discovery.ts
 const discoverySchema = z.strictObject({
@@ -268,7 +268,7 @@ async function bindSidecarSocket() {
 	const lock = await open(`${socketPath}.lock`, constants.O_RDWR | constants.O_CREAT | constants.O_NOFOLLOW, 384);
 	try {
 		while (!tryLock(lock.fd)) await setImmediate();
-		const guard = createServer((socket) => socket.destroy());
+		const guard = createServer$1((socket) => socket.destroy());
 		for (;;) try {
 			await new Promise((resolve, reject) => {
 				guard.once("error", reject);
@@ -335,7 +335,7 @@ async function startOwnedRemSidecar() {
 		async open() {
 			if (currentMemory) return currentMemory;
 			if (settingsError) throw settingsError;
-			openingMemory ??= import("./memory-runtime-4iOpeP09.js").then((module) => module.MemoryRuntimePool.open()).then((pool) => {
+			openingMemory ??= import("./memory-runtime-jQke2sBc.js").then((module) => module.MemoryRuntimePool.open()).then((pool) => {
 				currentMemory = pool;
 				if (stopping) pool.stopTimers();
 				return pool;
@@ -372,7 +372,7 @@ async function startOwnedRemSidecar() {
 	};
 	const activeTasks = /* @__PURE__ */ new Set();
 	const pendingRequests = /* @__PURE__ */ new Set();
-	const server = createServer$1((request, response) => {
+	const server = createServer((request, response) => {
 		const started = performance.now();
 		const operationId = `rem-http-${randomUUID()}`;
 		const context = {};
@@ -730,7 +730,7 @@ async function runChassisJob(store, journal, waveId, holdMs, runtime) {
 				cleanRefusalReasons.push(reason);
 				await appendChassisRefusal(journal, queued, operation, "refused", reason);
 			}
-			const { runRemProductionOrderedWave } = await import("./rem-batch-executor-CfWChDAk.js");
+			const { runRemProductionOrderedWave } = await import("./rem-batch-executor-B_49KivZ.js");
 			const result = enabledOperations.length === 0 ? {
 				decision: "allow",
 				reasonCode: null,