@modusensus/dsh-mneme 0.7.28 → 0.7.30

package/src/api.js

@@ -161,6 +161,16 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // 反馈入口预填用的插件版本（面板「帮助与反馈」卡片拉取）。读取失败（打包
+  // 环境）返回 "unknown"，链接照常可用，纯展示信息不拦截。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/info",
+    handler(req, res) {
+      sendJson(res, 200, { version: PACKAGE_VERSION });
+    }
+  });
+
   register({
     kind: "exact",
     path: "/api/dsh-mneme/list",
@@ -595,7 +605,13 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
       try {
         const stats = semantic?.vectorIndex?.getStats?.() ?? null;
         sendJson(res, 200, {
-          embedProvider: embedder ? (embedder.constructor?.name ?? "unknown") : null,
+          // #118: expose readiness so the status card can tell "initializing /
+          // unreachable" from "disabled". Legacy OpenAI embedder has no `ready`
+          // prop and is immediately usable, so treat that as ready.
+          ready: embedder ? ("ready" in embedder ? embedder.ready === true : true) : null,
+          // Explicit display name first: the legacy OpenAI-compatible embedder
+          // is an object literal, so constructor.name would be "Object".
+          embedProvider: embedder ? (embedder.name ?? embedder.constructor?.name ?? "unknown") : null,
           modelHash: embedder?.modelHash ?? null,
           dimension: embedder?.dimension ?? null,
           reranker: semantic?.reranker ? "ready" : null,

package/src/config.js

@@ -178,6 +178,19 @@ export const Config = z.object({
   searchSemanticDedup: z.boolean().default(false),
   searchSemanticDedupThreshold: z.number().min(0.5).max(1).default(0.95),
 
+  // Recall fusion recipe (plan #1): how the keyword/vector/BM25 ranked lists
+  // are combined into the final ranking. `blend` (default) is the legacy
+  // behavior — weighted sum for vector/hybrid, union backfill for auto —
+  // unchanged. `rrf` (Reciprocal Rank Fusion) and `minmax` (min-max normalized
+  // weighted sum) are rank/scale-aware recipes that fix the unit mismatch the
+  // issue describes (raw cosine vs keyword score vs normalized IDF are added
+  // directly). Off by default so existing behavior holds exactly.
+  recallFusion: z.union([z.const("blend"), z.const("rrf"), z.const("minmax")]).default("blend"),
+  // Attach a `signals` object { keyword, vector, bm25, final } to each search
+  // result for transparency/debugging (plan #2). Default off; when on it only
+  // decorates the returned rows, never changes the ranking.
+  signalTransparency: z.boolean().default(false),
+
   // --- semantic: rerank layer (v0.2) --------------------------------------
   // Opt-in by default (item ⑥): the local cross-encoder pulls in onnxruntime
   // (transformers.js) at init, so a bare install must not load it. Only an
@@ -207,9 +220,23 @@ export const Config = z.object({
   // The storage layer (entities/entity_attrs/entity_relations tables + CRUD)
   // is always available regardless of this flag.
   entityExtractionEnabled: z.boolean().default(false),
+  // Optional provider override for entity extraction; empty = use the caller's
+  // default provider/model. Combined with entityExtractionModel — provider
+  // without model (or vice versa) falls through to the caller default.
+  entityExtractionProvider: z.string().default(""),
   // Optional model override for entity extraction; empty = use the caller's
   // default provider/model.
   entityExtractionModel: z.string().default(""),
+  // Reasoning effort for entity extraction (issue #109), mirrors
+  // dreamReasoningEffort: 'none' (default) omits the field / provider default;
+  // low/medium/high passed through. A provider that rejects the effort retries
+  // once without it, so opting in is safe to experiment with.
+  entityExtractionReasoning: z.union([
+    z.const("low"),
+    z.const("medium"),
+    z.const("high"),
+    z.const("none")
+  ]).default("none"),
   // Cap on entities per extraction pass and attributes per entity.
   entityExtractionMaxEntities: z.natural().min(1).max(20).default(10),
   entityExtractionMaxAttrs: z.natural().min(1).max(50).default(20),

package/src/embedding.js

@@ -97,6 +97,9 @@ export function createEmbedder({ store, settings, logger, vectorIndex }) {
   }
 
   return {
+    // Display name for /semantic: a literal's constructor.name is "Object",
+    // which the status card would render verbatim.
+    name: "OpenAI",
     /** Fire-and-forget re-embed of a memory after any write. */
     schedule(memory) {
       if (!memory?.id) return;

package/src/entities/extractor.js

@@ -146,16 +146,23 @@ export async function extractEntities(memory, { store, config, callLLM, logger }
       return { ok: false, error: "Invalid memory: missing content" };
     }
     
-    const model = config.entityExtractionModel || null;
     const systemPrompt = buildSystemPrompt(config);
     const userText = buildUserMessage(memory.content);
-    
+
     const messages = [
       { role: "system", content: [{ type: "text", text: systemPrompt }] },
       { role: "user", content: [{ type: "text", text: userText }] }
     ];
-    
-    const options = model ? { model } : {};
+
+    // Issue #109: optional provider/model override + reasoning effort are
+    // passed through to callLLM's options; the index.js adapter maps them onto
+    // the route (or falls back to the caller's default model). Empty provider/
+    // model both mean "use the caller default".
+    const options = {};
+    if (config.entityExtractionProvider) options.provider = config.entityExtractionProvider;
+    if (config.entityExtractionModel) options.model = config.entityExtractionModel;
+    const reasoning = config.entityExtractionReasoning;
+    if (reasoning && reasoning !== "none") options.reasoningEffort = reasoning;
     const llmResponse = await callLLM(messages, options);
     
     if (!llmResponse) {
@@ -219,7 +226,7 @@ export async function extractEntities(memory, { store, config, callLLM, logger }
           to_entity: toId,
           relation_type: rel.type,
           memory_id: memory.id,
-          metadata: { model: model || "default" }
+          metadata: { model: options.model || "default" }
         });
         savedRelations.push(saved);
       } catch (err) {

package/src/index.js

@@ -35,6 +35,57 @@ export { Config };
 // value, so a `function apply` disposer would never run on unload. An arrow
 // has no prototype, is called normally, and its returned disposer is collected
 // and run by the fiber on unload.
+// Entity-extraction LLM adapter (issue #108/#109): maps the extractor's
+// options (provider/model override + reasoningEffort) onto a real dsh-llm
+// stream route and retries once without the effort when the first attempt is
+// rejected. Extracted from apply() so the effort-fallback branch is
+// unit-testable; the extractor only ever sees a callLLM(messages, options)
+// => Promise<string>. The route always carries a real provider/model (dsh-llm
+// GenerateOptions requires both) — never a bare stream.
+export function createEntityStreamAdapter({ llm, agentDefaultModel, logger }) {
+  return async function streamEntityText(messages, options = {}) {
+    let route = {};
+    if (options.provider) route.provider = options.provider;
+    if (options.model) route.model = options.model;
+    if (!route.provider || !route.model) {
+      try {
+        const sel = agentDefaultModel?.currentSelection?.();
+        if (sel?.provider && sel?.model) {
+          route.provider ??= sel.provider;
+          route.model ??= sel.model;
+        }
+      } catch { /* fall through to whatever route we already have */ }
+    }
+    const effort = options.reasoningEffort;
+    const tryStream = (withEffort) => {
+      let text = "";
+      return (async () => {
+        for await (const chunk of llm.stream({
+          ...route,
+          maxTokens: 4096,
+          ...(withEffort && effort ? { reasoningEffort: effort } : {}),
+          messages
+        })) {
+          if (chunk.type === "text-delta" && typeof chunk.text === "string") text += chunk.text;
+          if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) return undefined;
+        }
+        return text;
+      })().catch((err) => {
+        logger?.warn?.(`[dsh-mneme] entity extraction llm stream failed: ${String(err)}`);
+        return undefined;
+      });
+    };
+    let text = await tryStream(true);
+    if (text === undefined && effort) {
+      // Mirror dream's effort fallback: a provider rejecting the reasoning
+      // effort must not sink the whole extraction — retry once without it.
+      logger?.warn?.(`[dsh-mneme] entity extraction: reasoningEffort "${effort}" rejected, retrying without it`);
+      text = await tryStream(false);
+    }
+    return text;
+  };
+}
+
 export const apply = (ctx, config) => {
   const rawCfg = Config(config);
 
@@ -148,6 +199,8 @@ export const apply = (ctx, config) => {
 
   let embedder = null;
   let reranker = null;
+  // #118: pending embedder-init retry timer, cleared on unload.
+  let embedRetryTimer = null;
   if (lightMode) {
     // Light mode: the whole vector pipeline stays off — no embedder (nothing
     // pulls in ONNX/transformers), no reranker, no boot backfill (the preset
@@ -175,13 +228,32 @@ export const apply = (ctx, config) => {
       service.setEmbedder(embedder);
       // issue #6: wait for extractor init before applying human edits, so
       // scheduled embeddings see a ready embedder.
-      embedder.init()
-        .then(() => applyHumanEdits())
-        .catch((error) => {
-          ctx.logger?.warn?.(`[dsh-mneme] embedder init failed, search degrades to keyword: ${String(error)}`);
-          service.setEmbedder(null);
-          applyHumanEdits();
-        });
+      const bootEmbedder = () => embedder.init()
+        .then(() => { applyHumanEdits(); return true; })
+        .catch(() => false);
+      // #118: the old one-shot probe permanently degraded search to keyword
+      // when Ollama was briefly unreachable at boot (recoverable only by
+      // restart). Retry briefly (5 attempts total: 1 initial + 4 × 15s);
+      // search degrades to keyword meanwhile because per-query embed failures
+      // are swallowed.
+      bootEmbedder().then((ok) => {
+        if (ok) return;
+        let tries = 4;
+        const retry = () => {
+          if (tries-- <= 0) {
+            ctx.logger?.warn?.("[dsh-mneme] embedder init retries exhausted, search degrades to keyword");
+            service.setEmbedder(null);
+            applyHumanEdits();
+            return;
+          }
+          embedRetryTimer = setTimeout(async () => {
+            if (await bootEmbedder()) return;
+            retry();
+          }, 15_000);
+        };
+        ctx.logger?.warn?.("[dsh-mneme] embedder init failed, retrying");
+        retry();
+      });
     } catch (error) {
       ctx.logger?.warn?.(`[dsh-mneme] embedder unavailable, search degrades to keyword: ${String(error)}`);
       applyHumanEdits();
@@ -320,40 +392,35 @@ export const apply = (ctx, config) => {
   // expects, reusing the same ctx.llm.stream consumption pattern as dream.js.
   // Explicit opt-in only (entityExtractionEnabled defaults to false); any LLM
   // failure degrades inside the extractor to { ok:false }, never a write error.
-  if (cfg.entityExtractionEnabled && ctx.llm) {
-    const streamEntityText = async (messages, options = {}) => {
-      let route = null;
-      if (options.model) {
-        route = { model: options.model };
-      } else {
-        try {
-          const sel = ctx.agentDefaultModel?.currentSelection?.();
-          if (sel?.provider && sel?.model) route = sel;
-        } catch { /* fall through to no route */ }
-      }
-      let text = "";
-      for await (const chunk of ctx.llm.stream({
-        ...(route ?? {}),
-        purpose: "entity-extract",
-        maxTokens: 4096,
-        messages
-      })) {
-        if (chunk.type === "text-delta" && typeof chunk.text === "string") text += chunk.text;
-        if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) return undefined;
-      }
-      return text;
-    };
-    service.setEntityExtractor((memory) =>
-      extractEntities(memory, { store, config: cfg, callLLM: streamEntityText, logger: ctx.logger })
-        .catch((err) => {
-          ctx.logger?.warn?.(`[dsh-mneme] entity extraction failed: ${String(err)}`);
-          return { ok: false, error: String(err) };
-        })
-    );
+  if (cfg.entityExtractionEnabled) {
+    if (!ctx.llm) {
+      // Issue #108: an enabled-but-unwired extractor failed silently before —
+      // zero entities, zero llm_audit_logs, no log line anywhere. Make the
+      // missing dependency visible so a user can tell "extractor not installed"
+      // from "extraction failed".
+      ctx.logger?.warn?.("[dsh-mneme] entityExtractionEnabled=true but ctx.llm unavailable — entity extractor NOT installed");
+    } else {
+      const streamEntityText = createEntityStreamAdapter({
+        llm: ctx.llm,
+        agentDefaultModel: ctx.agentDefaultModel,
+        logger: ctx.logger
+      });
+      service.setEntityExtractor((memory) =>
+        extractEntities(memory, { store, config: cfg, callLLM: streamEntityText, logger: ctx.logger })
+          .catch((err) => {
+            ctx.logger?.warn?.(`[dsh-mneme] entity extraction failed: ${String(err)}`);
+            return { ok: false, error: String(err) };
+          })
+      );
+    }
   }
 
   const disposers = [];
 
+  // #118: never let a pending embedder init retry fire after unload and touch
+  // a torn-down context.
+  disposers.push(() => { if (embedRetryTimer !== null) clearTimeout(embedRetryTimer); });
+
   ctx.inject(["systemPrompt"], (promptCtx) => {
     if (cfg.autoInject) disposers.push(createInjector(promptCtx, service, settings, cfg));
   });

package/src/local-embedder.js

@@ -139,6 +139,9 @@ export class OllamaEmbedder {
     this.model = String(opts.model ?? "nomic-embed-text").trim();
     this.logger = opts.logger ?? null;
     this._dimension = null;
+    // #118: async-init embedders expose `ready` so the service queues re-embeds
+    // until init lands and the status card can show "initializing".
+    this.ready = false;
   }
 
   async _post(body) {
@@ -157,6 +160,7 @@ export class OllamaEmbedder {
     const body = await res.json();
     if (!Array.isArray(body?.embedding)) throw new Error(`Ollama ${this.model} returned no embedding`);
     this._dimension = body.embedding.length;
+    this.ready = true;
     this.logger?.info?.(
       `[dsh-mneme] ollama embedder ready: ${this.model} (dim=${this._dimension})`
     );

package/src/service.js

@@ -416,6 +416,171 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     }
   }
 
+  /**
+   * Recall fusion (plan #1). Turns the three ranked signal lists (keyword,
+   * vector, BM25) into a single merged list. Three recipes, selected by
+   * config.recallFusion:
+   *  - blend (default): legacy behavior — weighted sum for vector/hybrid, union
+   *    backfill for auto. Byte-identical to pre-fusion code, so enabling the
+   *    config never regresses anybody.
+   *  - rrf: Reciprocal Rank Fusion — Σ 1/(k + rank + 1) over each list a row
+   *    appears in. Rank-based, so the unit mismatch (raw cosine vs keyword
+   *    score vs normalized IDF) is irrelevant.
+   *  - minmax: min-max normalize each source list's scores to [0,1] then take
+   *    the weighted sum — a scale-aware version of `blend`.
+   * Returns { merged, signals }, where signals is Map<id, {keyword, vector,
+   * bm25}> so searchMemories can decorate rows when signalTransparency is on.
+   */
+  function fuseRecall({ keyword, vector, bm25, lim, mode, wv, wk, wb }) {
+    const recipe = config?.recallFusion ?? "blend";
+
+    // Per-source scores are recorded for every recipe so signalTransparency
+    // works regardless of how the ranking was produced.
+    const signals = new Map();
+    const addSig = (id, field, sc) => {
+      const cur = signals.get(id) ?? {};
+      cur[field] = sc;
+      signals.set(id, cur);
+    };
+    for (const m of keyword) addSig(m.id, "keyword", m.score ?? 0);
+    for (const m of vector) addSig(m.id, "vector", m.score ?? 0);
+    for (const m of bm25) addSig(m.id, "bm25", m.score ?? 0);
+
+    const vectorIds = new Set(vector.map((m) => m.id));
+    const keywordIds = new Set(keyword.map((m) => m.id));
+
+    // Mode contract (aligns rrf/minmax with blend): keyword-only searches must
+    // stay keyword-only regardless of recipe, so enabling an opt-in recipe can
+    // never pull vector/BM25 rows into a mode="keyword" request. This mirrors
+    // the blend branch's `mode === "keyword"` short-circuit (byte-for-byte).
+    if (mode === "keyword") {
+      return { merged: keyword.slice(0, lim), signals };
+    }
+
+    let merged;
+    if (recipe === "rrf") {
+      // Rank-based: only the position of a row inside each surviving source
+      // list matters, so no cross-signal scale calibration is needed.
+      const k = 60; // standard RRF constant (plan #1 documents k=60)
+      const rows = new Map();
+      const addList = (list) => list.forEach((m, idx) => {
+        const s = 1 / (k + idx + 1);
+        const cur = rows.get(m.id);
+        if (cur) cur.score += s;
+        else rows.set(m.id, { ...m, score: s });
+      });
+      addList(keyword);
+      addList(vector);
+      addList(bm25);
+      merged = [...rows.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, lim);
+    } else if (recipe === "minmax") {
+      // Scale-aware weighted sum: each source list is min-max normalized to
+      // [0,1] before blending, so raw cosine and keyword score live on the
+      // same footing.
+      const norm = (list) => {
+        if (!list.length) return new Map();
+        let min = Infinity, max = -Infinity;
+        for (const m of list) { const s = m.score ?? 0; if (s < min) min = s; if (s > max) max = s; }
+        const range = max - min;
+        const out = new Map();
+        for (const m of list) out.set(m.id, range > 0 ? ((m.score ?? 0) - min) / range : 0.5);
+        return out;
+      };
+      const kw = norm(keyword), ve = norm(vector), bm = norm(bm25);
+      const rows = new Map();
+      const seed = (m) => { if (!rows.has(m.id)) rows.set(m.id, { ...m, score: 0 }); };
+      for (const m of keyword) seed(m);
+      for (const m of vector) seed(m);
+      for (const m of bm25) seed(m);
+      for (const [id, row] of rows) {
+        const k = kw.get(id) ?? 0;
+        const v = ve.get(id) ?? 0;
+        const b = bm.get(id) ?? 0;
+        row.score = v * wv + k * wk + b * wb;
+      }
+      merged = [...rows.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, lim);
+    } else {
+      // blend — the pre-existing per-mode behavior, extracted verbatim.
+      if (mode === "keyword") {
+        merged = keyword;
+      } else if (mode === "vector" || mode === "hybrid") {
+        const byId = new Map();
+        for (const m of vector) {
+          const rec = byId.get(m.id);
+          byId.set(m.id, rec ? { ...rec, score: Math.max(rec.score ?? 0, m.score ?? 0) } : m);
+        }
+        for (const m of keyword) {
+          const rec = byId.get(m.id);
+          if (rec) {
+            byId.set(m.id, { ...rec, score: (rec.score ?? 0) * wv + (m.score ?? 0) * wk });
+          } else {
+            byId.set(m.id, m);
+          }
+        }
+        for (const m of bm25) {
+          const rec = byId.get(m.id);
+          if (rec) {
+            if (keywordIds.has(m.id)) continue;
+            byId.set(m.id, { ...rec, score: (rec.score ?? 0) + wb * (m.score ?? 0) });
+          } else {
+            byId.set(m.id, { ...m, score: wb * (m.score ?? 0) });
+          }
+        }
+        const ranked = [...byId.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+        merged = ranked.slice(0, lim);
+        if (merged.length < lim && !merged.length) {
+          merged = keyword.slice(0, lim);
+        }
+      } else {
+        // auto: keyword leads, vector + BM25 fill remaining slots.
+        merged = keyword.slice(0, lim);
+        const seen = new Set(merged.map((m) => m.id));
+        for (const m of vector) {
+          if (merged.length >= lim) break;
+          if (!seen.has(m.id)) { seen.add(m.id); merged.push(m); }
+        }
+        for (const m of bm25) {
+          if (merged.length >= lim) break;
+          if (!seen.has(m.id)) { seen.add(m.id); merged.push(m); }
+        }
+      }
+    }
+
+    // Mode contract, auto (aligns rrf/minmax with blend): keyword leads, the
+    // recipe fills the remaining slots. blend.auto already front-loads keyword;
+    // rrf/minmax rank across sources, so re-apply the same "keyword first"
+    // ordering here to preserve the pre-fusion auto contract — the keyword
+    // hit list keeps its power, and only slots it couldn't fill go to the
+    // recipe's ranking.
+    if (recipe !== "blend" && mode === "auto" && keyword.length) {
+      const head = keyword.slice(0, lim);
+      const seen = new Set(head.map((m) => m.id));
+      const tail = merged.filter((m) => !seen.has(m.id)).slice(0, Math.max(0, lim - head.length));
+      merged = head.concat(tail);
+    }
+
+    return { merged, signals };
+  }
+
+  /**
+   * Search memories for a query. Merges up to three recall sources (keyword,
+   * vector, BM25) according to config.recallFusion (blend/rrf/minmax — see
+   * fuseRecall), then optionally decorates rows with per-source signals
+   * (config.signalTransparency), applies semantic dedup (non-keyword modes),
+   * reranking, and epistemic trust re-weighting, and finally hands the merged
+   * list to the recall-layer recorder.
+   *
+   * options:
+   *   mode          — 'auto' (default) | 'keyword' | 'vector' | 'hybrid'
+   *   topK          — max rows (default 20)
+   *   threshold     — explicit vector score floor (overrides adaptive)
+   *   useRerank     — apply the reranker if available (default true)
+   *   recordRecall  — write a recall_runs audit row (default from config)
+   *
+   * Returns an array of memory rows { id, title, content, score, source, ... },
+   * with `signals` added when config.signalTransparency is on. Never throws:
+   * a vector/rerank failure degrades to keyword results.
+   */
   async function searchMemories(query, options = {}) {
     const { mode = "auto", topK = 20, threshold, useRerank = true, recordRecall = options.recordRecall ?? (config?.recallRecordDefault ?? true) } = options;
     const q = String(query ?? "").trim();
@@ -477,69 +642,17 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // Loose blend weight: BM25 confirms and backfills, never dominates the
     // semantic signal. Same-memory overlap boosts, unseen ids backfill.
     const wb = 0.3;
-    // Path bookkeeping for the boost rule below: which ids each semantic
-    // recall path surfaced.
-    const vectorIds = new Set(vector.map((m) => m.id));
-    const keywordIds = new Set(keyword.map((m) => m.id));
 
     // Hybrid blending weights from config when provided.
     const wv = config?.hybridSearchVectorWeight ?? DEFAULT_HYBRID_WEIGHTS.vector;
     const wk = config?.hybridSearchKeywordWeight ?? DEFAULT_HYBRID_WEIGHTS.keyword;
 
-    let merged;
-    if (mode === "keyword") {
-      merged = keyword;
-    } else if (mode === "vector" || mode === "hybrid") {
-      // semantic-first: vector recalls lead, keyword + BM25 fill remaining
-      // slots. Weighted blend when sides scored the same memory; otherwise
-      // vector order leads (it is the semantic signal), lexical paths
-      // backfill.
-      const byId = new Map();
-      for (const m of vector) {
-        const rec = byId.get(m.id);
-        byId.set(m.id, rec ? { ...rec, score: Math.max(rec.score ?? 0, m.score ?? 0) } : m);
-      }
-      for (const m of keyword) {
-        const rec = byId.get(m.id);
-        if (rec) {
-          // Same memory from both sides: blend the scores.
-          byId.set(m.id, { ...rec, score: (rec.score ?? 0) * wv + (m.score ?? 0) * wk });
-        } else {
-          byId.set(m.id, m);
-        }
-      }
-      for (const m of bm25) {
-        const rec = byId.get(m.id);
-        if (rec) {
-          // Boost rule: a row the LIKE keyword path already hit carries the
-          // query as a substring, so BM25 tokens are trivially present —
-          // boosting it double-counts lexical evidence. Only vector-recalled
-          // rows (lexical hit is genuinely new information) get the boost.
-          if (keywordIds.has(m.id)) continue;
-          byId.set(m.id, { ...rec, score: (rec.score ?? 0) + wb * (m.score ?? 0) });
-        } else {
-          byId.set(m.id, { ...m, score: wb * (m.score ?? 0) });
-        }
-      }
-      const ranked = [...byId.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
-      merged = ranked.slice(0, lim);
-      if (merged.length < lim && !merged.length) {
-        // Vector unavailable entirely: fall back to plain keyword.
-        merged = keyword.slice(0, lim);
-      }
-    } else {
-      // auto: keyword leads, vector + BM25 fill remaining slots (legacy
-      // behavior, extended with the third path)
-      merged = keyword.slice(0, lim);
-      const seen = new Set(merged.map((m) => m.id));
-      for (const m of vector) {
-        if (merged.length >= lim) break;
-        if (!seen.has(m.id)) { seen.add(m.id); merged.push(m); }
-      }
-      for (const m of bm25) {
-        if (merged.length >= lim) break;
-        if (!seen.has(m.id)) { seen.add(m.id); merged.push(m); }
-      }
+    const { merged: fusedMerged, signals } = fuseRecall({ keyword, vector, bm25, lim, mode, wv, wk, wb });
+    let merged = fusedMerged;
+    // Signal transparency (#2): decorate each returned row with its per-source
+    // scores and the final fused score. Purely additive — never changes rank.
+    if (config?.signalTransparency === true) {
+      merged = merged.map((m) => ({ ...m, signals: { ...(signals.get(m.id) ?? {}), final: m.score ?? 0 } }));
     }
 
     // Search-time semantic dedup (v0.5.0 2.3): near-duplicate rows are

package/src/settings.js

@@ -58,6 +58,9 @@ const FEATURE_FLAG_BOOLEANS = [
   "bm25SearchEnabled",
   "conflictFreezeEnabled",
   "trustEpistemicWeighting",
+  // Plan #2: attach per-source {keyword, vector, bm25, final} signals to each
+  // search result for transparency/debugging. Default off, purely decorative.
+  "signalTransparency",
   // Issue #89：宽容校验回归（默认开）+ 跨类型合并显式放宽（默认关）。
   "dreamSkipInvalid",
   "allowCrossTypeMerge",
@@ -86,6 +89,10 @@ const FEATURE_FLAG_STRINGS = [
   // /llm-providers 端点一起提供，留空 = 用巩固模型或当前模型。
   "sleepProvider",
   "sleepModel",
+  // 实体抽取侧专用路由（issue #109）：provider/model 显式指定，
+  // 留空 = 用当前默认模型。
+  "entityExtractionProvider",
+  "entityExtractionModel",
   "localEmbedModel",
   "ollamaModel"
 ];
@@ -94,7 +101,12 @@ const FEATURE_FLAG_STRINGS = [
 const FEATURE_FLAG_URLS = ["ollamaBaseUrl"];
 // 枚举开关（与 config.js 的 z.union(z.const(...)) 对齐）：仅允许列出的值。
 const FEATURE_FLAG_ENUMS = {
-  embedProvider: ["openai", "local", "ollama"]
+  embedProvider: ["openai", "local", "ollama"],
+  // Plan #1: recall fusion recipe. blend = legacy (default); rrf / minmax are
+  // rank/scale-aware alternatives selected by the panel.
+  recallFusion: ["blend", "rrf", "minmax"],
+  // 实体抽取思考强度（issue #109）：与 dreamReasoningEffort 枚举对齐。
+  entityExtractionReasoning: ["low", "medium", "high", "none"]
 };
 const FEATURE_FLAG_STRING_MAX = 200;
 

package/src/store.js

@@ -1023,8 +1023,11 @@ export function createStore(path) {
   }
 
   function embeddedCount() {
+    // Active rows only — getStats pairs this with count() as the status card's
+    // "indexed N / M" denominator, and count() defaults exclude forgotten and
+    // archived memories. Unfiltered, archived rows inflate N past M.
     return db.prepare(
-      "SELECT count(*) AS c FROM memories WHERE embedding IS NOT NULL AND embedding != ''"
+      "SELECT count(*) AS c FROM memories WHERE embedding IS NOT NULL AND embedding != '' AND forgotten = 0 AND archived = 0"
     ).get().c;
   }