@modusensus/dsh-mneme 0.8.5 → 0.8.6

package/src/index.js

@@ -43,7 +43,15 @@ export { Config };
 // 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 }) {
+//
+// Issue #250: it also accounts for itself. Entity extraction is the background
+// LLM path that runs on every memory write, yet it never reached
+// llm_audit_logs — the adapter only ever held an llm handle, so it had no way
+// to call service.saveLlmAudit. It now takes service (+ config for the shared
+// llmAudit.enabled gate) and writes one row per stream attempt, matching the
+// contract of runAuditedLlm in dream.js: a rejected effort attempt records its
+// own error row and the retry records its own success row.
+export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, service, config }) {
   return async function streamEntityText(messages, options = {}) {
     let route = {};
     if (options.provider) route.provider = options.provider;
@@ -58,8 +66,38 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger }) {
       } catch { /* fall through to whatever route we already have */ }
     }
     const effort = options.reasoningEffort;
+    // 没有解析出 provider/model 就没有可归属的模型——与 dream 的 resolveRoute
+    // 无路由早退同口径，那种情况不写审计行。
+    const modelId = route.provider && route.model ? `${route.provider}:${route.model}` : "";
     const tryStream = (withEffort) => {
       let text = "";
+      let inputTokens = 0;
+      let outputTokens = 0;
+      const startedAt = Date.now();
+      const timestamp = new Date(startedAt).toISOString();
+      // 记账是 best-effort：写审计行失败只 warn，绝不反噬抽取本身（CONTRIBUTING
+      // 的 fail-safe 硬约定）。
+      const writeAudit = (status, errorMessage) => {
+        if (config?.llmAudit?.enabled === false || !modelId || typeof service?.saveLlmAudit !== "function") return;
+        try {
+          service.saveLlmAudit({
+            timestamp,
+            trigger_source: "entityExtract",
+            operation_type: "entity_extract",
+            model_id: modelId,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            total_tokens: inputTokens + outputTokens,
+            cost_usd: 0,
+            duration_ms: Date.now() - startedAt,
+            status,
+            error_message: errorMessage,
+            related_memory_ids: []
+          });
+        } catch (auditError) {
+          logger?.warn?.(`dsh-mneme: entity extraction llm audit write failed: ${String(auditError)}`);
+        }
+      };
       return (async () => {
         for await (const chunk of llm.stream({
           ...route,
@@ -68,11 +106,26 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger }) {
           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;
+          // DSH 的 StreamChunk 契约把用量嵌在 chunk.usage（TokenUsage）；兼容直接
+          // 平铺在 chunk 上的旧形态。归一放在这里，下面只需认平铺形状——与
+          // dream.js 的 streamText 同一处理。
+          if (chunk.type === "usage") {
+            const u = chunk.usage ?? chunk;
+            const i = u.input_tokens ?? u.inputTokens ?? u.prompt_tokens ?? u.promptTokens;
+            const o = u.output_tokens ?? u.outputTokens ?? u.completion_tokens ?? u.completionTokens;
+            if (Number.isFinite(i)) inputTokens = i;
+            if (Number.isFinite(o)) outputTokens = o;
+          }
+          if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
+            writeAudit("error", "llm stream aborted or errored");
+            return undefined;
+          }
         }
+        writeAudit("success", null);
         return text;
       })().catch((err) => {
         logger?.warn?.(`[dsh-mneme] entity extraction llm stream failed: ${String(err)}`);
+        writeAudit("error", String(err?.message ?? err));
         return undefined;
       });
     };
@@ -273,6 +326,9 @@ export const apply = (ctx, config) => {
         dimension: cfg.localEmbedDimension,
         device: cfg.localEmbedDevice,
         batchSize: cfg.localEmbedBatchSize,
+        // 池化方式必须与模型的训练口径一致（BGE 系 = CLS）。它既进 embed() 的调用，
+        // 也进 modelHash —— 池化改了就是换向量空间，既有索引会被判失配并重建。
+        pooling: cfg.localEmbedPooling,
         cacheDir: cfg.embedModelCacheDir,
         runtimeDir: cfg.runtimeDir,
         // #188：embedModelMirror 接成 transformers 的下载镜像（此前死配置）。
@@ -403,6 +459,7 @@ export const apply = (ctx, config) => {
       minIntervalMs: (cfg.dreamMinIntervalMinutes ?? 0) * 60000,
       logger: ctx.logger,
       semantic: { embedder, vectorIndex },
+      lastRunAtSeed: store.lastDreamRunAt("auto"),
       onRun: () => (dream ? dream.runDream(ctx, service, cfg) : Promise.resolve({ ok: true, skipped: true }))
     });
     service.setDreamHook(() => dream.maybeSchedule(service));
@@ -419,6 +476,7 @@ export const apply = (ctx, config) => {
       service,
       config: cfg,
       logger: ctx.logger,
+      lastRunAtSeed: store.lastDreamRunAt("sleep"),
       onRun: (signal) => (sleep ? runSleep(ctx, service, cfg, ctx.logger, { embedder, vectorIndex }, signal) : Promise.resolve({ ok: true, skipped: true }))
     });
     service.setSleepHook(() => sleep.noteWrite());
@@ -442,7 +500,11 @@ export const apply = (ctx, config) => {
       const streamEntityText = createEntityStreamAdapter({
         llm: ctx.llm,
         agentDefaultModel: ctx.agentDefaultModel,
-        logger: ctx.logger
+        logger: ctx.logger,
+        // Issue #250: the adapter needs service to write its llm_audit_logs row
+        // (it never had it) and config for the shared llmAudit.enabled gate.
+        service,
+        config: cfg
       });
       service.setEntityExtractor((memory) =>
         extractEntities(memory, { store, config: cfg, callLLM: streamEntityText, logger: ctx.logger })

package/src/local-embedder.js

@@ -21,6 +21,32 @@ function modelHash(model) {
   return `${model}#${hashString(model)}`;
 }
 
+/**
+ * Model families whose embedding is the CLS token rather than a mean over tokens.
+ *
+ * BGE (BAAI/bge-*) is trained that way: the model's own `1_Pooling/config.json`
+ * declares `pooling_mode_cls_token: true` / `pooling_mode_mean_tokens: false`, and
+ * the official README says "select the last hidden state of the first token" plus
+ * L2 normalization. transformers.js's `feature-extraction` defaults to `mean`, so
+ * feeding it a BGE model silently produces slightly-off vectors — no error, just a
+ * worse ranking. This table is the extension point: a family goes in only once its
+ * pooling is confirmed against the model's own `1_Pooling` (or equivalent) config.
+ */
+const CLS_POOLED_MODEL_PATTERNS = [/bge/i];
+
+/**
+ * Resolve the pooling to embed with.
+ *
+ * `auto` (default) picks by model family — BGE → `cls`, everything else → `mean`,
+ * so models that were never affected keep their exact previous behavior. An
+ * explicit `cls` / `mean` wins over the family table.
+ */
+export function resolvePooling(pooling, model) {
+  const mode = String(pooling ?? "auto").trim().toLowerCase();
+  if (mode === "cls" || mode === "mean") return mode;
+  return CLS_POOLED_MODEL_PATTERNS.some((re) => re.test(String(model ?? ""))) ? "cls" : "mean";
+}
+
 /**
  * Lazy default loader: dynamic import keeps module load cheap.
  *
@@ -71,8 +97,9 @@ function tensorToRows(tensor) {
 
 /**
  * ONNX text embedder backed by transformers.js (onnxruntime-node underneath).
- * Runs fully offline with mean pooling + L2 normalization for BERT-style
- * models like bge-small-zh. `engineFactory` is injectable for tests.
+ * Runs fully offline; pooling is resolved per model family (BGE → CLS, else mean —
+ * see resolvePooling) and vectors are L2-normalized. `engineFactory` is injectable
+ * for tests.
  */
 export class LocalEmbedder {
   constructor(opts = {}) {
@@ -87,6 +114,10 @@ export class LocalEmbedder {
     // （含测试）保持裸 fetch 的现状，配置默认值由 index.js 传进来。
     this.resilientModelDownload = opts.resilientModelDownload === true;
     this.useDtype = opts.useDtype || "q8";
+    // 池化：配置值（auto/cls/mean）→ 生效值（cls/mean）。解析结果既进 embed()，
+    // 也进 modelHash —— 换池化就是换向量空间，旧索引必须被判失配后重建。
+    this.poolingMode = String(opts.pooling ?? "auto").trim().toLowerCase();
+    this.pooling = resolvePooling(this.poolingMode, this.model);
     // 模型镜像下载源（embedModelMirror，#188 补充）：空 = transformers 默认。
     this.remoteHost = String(opts.remoteHost ?? "").trim();
     this.logger = opts.logger ?? null;
@@ -114,19 +145,19 @@ export class LocalEmbedder {
     this.extractor = await this.engineFactory("feature-extraction", this.model, options);
     this.ready = true; // service reads this to flush queued re-embeds
     this.logger?.info?.(
-      `[dsh-mneme] local embedder ready: ${this.model} (dim=${this._dimension}, device=${this.device})`
+      `[dsh-mneme] local embedder ready: ${this.model} (dim=${this._dimension}, device=${this.device}, pooling=${this.pooling})`
     );
     return this;
   }
 
-  /** Embed many texts with mean pooling; chunks at batchSize. */
+  /** Embed many texts with the model's pooling; chunks at batchSize. */
   async embed(texts) {
     if (!Array.isArray(texts)) throw new TypeError("embed expects an array of strings");
     if (!this.extractor) throw new Error("LocalEmbedder not initialized");
     const out = [];
     for (let i = 0; i < texts.length; i += this.batchSize) {
       const chunk = texts.slice(i, i + this.batchSize);
-      const tensor = await this.extractor(chunk, { pooling: "mean", normalize: true });
+      const tensor = await this.extractor(chunk, { pooling: this.pooling, normalize: true });
       out.push(...tensorToRows(tensor));
     }
     return out;
@@ -142,7 +173,14 @@ export class LocalEmbedder {
   }
 
   get modelHash() {
-    return modelHash(this.model);
+    // Pooling is part of the vector space: a CLS index cannot be queried with mean
+    // vectors (or vice versa). Keep the historical `model#hash` shape for `mean` so
+    // indexes that were never affected are not invalidated needlessly; every other
+    // pooling gets a fingerprint of its own, which makes the index-consistency gate
+    // flag the stale mean-space index and rebuild it.
+    return this.pooling === "mean"
+      ? modelHash(this.model)
+      : modelHash(`${this.model}@${this.pooling}`);
   }
 
   dispose() {

package/src/settings.js

@@ -172,8 +172,10 @@ const FEATURE_FLAG_ENUMS = {
   summarizeDedupeMode: ["off", "title", "vector"],
   // Issue #126：sleep 冲突阶段的动作集（conflict 默认 = 现状；full = 六分支）。
   sleepActionSet: ["conflict", "full"],
-  // Issue #125：dream 候选集构造方式（window 默认 = 现状；hybrid 并入向量组）。
-  dreamCandidateMode: ["window", "hybrid"]
+    // Issue #125：dream 候选集构造方式（window 默认 = 现状；hybrid 并入向量组）。
+    dreamCandidateMode: ["window", "hybrid"],
+    // 本地嵌入池化：auto = 按模型族判定（BGE → cls），可显式覆盖为 cls / mean。
+    localEmbedPooling: ["auto", "cls", "mean"]
 };
 const FEATURE_FLAG_STRING_MAX = 200;
 

package/src/store.js

@@ -1532,6 +1532,22 @@ export function createStore(path) {
     return rows.map(toDreamRun);
   }
 
+  // Issue #89：上次实际开跑时刻（epoch ms），从审计表恢复——调度器的 lastRunAt
+  // 只活在内存里，进程重启即归零，闸门对新实例放行 → 重启后立刻连发。审计表
+  // 本来就逐 run 落库（failed/degraded 也算 run），直接读它就是事实源，零迁移。
+  function lastDreamRunAt(runType = null) {
+    const row = runType
+      ? db.prepare(
+          "SELECT created_at FROM dream_runs WHERE run_type = ? ORDER BY created_at DESC, id LIMIT 1"
+        ).get(runType)
+      : db.prepare(
+          "SELECT created_at FROM dream_runs ORDER BY created_at DESC, id LIMIT 1"
+        ).get();
+    if (!row?.created_at) return 0;
+    const ms = Date.parse(row.created_at);
+    return Number.isFinite(ms) ? ms : 0;
+  }
+
   /**
    * Latest ruling-rule version seen on the audit trail. policy_epoch is a config
    * value stamped onto each run by the caller; reading the newest row's epoch
@@ -2486,6 +2502,7 @@ export function createStore(path) {
     needsEmbedding,
     searchVector,
     saveDreamRun,
+    lastDreamRunAt,
     getDreamRun,
     listDreamRuns,
     getLatestPolicyEpoch,

package/test/api.test.js

@@ -663,8 +663,9 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   // issue #257 新增 sleepMaxTokens、issue #258 新增总览路由两键与
   // dreamSummaryMaxInputs、issue #230 新增 documentMemoryEnabled/
   // documentInjectBudget、issue #249 第一批新增 injectGuidanceEnabled/
-  // pinnedInjectBudget，v0.8.5 新增 disableMemorySearch/disableMemoryArchive）
-  assert.equal(Object.keys(data.effective).length, 59 + 3 + 2 + 1 + 2 + 2 + 2);
+  // pinnedInjectBudget，v0.8.5 新增 disableMemorySearch/disableMemoryArchive，
+  // 本地嵌入池化新增 localEmbedPooling）
+  assert.equal(Object.keys(data.effective).length, 59 + 3 + 2 + 1 + 2 + 2 + 2 + 1);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMinIntervalMinutes, 0);

package/test/lastrunat-persist.test.js

@@ -0,0 +1,101 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler } from "../src/dream.js";
+import { createSleepScheduler } from "../src/dream/sleep.js";
+
+// 回归（issue #89）：调度器的 lastRunAt 只活在内存里，进程重启即归零——
+// 最小间隔/冷却闸对新实例放行，重启后 autoDream/sleep 立即连发（Sample A/C 的
+// 根因）。修复 = 构造调度器时从 dream_runs 审计表恢复种子（store.lastDreamRunAt，
+// failed/degraded 也算 run，审计表本来就是逐 run 落库）。本文件锁三点：
+//   1. lastDreamRunAt 读回最近一次 run 的开跑时刻（含 run_type 过滤）；
+//   2. dream 调度器带种子构造后，重启场景下最小间隔闸门立即生效；
+//   3. sleep 调度器带种子构造后，冷却期内不起跑、且按剩余窗口重排不丢触发权。
+
+test("issue#89: store.lastDreamRunAt recovers the last run timestamp (with run_type filter)", () => {
+  const store = createStore(":memory:");
+  assert.equal(store.lastDreamRunAt(), 0, "empty trail → 0 (never ran)");
+  assert.equal(store.lastDreamRunAt("sleep"), 0);
+  store.saveDreamRun({ status: "ok", snapshot_hash: "h1", input_count: 1, receipt: "r", created_at: "2026-09-10T01:05:23.640Z", run_type: "auto" });
+  store.saveDreamRun({ status: "ok", snapshot_hash: "h2", input_count: 1, receipt: "r", created_at: "2026-09-09T20:00:00.000Z", run_type: "sleep" });
+  assert.equal(store.lastDreamRunAt(), Date.parse("2026-09-10T01:05:23.640Z"), "latest run regardless of type");
+  assert.equal(store.lastDreamRunAt("sleep"), Date.parse("2026-09-09T20:00:00.000Z"), "filtered by run_type");
+  assert.equal(store.lastDreamRunAt("auto"), Date.parse("2026-09-10T01:05:23.640Z"), "auto filter ignores sleep rows");
+  store.close();
+});
+
+test("issue#89: dream scheduler seeded from the audit trail — restart no longer bypasses the min interval", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  // 模拟上一进程刚跑过一轮（10ms 前开跑）并留下审计行，然后「重启」：
+  // minIntervalMs 取 1min——断言窗口远宽于用例执行时间，真实时钟抖动（调度、
+  // 慢盘）不会把 10ms 偏移推出闸门外造成间歇性假失败。
+  store.saveDreamRun({
+    status: "ok", snapshot_hash: "h", input_count: 1, receipt: "r",
+    created_at: new Date(Date.now() - 10).toISOString(), run_type: "auto"
+  });
+  const dream = createDreamScheduler({
+    onRun: async () => ({ ok: false, error: "llm failed" }),
+    thresholdCount: 1, thresholdChars: 0, delayMs: 0, minIntervalMs: 60000,
+    lastRunAtSeed: store.lastDreamRunAt("auto"),
+    logger: { warn: () => {} }
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  // 无种子时这里会返回 true（旧缺陷：重启后立刻连发）；带种子必须被闸门拦下。
+  assert.equal(dream.maybeSchedule(service), false, "seeded gate blocks immediately after 'restart'");
+  store.close();
+});
+
+test("issue#89: sleep scheduler seeded — cooldown survives a restart", async () => {
+  let nowMs = 1_000_000;
+  const timers = [];
+  let seq = 1;
+  let runs = 0;
+  const lastRunAt = nowMs - 10 * 60_000; // 上一进程 10 分钟前跑过，CD 1h 还剩 50min
+  const sched = createSleepScheduler({
+    service: { enqueue: (fn) => fn() },
+    config: { sleepModeEnabled: true, sleepIdleMinutes: 5, sleepMinIntervalHours: 1 },
+    logger: { warn: () => {} },
+    onRun: async () => { runs++; return { ok: true }; },
+    now: () => nowMs,
+    lastRunAtSeed: lastRunAt,
+    setTimeoutFn: (fn, delay) => { const t = { id: seq++, at: nowMs + delay, fn }; timers.push(t); return t.id; },
+    clearTimeoutFn: (id) => { const i = timers.findIndex((t) => t.id === id); if (i >= 0) timers.splice(i, 1); }
+  });
+  nowMs += 1000;
+  sched.noteWrite(); // 挂 idle 闹钟
+  const idleTimer = timers[0];
+  assert.ok(idleTimer, "idle timer armed on write");
+  nowMs = idleTimer.at;
+  timers.length = 0;
+  await idleTimer.fn();
+  assert.equal(runs, 0, "restored cooldown blocks the run");
+  const rearm = timers[0];
+  assert.ok(rearm, "re-armed for the remaining cooldown window (not dropped, #187 semantics)");
+  assert.equal(rearm.at, lastRunAt + 3_600_000 + 1000, "re-arms at CD expiry (+1s guard)");
+});
+
+// --- CodeRabbit #291 findings 5/6：index.js 的 seed 注入是单行无分支接线，仓库
+// 没有插件级挂载 harness（apply 需要完整宿主 ctx），起全量挂载只为准两条断言
+// 不成比例——改为源码级锁：删掉 index.js 的对应注入行即红。import 用绝对路径，
+// 不依赖测试进程 CWD。
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+const indexSrc = readFileSync(fileURLToPath(new URL("../src/index.js", import.meta.url)), "utf8");
+
+test("issue#89: index.js wires the dream scheduler seed from the audit trail", () => {
+  assert.match(
+    indexSrc,
+    /lastRunAtSeed:\s*store\.lastDreamRunAt\("auto"\)/,
+    "dream scheduler must seed its min-interval gate from dream_runs (run_type='auto') — remove this line and restart-bypass returns"
+  );
+});
+
+test("issue#89: index.js wires the sleep scheduler seed from the audit trail", () => {
+  assert.match(
+    indexSrc,
+    /lastRunAtSeed:\s*store\.lastDreamRunAt\("sleep"\)/,
+    "sleep scheduler must seed its cooldown gate from dream_runs (run_type='sleep') — remove this line and restart-bypass returns"
+  );
+});

package/test/llm-audit.test.js

@@ -7,6 +7,7 @@ import { createDreamScheduler } from "../src/dream.js";
 import { createSummarizer } from "../src/summarize.js";
 import { createApi } from "../src/api.js";
 import { createSettings } from "../src/settings.js";
+import { createEntityStreamAdapter } from "../src/index.js";
 import { mockCtx } from "./helpers/dream-mock.js";
 
 // Bug8: LLM audit trail. Every background LLM call (autoDream consolidation +
@@ -460,3 +461,96 @@ test("GET /api/dsh-mneme/semantic/llm-audit/stats aggregates by source and statu
   assert.equal(errStatus.c, 1);
   store.close();
 });
+
+// ------------------------------------------- entity extraction (issue #250)
+// 实体抽取是「每次写入记忆都会跑」的后台 LLM 链路，但 createEntityStreamAdapter
+// 只拿到 llm 句柄、没有 service，所以从来没有写审计的能力——面板因此回答不了
+// 「关掉实体抽取能省多少」。下面两条用例锁定 usage chunk 汇总落库，以及审计写失败
+// 只 warn 不反噬（CONTRIBUTING 的 fail-safe 硬约定）。
+
+test("entity extraction writes an llm_audit row with the streamed usage tokens", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: '{"entities":[],"relations":[]}' };
+        yield { type: "usage", usage: { inputTokens: 700, outputTokens: 180, totalTokens: 880 } };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service
+  });
+  const text = await streamEntityText(
+    [{ role: "user", content: [{ type: "text", text: "记忆内容" }] }],
+    {}
+  );
+  assert.ok(text.includes("entities"), "the extracted text still reaches the extractor");
+
+  const row = service.listLlmAudits({ source: "entityExtract" })[0];
+  assert.ok(row, "entity_extract audit row present");
+  assert.equal(row.trigger_source, "entityExtract");
+  assert.equal(row.operation_type, "entity_extract");
+  assert.equal(row.status, "success");
+  assert.equal(row.model_id, "mock:mock-model", "the resolved route is recorded");
+  assert.equal(row.input_tokens, 700, "input tokens come from chunk.usage");
+  assert.equal(row.output_tokens, 180, "output tokens come from chunk.usage");
+  assert.equal(row.total_tokens, 880);
+  store.close();
+});
+
+test("entity extraction audit write failure only warns and never sinks the extraction", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  // 审计表写不进去（只读库 / 磁盘满）绝不能把抽取本身拖失败—— fail-safe 是硬约定。
+  service.saveLlmAudit = () => { throw new Error("attempt to write a readonly database"); };
+  const warnings = [];
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: '{"entities":[],"relations":[]}' };
+        yield { type: "usage", usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 } };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: (m) => warnings.push(String(m)) },
+    service
+  });
+  const text = await streamEntityText(
+    [{ role: "user", content: [{ type: "text", text: "记忆内容" }] }],
+    {}
+  );
+  assert.ok(text.includes("entities"), "extraction text survives an audit write failure");
+  assert.ok(warnings.some((w) => w.includes("llm audit write failed")),
+    "the audit failure is logged rather than swallowed silently");
+  store.close();
+});
+
+test("entity extraction writes no audit row when llmAudit.enabled === false", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const streamEntityText = createEntityStreamAdapter({
+    llm: {
+      async *stream() {
+        yield { type: "text-delta", index: 0, text: '{"entities":[],"relations":[]}' };
+        yield { type: "usage", usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 } };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    logger: { warn: () => {} },
+    service,
+    // 单闸门：与 dream / sleep / summarize 同一个 llmAudit.enabled，不新增第二道。
+    config: { llmAudit: { enabled: false } }
+  });
+  const text = await streamEntityText(
+    [{ role: "user", content: [{ type: "text", text: "记忆内容" }] }],
+    {}
+  );
+  assert.ok(text.includes("entities"), "turning the audit off must not break extraction");
+  assert.equal(service.listLlmAudits().length, 0, "no audit rows when disabled");
+  store.close();
+});

package/test/local-embedder.test.js

@@ -79,7 +79,7 @@ test("LocalEmbedder init threads resilientModelDownload and logger to engineFact
   assert.equal(seen.resilientModelDownload, false, "直连构造不显式给 true = 保持现状");
 });
 
-test("LocalEmbedder embed returns [n, dim] with mean pooling and chunking", async () => {
+test("LocalEmbedder embed returns [n, dim] with the model's pooling and chunking", async () => {
   const calls = [];
   const e = new LocalEmbedder({
     model: "Xenova/bge-small-zh-v1.5",
@@ -95,6 +95,18 @@ test("LocalEmbedder embed returns [n, dim] with mean pooling and chunking", asyn
   }
   // 3 texts at batchSize 2 -> two extractor calls.
   assert.deepEqual(calls.map((c) => c.count), [2, 1]);
+  // BGE 系按 CLS 训练（模型自带 1_Pooling/config.json: pooling_mode_cls_token=true）
+  assert.deepEqual(calls[0].opts, { pooling: "cls", normalize: true });
+});
+
+test("LocalEmbedder keeps mean pooling for models outside the CLS families", async () => {
+  const calls = [];
+  const e = new LocalEmbedder({
+    model: "sentence-transformers/all-MiniLM-L6-v2",
+    engineFactory: async () => makeFakeExtractor(384, calls)
+  });
+  await e.init();
+  await e.embed(["x"]);
   assert.deepEqual(calls[0].opts, { pooling: "mean", normalize: true });
 });
 
@@ -105,14 +117,45 @@ test("LocalEmbedder embedSingle returns a single vector", async () => {
   assert.equal(v.length, 384);
 });
 
+test("LocalEmbedder resolves pooling by model family, explicit value wins", async () => {
+  const cases = [
+    [{ model: "Xenova/bge-small-zh-v1.5" }, "cls", "BGE 默认 cls"],
+    [{ model: "BAAI/bge-m3" }, "cls", "BGE 大小写无关"],
+    [{ model: "sentence-transformers/all-MiniLM-L6-v2" }, "mean", "非 BGE 族保持 mean"],
+    [{ model: "Xenova/bge-small-zh-v1.5", pooling: "mean" }, "mean", "显式覆盖 auto"],
+    [{ model: "sentence-transformers/all-MiniLM-L6-v2", pooling: "cls" }, "cls", "显式覆盖非 BGE"],
+    [{ model: "Xenova/bge-small-zh-v1.5", pooling: "AUTO" }, "cls", "大小写/空白容错"],
+    [{ model: "Xenova/bge-small-zh-v1.5", pooling: " bogus " }, "cls", "未知值退回 auto"]
+  ];
+  for (const [opts, expected, why] of cases) {
+    const calls = [];
+    const e = new LocalEmbedder({ ...opts, engineFactory: async () => makeFakeExtractor(512, calls) });
+    assert.equal(e.pooling, expected, why);
+    await e.init();
+    await e.embed(["x"]);
+    assert.equal(calls[0].opts.pooling, expected, `${why}: 必须真的传进 extractor`);
+  }
+});
+
 test("LocalEmbedder dimension and modelHash are stable", () => {
   const a = new LocalEmbedder({ model: "Xenova/bge-small-zh-v1.5" });
   const b = new LocalEmbedder({ model: "Xenova/bge-small-zh-v1.5" });
   assert.equal(a.dimension, 512);
   assert.equal(a.modelHash, b.modelHash);
-  assert.match(a.modelHash, /^Xenova\/bge-small-zh-v1\.5#[0-9a-f]+$/);
+  // BGE 解析为 cls，且池化进指纹（否则旧索引不会被判失配、不会重建）
+  assert.match(a.modelHash, /^Xenova\/bge-small-zh-v1\.5@cls#[0-9a-f]+$/);
   // Different model -> different hash.
   assert.notEqual(a.modelHash, new LocalEmbedder({ model: "other/model" }).modelHash);
+  // 显式 mean 保持历史指纹形状，不给未受影响的索引制造无谓重建
+  assert.match(
+    new LocalEmbedder({ model: "Xenova/bge-small-zh-v1.5", pooling: "mean" }).modelHash,
+    /^Xenova\/bge-small-zh-v1\.5#[0-9a-f]+$/
+  );
+  // 两种池化是不同向量空间，绝不能共用一个指纹
+  assert.notEqual(
+    a.modelHash,
+    new LocalEmbedder({ model: "Xenova/bge-small-zh-v1.5", pooling: "mean" }).modelHash
+  );
 });
 
 test("LocalEmbedder throws before init and after dispose", async () => {