@modusensus/dsh-mneme 0.7.31 → 0.8.0

package/test/inject.test.js

@@ -105,12 +105,15 @@ test("Bug6: injected block stays within the ~1500 char budget, later entries col
 // DSH ≥0.1.2-rc removed Session.events; events are only reachable via
 // snapshotEvents(). Regression for #59: the hot block must still render from
 // a session object that has no .events property.
+// 注意：assistant/message 的消息体在 data.message 下（见 Issue #129），夹具必须用这个
+// 真实形状 —— 原先的夹具写的是 data.content，与当时有 bug 的实现是同一个错误假设，
+// 所以它永远抓不到这个回归。
 test("extracts hot rounds from snapshotEvents() when Session.events is absent", () => {
   const { contexts } = setup();
   const session = {
     snapshotEvents: () => [
       { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "怎么修图谱面板" }] } },
-      { type: "assistant/message", data: { content: [{ type: "text", text: "用 viewBox 单位跑模拟" }] } }
+      { type: "assistant/message", data: { message: { content: [{ type: "text", text: "用 viewBox 单位跑模拟" }] } } }
     ]
   };
   const text = contexts[0].text({ agent: { session } });
@@ -118,3 +121,129 @@ test("extracts hot rounds from snapshotEvents() when Session.events is absent",
   assert.ok(text.includes("怎么修图谱面板"), "round query present");
   assert.ok(text.includes("用 viewBox 单位跑模拟"), "round response present");
 });
+
+// Issue #129 的复现：assistant 轮的正文取自 data.message.content。修复前 textOf 只读
+// data.content，于是每一轮的 response 都落成空串 —— 表现为「N 轮 A 全空」。
+test("Issue #129: response 取自 data.message.content，N 轮不再出现空 A", () => {
+  const { contexts } = setup();
+  const session = {
+    snapshotEvents: () => [
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "第一个问题" }] } },
+      { type: "assistant/message", data: { message: { content: [{ type: "text", text: "第一个回答" }] } } },
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "第二个问题" }] } },
+      { type: "assistant/message", data: { message: { content: [{ type: "text", text: "第二个回答" }] } } }
+    ]
+  };
+  const text = contexts[0].text({ agent: { session } });
+  for (const s of ["第一个问题", "第一个回答", "第二个问题", "第二个回答"]) {
+    assert.ok(text.includes(s), `hot block 应包含 ${s}`);
+  }
+});
+
+// 修复用的是 ?? 兜底而非破坏性替换：扁平的 data.content 形状（user 消息一贯如此，
+// 历史事件也可能如此）必须继续可用。
+test("Issue #129: 扁平的 data.content 形状仍被兼容", () => {
+  const { contexts } = setup();
+  const session = {
+    snapshotEvents: () => [
+      { type: "user/message", data: { source: { kind: "user" }, content: [{ type: "text", text: "问题" }] } },
+      { type: "assistant/message", data: { content: [{ type: "text", text: "扁平形状的回答" }] } }
+    ]
+  };
+  const text = contexts[0].text({ agent: { session } });
+  assert.ok(text.includes("问题"), "query present");
+  assert.ok(text.includes("扁平形状的回答"), "flat content shape still supported");
+});
+
+// ---- issue #162: 注入边界花括号转义(v0.7.4 #40 修复被 v0.7.11 误删后恢复) ----
+
+test("issue #162: {{...}} in memory content is escaped at the injection boundary", () => {
+  const { contexts, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "模板记忆", content: "{{hl|highlight}} 和 {{挖空}} {{关键词}}", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("模板记忆"), "memory still rendered by title");
+  assert.ok(text.includes("{\\{hl|highlight}\\}"), "ASCII template braces escaped");
+  assert.ok(text.includes("{\\{挖空}\\}"), "CJK template braces escaped");
+  assert.ok(!text.includes("{{"), "no raw {{ survives into the prompt");
+  assert.ok(!text.includes("}}"), "no raw }} survives into the prompt");
+});
+
+test("issue #162: odd brace runs like {{{a}}} are escaped too", () => {
+  const { contexts, service } = setup();
+  service.saveWithDedupe({ type: "preference", title: "三层模板", content: "{{{a}}} 和 }}} 结尾", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(!text.includes("{{"), "no raw {{ for odd brace runs");
+  assert.ok(!text.includes("}}"), "no raw }} for odd brace runs");
+});
+
+test("issue #162: {{...}} in user profile/rules is escaped", () => {
+  const { contexts, settings } = setup();
+  settings.setProfile("我叫{{名字}}，前端开发者");
+  settings.setRules(["回答时用 {{hl|term}}", "以 }} 结尾的规则"]);
+  const settingsCtx = contexts.find((c) => c.name === "user-settings");
+  const text = settingsCtx.text({});
+  assert.ok(text.includes("{\\{名字}\\}"), "profile braces escaped");
+  assert.ok(text.includes("{\\{hl|term}\\}"), "rule braces escaped");
+  assert.ok(!text.includes("{{"), "no raw {{ in user-settings block");
+  assert.ok(!text.includes("}}"), "no raw }} in user-settings block");
+});
+
+test("issue #162: hot-context rounds with {{...}} are escaped", () => {
+  const { contexts } = setup();
+  const text = contexts[0].text({
+    agent: {
+      session: {
+        id: "s1",
+        events: [
+          { type: "user/message", data: { source: { kind: "user" }, content: ["用 {{hl|你好}} 测试"] } },
+          { type: "assistant/message", data: { source: { kind: "assistant" }, content: ["返回 {{答案}}"] } }
+        ]
+      }
+    }
+  });
+  assert.ok(text.includes("[短期上下文]"), "hot context rendered");
+  assert.ok(!text.includes("{{"), "no raw {{ in hot context");
+  assert.ok(!text.includes("}}"), "no raw }} in hot context");
+});
+
+test("issue #162: reasoning parts are excluded from hot memory (docker --format case)", () => {
+  const { contexts } = setup();
+  // issue #162 的触发源：assistant 的 reasoning part 是 { type: "reasoning", text }
+  // 结构，内容里出现 docker --format "{{.Server.Version}}" 时，若被注入 hot memory
+  // 会让 DSH interpolate() 扫到非法变量名 throw → 整轮永久失败。textOf 必须跳过它。
+  const text = contexts[0].text({
+    agent: {
+      session: {
+        id: "s1",
+        events: [
+          { type: "user/message", data: { source: { kind: "user" }, content: ["检查 docker 版本"] } },
+          {
+            type: "assistant/message",
+            data: {
+              source: { kind: "assistant" },
+              content: [
+                { type: "reasoning", text: "运行 docker version --format \"{{.Server.Version}}\" 查看版本" },
+                { type: "text", text: "已检查，Docker 版本 27.1.1。" }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  });
+  // reasoning 不应进入 hot memory
+  assert.ok(!text.includes("Server.Version"), "reasoning text excluded from hot memory");
+  // 正文保留
+  assert.ok(text.includes("27.1.1"), "assistant text part still injected");
+  // 整个注入块没有任何原始 {{ (双保险：即使将来 reasoning 被引入，也会被转义)
+  assert.ok(!text.includes("{{"), "no raw {{ anywhere in injected context");
+  assert.ok(!text.includes("}}"), "no raw }} anywhere in injected context");
+});
+
+test("issue #162: escapePromptVariables=false passes {{...}} through verbatim", () => {
+  const { contexts, service } = setup({ escapePromptVariables: false });
+  service.saveWithDedupe({ type: "preference", title: "模板", content: "{{挖空}} 与 {{hl|term}}", importance: 5 });
+  const text = contexts[0].text({});
+  assert.ok(text.includes("{{挖空}}"), "raw braces preserved when escaping disabled");
+  assert.ok(text.includes("{{hl|term}}"), "raw ASCII braces preserved when escaping disabled");
+});

package/test/lang.test.js

@@ -0,0 +1,87 @@
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { STR, langOf } from "../src/lang.js";
+import { createMirror, parseHumanEdits, renderMirrorText } from "../src/mirror.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+
+test("langOf resolves the per-instance config language", () => {
+  assert.equal(langOf({}), "zh");
+  assert.equal(langOf({ language: "zh" }), "zh");
+  assert.equal(langOf({ language: "en" }), "en");
+  assert.equal(langOf({ language: "fr" }), "zh");
+  assert.equal(langOf(null), "zh");
+});
+
+test("prompt table resolves by explicit language key", () => {
+  assert.ok(STR.prompts.summary.zh.includes("记忆库提炼助手"));
+  assert.ok(STR.prompts.summary.en.includes("memory curation assistant"));
+  assert.ok(STR.prompts.consolidation.zh.includes("记忆库整理助手"));
+  assert.ok(STR.prompts.consolidation.en.includes("consolidation assistant"));
+  assert.ok(STR.prompts.conflict.zh.includes("冲突仲裁"));
+  assert.ok(STR.prompts.conflict.en.includes("conflict arbiter"));
+  assert.ok(STR.prompts.pattern.zh.includes("模式发现助手"));
+  assert.ok(STR.prompts.pattern.en.includes("pattern-discovery assistant"));
+  // 冻结模式后缀：纯提示文本，可直接拼接在巩固 prompt 后。
+  assert.ok(STR.prompts.freezeSuffix.zh.startsWith("\n\n当前为「冲突冻结」模式"));
+  assert.ok(STR.prompts.freezeSuffix.en.startsWith("\n\nConflict-freeze mode is active"));
+  // 无 JS 语法残留：不携带 const 声明、模板字面量包裹或拼接片段。
+  for (const [key, pair] of Object.entries(STR.prompts)) {
+    for (const [lang, text] of Object.entries(pair)) {
+      assert.ok(!text.startsWith("const ") && !text.startsWith("? ")
+        && !text.endsWith("`;") && !text.endsWith("`"),
+        `${key}.${lang} must not carry JS syntax`);
+    }
+  }
+});
+
+test("two injectors with different language configs render independently", () => {
+  function setup(language) {
+    const store = createStore(":memory:");
+    const service = createService({ store, mirror: null, config: {} });
+    const settings = createSettings(store.db);
+    const contexts = [];
+    const ctx = { systemPrompt: { context(def) { contexts.push(def); } } };
+    createInjector(ctx, service, settings, { maxInjectedItems: 3, importanceThreshold: 3, language });
+    service.saveWithDedupe({ type: "preference", title: "lang", content: "value", importance: 5 });
+    return { store, contexts };
+  }
+  const en = setup("en");
+  const zh = setup("zh");
+  try {
+    assert.ok(en.contexts[0].text({}).includes("[Memory]"), "en instance renders English header");
+    assert.ok(zh.contexts[0].text({}).includes("[记忆库]"), "zh instance renders Chinese header");
+  } finally {
+    en.store.close();
+    zh.store.close();
+  }
+});
+
+test("mirror render follows the instance language; parser accepts both", () => {
+  const memory = { id: "m1", type: "preference", title: "t", content: "c", importance: 5, tags: [], updated_at: "2026-01-01" };
+  const enText = renderMirrorText("preference", [memory], "en");
+  const zhText = renderMirrorText("preference", [memory], "zh");
+  assert.ok(enText.includes("- **Type**: preference"));
+  assert.ok(zhText.includes("- **类型**: preference"));
+  const edits = parseHumanEdits(enText + "\n" + zhText);
+  assert.deepEqual(
+    edits.map((e) => e.id),
+    ["m1", "m1"]
+  );
+  assert.equal(edits[1].content, "c");
+});
+
+test("dream summary keeps one row across a language switch (stable source identity)", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  service.saveWithDedupe({ type: "summary", title: "记忆库总览", content: "zh overview", importance: 5, source: "dream", _overwrite: true });
+  service.saveWithDedupe({ type: "summary", title: "Memory library overview", content: "en overview", importance: 5, source: "dream", _overwrite: true });
+  const summaries = store.all().filter((m) => m.type === "summary" && !m.archived);
+  assert.equal(summaries.length, 1);
+  assert.equal(summaries[0].title, "Memory library overview");
+  assert.equal(summaries[0].content, "en overview");
+  store.close();
+});

package/test/quality-filter.test.js

@@ -116,3 +116,71 @@ test("exported helpers behave (meta regex, similarity, dedup ratio)", () => {
   assert.ok(dedupRatio("哈哈哈哈哈哈") < 0.3, "repetitive filler has low dedup ratio");
   assert.ok(dedupRatio("一句信息量足够的话") > 0.3);
 });
+
+// --- Issue #135 附属发现 1：importance ≥ exemptImportance 只降权，不静默归档 ----
+
+test("Issue #135: importance-5 memory below archive threshold is demoted, not archived", () => {
+  const { store, service } = setup();
+  const { memory } = service.saveWithDedupe({
+    type: "preference", title: "关键决策", content: "短", importance: 5
+  });
+  const got = store.getById(memory.id);
+  assert.equal(got.archived, false, "importance 5 >= exemptImportance 4 → kept active");
+  assert.ok(got.quality_score < 30, `score still persisted, got ${got.quality_score}`);
+  assert.ok(got.tags.includes("low_quality"), "signal tag still written (verdict observable)");
+});
+
+test("Issue #135: importance-4 is exempt by default; importance-3 is still archived", () => {
+  const { store, service } = setup();
+  const four = service.saveWithDedupe({ type: "preference", title: "决策甲", content: "短", importance: 4 }).memory;
+  const three = service.saveWithDedupe({ type: "preference", title: "决策乙", content: "短", importance: 3 }).memory;
+  assert.equal(store.getById(four.id).archived, false, "importance 4 exempt by default");
+  assert.equal(store.getById(three.id).archived, true, "importance 3 below the floor still archived");
+});
+
+test("Issue #135: exemptImportance=1 disables auto-archive; =5 narrows the floor", () => {
+  const one = setup({ memoryQualityFilter: { enabled: true, exemptImportance: 1 } });
+  const threeLow = one.service.saveWithDedupe({ type: "preference", title: "语言", content: "短", importance: 3 }).memory;
+  assert.equal(one.store.getById(threeLow.id).archived, false, "exemptImportance 1 exempts everything");
+
+  const five = setup({ memoryQualityFilter: { enabled: true, exemptImportance: 5 } });
+  const four = five.service.saveWithDedupe({ type: "preference", title: "决策甲", content: "短", importance: 4 }).memory;
+  assert.equal(five.store.getById(four.id).archived, true, "importance 4 no longer exempt at floor 5");
+});
+
+// --- Issue #135 附属发现 2：update 的 tags 整组替换不再抹掉系统信号标签 --------
+
+test("Issue #135: update with tags preserves the filter's signal tags", () => {
+  const { store, service } = setup();
+  const { memory } = service.saveWithDedupe({ type: "preference", title: "语言", content: "短" });
+  assert.ok(store.getById(memory.id).tags.includes("low_quality"), "precondition: filter tagged the row");
+
+  service.update(memory.id, { tags: ["用户标签"], content: "补充后的完整内容，不再是短文本了" });
+  const after = store.getById(memory.id);
+  assert.ok(after.tags.includes("用户标签"), "user tags applied");
+  assert.ok(after.tags.includes("low_quality"), "low_quality preserved through the update");
+  assert.ok(after.tags.includes("short_content"), "short_content preserved too");
+});
+
+test("Issue #135: update without tags leaves the row untouched (legacy path)", () => {
+  const { store, service } = setup();
+  const { memory } = service.saveWithDedupe({ type: "preference", title: "语言", content: "短" });
+  const before = store.getById(memory.id).tags;
+  service.update(memory.id, { content: "只改内容，不带 tags 字段" });
+  assert.deepEqual(store.getById(memory.id).tags, before, "no tags in patch → tags untouched");
+});
+
+test("Issue #135 review: self_referential is a signal tag and survives a tagged update", () => {
+  const { store, service } = setup();
+  // type 自指（title 提到自身类型标签「偏好」）→ quality-filter.js 写
+  // self_referential（−15）；加短内容一起跌破归档线。SIGNAL_TAGS 清单必须
+  // 覆盖它，否则带 tags 的 update 恰好把这个标签抹掉（审计线索缺口）。
+  const { memory } = service.saveWithDedupe({ type: "preference", title: "偏好记录", content: "短" });
+  const tagged = store.getById(memory.id);
+  assert.ok(tagged.tags.includes("self_referential"), "precondition: self_referential written");
+
+  service.update(memory.id, { tags: ["用户标签"], content: "补充后的完整内容" });
+  const after = store.getById(memory.id);
+  assert.ok(after.tags.includes("self_referential"), "self_referential preserved through the update");
+  assert.ok(after.tags.includes("用户标签"), "user tags still applied");
+});

package/test/reasoning-effort.test.js

@@ -1,10 +1,15 @@
-// Regression for issue #9:
+// Regression for issue #9, extended by issue #135 (建议 3/4/5):
 //  - B: dreamMaxTokens cap widened (min 256, max 131072) so large memory
-//    libraries no longer starve the consolidation output.
-//  - A: dreamReasoningEffort / sleepReasoningEffort pass-through. Default
-//    'none' must OMIT the reasoningEffort field entirely (the provider's own
-//    default applies); low/medium/high are forwarded verbatim on every dream /
-//    sleep LLM call. Asserted by capturing the options each llm.stream() sees.
+//    libraries no longer starve the consolidation output. #135 raises the
+//    DEFAULT to 131072 too — 32768 was exactly what thinking-model reasoning
+//    burnt, leaving an empty body.
+//  - A: dreamReasoningEffort / sleepReasoningEffort pass-through. Explicit
+//    'none' omits the reasoningEffort field entirely (provider default
+//    applies); low/medium/high are forwarded verbatim on every dream /
+//    sleep LLM call. #135: UNSET now resolves to the LOWEST effort the model
+//    declares (the old default 'none' let the harness substitute the model's
+//    defaultEffort, burning the budget on reasoning). Asserted by capturing
+//    the options each llm.stream() sees.
 import test from "node:test";
 import assert from "node:assert/strict";
 import { Config } from "../src/config.js";
@@ -25,9 +30,9 @@ const embedder = {
 
 // ---------------------------------------------------------------- config schema
 
-test("issue#9: dreamMaxTokens defaults to 32768 and accepts values up to 131072", () => {
-  assert.equal(Config({}).dreamMaxTokens, 32768, "default raised for thinking-model headroom");
-  assert.equal(Config({ dreamMaxTokens: 131072 }).dreamMaxTokens, 131072, "new upper bound accepted");
+test("issue#135: dreamMaxTokens defaults to 131072 and accepts values up to 131072", () => {
+  assert.equal(Config({}).dreamMaxTokens, 131072, "old default 32768 was exactly what thinking-model reasoning burnt (Issue #135 建议 3)");
+  assert.equal(Config({ dreamMaxTokens: 131072 }).dreamMaxTokens, 131072, "upper bound accepted");
   assert.equal(Config({ dreamMaxTokens: 65536 }).dreamMaxTokens, 65536, "intermediate value accepted");
 });
 
@@ -39,11 +44,12 @@ test("issue#9: dreamMaxTokens clamps to [256, 131072], out-of-range values are r
   assert.throws(() => Config({ dreamMaxTokens: 0 }), "zero rejected");
 });
 
-test("issue#9: reasoningEffort config defaults to none and rejects unknown values", () => {
+test("issue#135: reasoningEffort unset = undefined (auto-lowest at resolve time); explicit values preserved", () => {
   const cfg = Config({});
-  assert.equal(cfg.dreamReasoningEffort, "none");
-  assert.equal(cfg.sleepReasoningEffort, "none");
-  assert.equal(Config({ dreamReasoningEffort: "high" }).dreamReasoningEffort, "high");
+  assert.equal(cfg.dreamReasoningEffort, undefined, "unset must be distinguishable from explicit 'none'");
+  assert.equal(cfg.sleepReasoningEffort, undefined);
+  assert.equal(Config({ dreamReasoningEffort: "none" }).dreamReasoningEffort, "none", "explicit 'none' kept");
+  assert.equal(Config({ dreamReasoningEffort: "off" }).dreamReasoningEffort, "off", "'off' now a valid explicit choice");
   assert.equal(Config({ sleepReasoningEffort: "medium" }).sleepReasoningEffort, "medium");
   assert.throws(() => Config({ dreamReasoningEffort: "bogus" }), "invalid effort rejected");
   assert.throws(() => Config({ sleepReasoningEffort: "ultra" }), "invalid effort rejected");
@@ -71,7 +77,7 @@ function dreamCtx({ onConsolidation, summaryText = "记忆库总览：用户偏
   };
 }
 
-test("issue#9: dream omits reasoningEffort under default 'none' and still consolidates (applied>0)", async () => {
+test("issue#135: dream omits reasoningEffort when unset without a capability API and still consolidates (applied>0)", async () => {
   const store = createStore(":memory:");
   const service = createService({ store, mirror: null, config: {} });
   const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
@@ -89,7 +95,64 @@ test("issue#9: dream omits reasoningEffort under default 'none' and still consol
   assert.ok(result.applied > 0, "end-to-end dream run still lands changes");
   assert.equal(captured.length, 2, "consolidation + summary both hit the LLM");
   for (const options of captured) {
-    assert.equal("reasoningEffort" in options, false, `default 'none' must not forward reasoningEffort (${options.purpose})`);
+    assert.equal("reasoningEffort" in options, false, `unset without capability API must not forward reasoningEffort (${options.purpose})`);
+  }
+  store.close();
+});
+
+test("issue#135: unset effort resolves to the LOWEST supported effort, never the poison default", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const captured = [];
+  const ctx = dreamCtx({
+    captured,
+    onConsolidation: () => JSON.stringify([
+      { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "插件总览", content: "合并内容", importance: 4 }
+    ])
+  });
+  // v4-flash 系能力报告：声明 off/low/high/max、defaultEffort=high。旧默认
+  // （省略字段）让 harness 顶上 high → 推理烧光预算返回空体；现在未配置应
+  // 自动取最低档 off，而不是服务商默认。
+  ctx.llm.resolveModelInfo = async (provider, model) => ({
+    provider,
+    model,
+    reasoning: { efforts: [{ id: "high" }, { id: "off" }, { id: "low" }, { id: "max" }], defaultEffort: "high" }
+  });
+  const result = await dream.runDream(ctx, service, {});
+  assert.equal(result.ok, true);
+  assert.ok(result.applied > 0, "consolidation lands changes");
+  assert.equal(captured.length, 2, "consolidation + summary both hit the LLM");
+  for (const options of captured) {
+    assert.equal(options.reasoningEffort, "off", `unset resolves to the lowest declared effort on ${options.purpose}`);
+  }
+  store.close();
+});
+
+test("issue#135: explicit 'none' still omits the field even when the capability API is available", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const captured = [];
+  const ctx = dreamCtx({
+    captured,
+    onConsolidation: () => JSON.stringify([
+      { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "插件总览", content: "合并内容", importance: 4 }
+    ])
+  });
+  ctx.llm.resolveModelInfo = async (provider, model) => ({
+    provider,
+    model,
+    reasoning: { efforts: [{ id: "off" }, { id: "low" }], defaultEffort: "high" }
+  });
+  const result = await dream.runDream(ctx, service, { dreamReasoningEffort: "none" });
+  assert.equal(result.ok, true);
+  for (const options of captured) {
+    assert.equal("reasoningEffort" in options, false, `explicit 'none' is a user decision to omit (${options.purpose})`);
   }
   store.close();
 });
@@ -301,6 +364,34 @@ test("issue#9: sleep forwards sleepReasoningEffort on its LLM passes", async ()
   store.close();
 });
 
+test("issue#135: sleep unset effort also resolves to the lowest supported", async () => {
+  const { store, service, vectorIndex } = sleepSetup();
+  const a = service.saveWithDedupe({ type: "project", title: "主题X", content: "内容A 关于主题X", importance: 3 }).memory;
+  const b = service.saveWithDedupe({ type: "project", title: "主题X副本", content: "内容B 关于主题X", importance: 3 }).memory;
+  vectorIndex.saveEmbedding(a.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(b.id, [1, 0, 0]);
+  const captured = [];
+  const ctx = sleepCtx(
+    (userText) => userText.startsWith("候选冲突")
+      ? JSON.stringify([{ action: "conflict", winner: a.id, loser: b.id, reason: "重复覆盖" }])
+      : "[]",
+    { provider: "mock", model: "sleep-model" },
+    captured
+  );
+  ctx.llm.resolveModelInfo = async (provider, model) => ({
+    provider,
+    model,
+    reasoning: { efforts: [{ id: "low" }, { id: "high" }], defaultEffort: "high" }
+  });
+  const result = await runSleep(ctx, service, baseConfig(), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.status, "ok");
+  assert.ok(captured.length >= 2, "conflict + pattern passes both hit the LLM");
+  for (const options of captured) {
+    assert.equal(options.reasoningEffort, "low", `unset sleep effort resolves to the lowest declared (${options.purpose})`);
+  }
+  store.close();
+});
+
 // ------------------------------------------------------------------ stream-level rejection
 // dsh-llm rc.1 converts adapter-stage failures (including the provider's
 // UNSUPPORTED_REASONING_EFFORT throw from resolveCallWithInfo) into a terminal

package/test/reindex-backfill.test.js

@@ -0,0 +1,62 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { backfillMissingEmbeddings } from "../src/index.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+
+// Issue #128：boot 回填曾被模型指纹门短路——任意一条嵌入成功写入 vector_meta
+// 指纹后，指纹匹配的每次启动都在门上直接 return，写入时嵌入失败（embedder 未
+// 就绪 / 服务商限流）的活跃行从此永远补不上（报告实测 88 条活跃记忆长期缺失，
+// /vector-reindex 的配额还被归档死行吃掉）。
+
+test("Issue #128: fingerprint match no longer blocks backfill; archived rows are skipped", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const active = service.saveWithDedupe({ type: "preference", title: "活跃", content: "内容" }).memory;
+  const dead = service.saveWithDedupe({ type: "preference", title: "死行", content: "内容" }).memory;
+  store.setArchived(dead.id, true);
+
+  // 指纹已与 embedder 一致 —— 旧的早退条件在此成立，旧实现会整场不回填。
+  const vectorIndex = createVectorIndex({ store });
+  vectorIndex.markModel("mock-model#abc", 3);
+  const embedded = [];
+  const embedder = {
+    embedSingle: async (text) => { embedded.push(text); return [1, 0, 0]; },
+    modelHash: "mock-model#abc",
+    dimension: 3
+  };
+
+  const logs = [];
+  const indexed = await backfillMissingEmbeddings({
+    store, embedder, vectorIndex,
+    logger: { info: (m) => logs.push(m) },
+    rateLimitMs: 0
+  });
+
+  assert.equal(indexed, 1, "the active row is backfilled despite the matching fingerprint");
+  assert.equal(store.getEmbeddings([active.id]).get(active.id)?.length, 3, "active row now carries a vector");
+  assert.equal(store.getEmbeddings([dead.id]).get(dead.id), undefined, "archived row is skipped");
+  assert.equal(vectorIndex.modelHash(), "mock-model#abc", "fingerprint unchanged (markModel idempotent)");
+  assert.ok(logs.some((m) => m.includes("backfilled 1")), "boot log records the backfill");
+  store.close();
+});
+
+test("Issue #128: backfill is bounded by maxTotal; the rest stays queued", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  for (let i = 0; i < 5; i++) {
+    service.saveWithDedupe({ type: "preference", title: `记忆${i}`, content: `内容${i}` });
+  }
+  const embedder = { embedSingle: async () => [1, 0, 0], modelHash: "h#1", dimension: 3 };
+  const vectorIndex = createVectorIndex({ store });
+
+  const indexed = await backfillMissingEmbeddings({
+    store, embedder, vectorIndex,
+    logger: { info() {} },
+    maxTotal: 4, batchSize: 2, rateLimitMs: 0
+  });
+  assert.equal(indexed, 4, "stops at the maxTotal bound");
+  assert.equal(store.needsEmbedding(10).length, 1, "remaining rows stay queued for the next boot");
+  store.close();
+});