@modusensus/dsh-mneme 0.7.10 → 0.7.12

package/dsh-mneme/test/normalize-decisions.test.js

@@ -1,120 +0,0 @@
-// Field-name normalization guard (v0.5.3): thinking-type models
-// (deepseek-v4-flash etc.) sometimes ignore the prompt's exact decision schema
-// and emit alias keys —实测方案 A 输出 "consolidation"/"target_ids"、方案 B
-// 输出 "action"/"targetIds"，都不是插件要求的 "action"/"ids"。normalizeDecisions
-// 在 validateDecisions 之前把这些变体重写回规范字段名，让"语义正确但 schema
-// 不听话"的输出仍被应用，而不是整单被拒。
-import test from "node:test";
-import assert from "node:assert/strict";
-import { normalizeDecisions, createDreamScheduler } from "../src/dream.js";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-test("normalizeDecisions: canonical decisions pass through untouched", () => {
-  const raw = [
-    { action: "merge", ids: ["m1", "m2"], keepSource: "m1", title: "t", content: "c", importance: 4, reason: "主题相近" },
-    { action: "conflict", winner: "m3", loser: "m4", reason: "矛盾" },
-    { action: "update", ids: ["m5"], content: "修正" },
-    { action: "archive", ids: ["m6"], reason: "过时" },
-    { action: "create", type: "pattern", title: "新模式", content: "发现", importance: 3 }
-  ];
-  assert.deepEqual(normalizeDecisions(raw), raw);
-});
-
-test("normalizeDecisions: alias keys rewritten to canonical names", () => {
-  const raw = [
-    { consolidation: "merge", target_ids: ["m1", "m2"], keep_source: "m1", new_title: "t", new_content: "c", priority: 4, rationale: "主题相近" },
-    { action: "conflict", winner_id: "m3", loser_id: "m4", why: "矛盾" },
-    { action: "update", targetIds: ["m5"], merged_content: "修正" },
-    { action: "archive", memory_ids: ["m6"] }
-  ];
-  assert.deepEqual(normalizeDecisions(raw), [
-    { action: "merge", ids: ["m1", "m2"], keepSource: "m1", title: "t", content: "c", importance: 4, reason: "主题相近" },
-    { action: "conflict", winner: "m3", loser: "m4", reason: "矛盾" },
-    { action: "update", ids: ["m5"], content: "修正" },
-    { action: "archive", ids: ["m6"] }
-  ]);
-});
-
-test("normalizeDecisions: action value synonyms normalized", () => {
-  const raw = [
-    { action: "archived", ids: ["m1"], reason: "重复" },
-    { action: "consolidation", target_ids: ["m2", "m3"], keep_source: "m2" },
-    { action: "combine", targetIds: ["m4", "m5"], keeper: "m5" },
-    { action: "Remove", memory_ids: ["m6"] }
-  ];
-  const normalized = normalizeDecisions(raw);
-  assert.equal(normalized[0].action, "archive");
-  assert.equal(normalized[1].action, "merge");
-  assert.equal(normalized[1].ids[0], "m2");
-  assert.equal(normalized[2].action, "merge");
-  assert.equal(normalized[2].keepSource, "m5");
-  assert.equal(normalized[3].action, "archive");
-});
-
-test("normalizeDecisions: wrapper object around the array is unwrapped", () => {
-  const raw = { consolidation: [{ action: "merge", ids: ["m1"], keepSource: "m1", title: "t", content: "c" }] };
-  assert.deepEqual(normalizeDecisions(raw), [
-    { action: "merge", ids: ["m1"], keepSource: "m1", title: "t", content: "c" }
-  ]);
-  const raw2 = { decisions: [{ action: "archive", target_ids: ["m9"] }] };
-  assert.deepEqual(normalizeDecisions(raw2), [{ action: "archive", ids: ["m9"] }]);
-});
-
-test("normalizeDecisions: single decision object (non-array) normalized too", () => {
-  const raw = { action: "update", targetIds: ["m1"], new_content: "修正" };
-  assert.deepEqual(normalizeDecisions(raw), [{ action: "update", ids: ["m1"], content: "修正" }]);
-});
-
-test("normalizeDecisions: single-string ids become a one-element array", () => {
-  const raw = [{ action: "archive", target_id: "m7" }];
-  // target_id (singular) is not an alias key — the raw key survives untouched
-  // and validateDecisions rejects it (safe side). But targetIds (plural, string)
-  // IS mapped and wrapped.
-  const raw2 = [{ action: "archive", targetIds: "m7" }];
-  assert.deepEqual(normalizeDecisions(raw2), [{ action: "archive", ids: ["m7"] }]);
-  assert.deepEqual(normalizeDecisions(raw), [{ action: "archive", target_id: "m7" }]);
-});
-
-test("normalizeDecisions: create keeps its type field (never mistaken for action)", () => {
-  const raw = { action: "create", type: "preference", title: "语言", content: "中文", importance: 3 };
-  assert.deepEqual(normalizeDecisions(raw), [
-    { action: "create", type: "preference", title: "语言", content: "中文", importance: 3 }
-  ]);
-});
-
-test("normalizeDecisions: null / non-parseable returns as-is (caller's no-json branch)", () => {
-  assert.equal(normalizeDecisions(null), null);
-  assert.equal(normalizeDecisions(undefined), undefined);
-  assert.equal(normalizeDecisions("not json"), "not json");
-});
-
-test("dream runDream applies alias-key consolidation output end-to-end", 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 ctx = {
-    logger: { warn: () => {} },
-    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
-    llm: {
-      async *stream(options) {
-        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
-          // deepseek-v4-flash 实测风格：consolidation 当 action、target_ids 当 ids
-          yield { type: "text-delta", index: 0, text: JSON.stringify([
-            { consolidation: "merge", target_ids: [a.id, b.id], keep_source: b.id, new_title: "插件总览", new_content: "合并内容", priority: 4 }
-          ]) };
-        } else {
-          yield { type: "text-delta", index: 0, text: "记忆库总览：默认摘要。" };
-        }
-        yield { type: "finish", reason: { kind: "stop" } };
-      }
-    }
-  };
-  const result = await dream.runDream(ctx, service, {});
-  assert.equal(result.ok, true, "alias-key output must not be rejected wholesale");
-  assert.ok(result.applied > 0, "alias-key decisions still land changes");
-  store.close();
-});

package/dsh-mneme/test/provenance.test.js

@@ -1,103 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { DatabaseSync } from "node:sqlite";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createTools } from "../src/tools.js";
-
-const openMemory = () => createStore(":memory:");
-
-// Memory provenance (v0.5.x): every memory born from a session carries its
-// session_id so v0.6.0 reasoning-path / interest-drift analysis can rebuild
-// the derivation chain later. session_id is birth provenance — set once at
-// creation, preserved by merges, never fabricated when no session exists.
-
-test("save persists session_id and returns it", () => {
-  const store = openMemory();
-  const saved = store.save({
-    type: "preference",
-    title: "A",
-    content: "c",
-    tags: [],
-    importance: 3,
-    source: "tool",
-    session_id: "session-42"
-  });
-  assert.equal(saved.session_id, "session-42");
-  assert.equal(store.getById(saved.id).session_id, "session-42");
-  store.close();
-});
-
-test("save without session_id leaves it undefined (never fabricated)", () => {
-  const store = openMemory();
-  const saved = store.save({ type: "history", title: "B", content: "c" });
-  assert.equal(saved.session_id, undefined);
-  store.close();
-});
-
-test("dedupe merge keeps the ORIGINAL session_id (provenance = birth)", () => {
-  const store = openMemory();
-  const service = createService({ store, mirror: null, config: {} });
-  service.saveWithDedupe({
-    type: "preference", title: "语言", content: "中文", session_id: "session-1"
-  });
-  const merged = service.saveWithDedupe({
-    type: "preference", title: "语言", content: "中文 + 英文", session_id: "session-2"
-  });
-  assert.equal(merged.action, "merged");
-  assert.equal(store.getById(merged.memory.id).session_id, "session-1");
-  store.close();
-});
-
-test("memory_save tool records exec.agent.session.id as session_id", async () => {
-  const store = openMemory();
-  const service = createService({ store, mirror: null, config: {} });
-  const ctx = { tools: { register() { return () => {}; } } };
-  const tools = createTools(ctx, service, {}, undefined);
-  const saveTool = tools.find((t) => t.name === "memory_save");
-  const out = await saveTool.execute(
-    { type: "decision", title: "T", content: "c" },
-    { agent: { session: { id: "session-tool-9" } } }
-  );
-  assert.equal(store.getById(out.id).session_id, "session-tool-9");
-  store.close();
-});
-
-test("memory_save tool without agent context leaves session_id null", async () => {
-  const store = openMemory();
-  const service = createService({ store, mirror: null, config: {} });
-  const ctx = { tools: { register() { return () => {}; } } };
-  const tools = createTools(ctx, service, {}, undefined);
-  const saveTool = tools.find((t) => t.name === "memory_save");
-  const out = await saveTool.execute({ type: "decision", title: "T2", content: "c" }, {});
-  assert.equal(store.getById(out.id).session_id, undefined);
-  store.close();
-});
-
-test("legacy DB without session_id column migrates and saves with provenance", () => {
-  const dir = mkdtempSync(join(tmpdir(), "mneme-prov-"));
-  const dbPath = join(dir, "legacy.db");
-  const db = new DatabaseSync(dbPath);
-  db.exec(`CREATE TABLE memories (
-    id TEXT PRIMARY KEY, type TEXT NOT NULL, title TEXT NOT NULL, content TEXT NOT NULL,
-    tags TEXT NOT NULL DEFAULT '[]', importance INTEGER NOT NULL DEFAULT 3,
-    forgotten INTEGER NOT NULL DEFAULT 0, archived INTEGER NOT NULL DEFAULT 0,
-    source TEXT, content_history TEXT, embedding TEXT,
-    epistemic_status TEXT NOT NULL DEFAULT 'subjective',
-    last_accessed_at TEXT, _full_content TEXT,
-    created_at TEXT NOT NULL, updated_at TEXT NOT NULL
-  );`);
-  db.close();
-  const store = createStore(dbPath);
-  const cols = store.db.prepare("PRAGMA table_info(memories)").all().map((c) => c.name);
-  assert.ok(cols.includes("session_id"), "session_id column added by migration");
-  const saved = store.save({
-    type: "history", title: "旧库", content: "迁移后仍可溯源", session_id: "session-legacy"
-  });
-  assert.equal(store.getById(saved.id).session_id, "session-legacy");
-  store.close();
-  rmSync(dir, { recursive: true, force: true });
-});

package/dsh-mneme/test/recall-runs.test.js

@@ -1,93 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-// v0.7.0 recall-layer 强度标记 + 滚动清理：
-//   - searchMemories 记搜索帧：candidates 打 injected:false（被召回）；
-//   - injectCandidates 记注入帧：mode="inject"、candidates 打 injected:true
-//     （被注入上下文）—— 两个消耗强度可分可查；
-//   - 两路都受 recallRecordDefault 门控，注入帧记账失败绝不阻断注入；
-//   - store.purgeRecallRunsOlderThan(days) 按 created_at 滚动清理防膨胀。
-
-function setup(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  return { store, service };
-}
-
-function wireRecorder(service, seen) {
-  service.setRecallRecorder((r) => seen.push(r));
-}
-
-test("search scene candidates carry injected:false", async () => {
-  const { service } = setup();
-  const seen = [];
-  wireRecorder(service, seen);
-  service.saveWithDedupe({ type: "preference", title: "量子计算", content: "入门", importance: 5 });
-  const rows = await service.searchMemories("量子", { mode: "keyword", recordRecall: true });
-  assert.equal(rows.length, 1);
-  assert.equal(seen[0].mode, "keyword");
-  assert.equal(seen[0].candidates[0].injected, false, "搜索帧是被召回的帧，标记 false");
-});
-
-test("inject scene records mode=inject with injected:true on every candidate", async () => {
-  const { service } = setup();
-  const seen = [];
-  wireRecorder(service, seen);
-  const mem = service.saveWithDedupe({ type: "preference", title: "量子计算", content: "入门", importance: 5 }).memory;
-  const injected = service.injectCandidates({ query: "量子", maxItems: 3 });
-  assert.ok(injected.some((m) => m.id === mem.id), "注入选中的记忆在返回里");
-  assert.equal(seen.length, 1, "注入帧记了 1 条 recall_runs");
-  const rec = seen[0];
-  assert.equal(rec.mode, "inject", "注入帧 mode 为 inject");
-  assert.equal(rec.topK, injected.length);
-  assert.ok(rec.candidates.length >= 1 && rec.candidates.every((c) => c.injected === true), "注入候选全部 injected:true");
-  assert.ok(rec.candidates.every((c) => c.source === "inject"), "注入候选 source 标记 inject");
-});
-
-test("inject recording is gated off by recallRecordDefault=false, search stays explicit", async () => {
-  const { service } = setup({ recallRecordDefault: false });
-  const seen = [];
-  wireRecorder(service, seen);
-  service.saveWithDedupe({ type: "preference", title: "量子计算", content: "入门", importance: 5 });
-  service.injectCandidates({ query: "量子", maxItems: 3 });
-  assert.equal(seen.length, 0, "recallRecordDefault=false 时注入帧不上报");
-  await service.searchMemories("量子", { mode: "keyword", recordRecall: true });
-  assert.equal(seen.length, 1, "显式 recordRecall:true 的搜索帧照常上报");
-});
-
-test("injected flag survives the store round-trip", async () => {
-  const store = createStore(":memory:");
-  store.saveRecallRun({
-    query: "量子", mode: "inject", topK: 1, candidates: [{ id: "a", title: "量子", content: "入门", score: 0.8, source: "inject", injected: true }]
-  });
-  store.saveRecallRun({
-    query: "量子", mode: "keyword", topK: 1, candidates: [{ id: "b", title: "量子计算", content: "叠加态", score: 0.9, source: "keyword", injected: false }]
-  });
-  const runs = store.listRecallRuns();
-  assert.equal(runs.length, 2);
-  const inject = runs.find((r) => r.mode === "inject");
-  const search = runs.find((r) => r.mode === "keyword");
-  assert.equal(inject.candidates[0].injected, true, "注入帧 injected 存得回来");
-  assert.equal(search.candidates[0].injected, false, "搜索帧 injected 存得回来");
-  assert.equal(store.getRecallRun(search.id).candidates[0].injected, false);
-});
-
-test("purgeRecallRunsOlderThan drops only rows past the retention window", async () => {
-  const store = createStore(":memory:");
-  const old = store.saveRecallRun({
-    id: "old", query: "旧查询", mode: "keyword", topK: 5, candidates: [],
-    created_at: new Date(Date.now() - 200 * 86400000).toISOString()
-  });
-  const fresh = store.saveRecallRun({
-    id: "fresh", query: "新查询", mode: "inject", topK: 5, candidates: [],
-    created_at: new Date().toISOString()
-  });
-  const deleted = store.purgeRecallRunsOlderThan(90);
-  assert.equal(deleted, 1, "只有 200 天前的老行被清除");
-  const runs = store.listRecallRuns();
-  assert.deepEqual(runs.map((r) => r.id), ["fresh"], "新行保留");
-  assert.equal(store.getRecallRun(old.id), undefined, "旧行不可再读");
-  store.close();
-});

package/dsh-mneme/test/sleep-heat.test.js

@@ -1,112 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { runSleep } from "../src/dream/sleep.js";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-// v0.7.0 待办③ sleep 降级热联合判定：
-//   降级需同时满足 时间窗 + heat<sleepHeatThreshold + importance<5 三条件；
-//   λ=0 的免疫类型 heat 恒 1.0 天然豁免；importance≥5 紧要记忆无论多冷都保留。
-// 默认 λ 下：history(0.006) 约 77 天后热值跌破 0.05，project(0.0008) 约 581 天，
-// decision(0.002) 约 232 天 —— 整体取向保守，突出"冷但重要"与"热但低值"都不降级。
-
-const DAY = 86400000;
-
-function setup(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  return { store, service };
-}
-
-function saveMemory(service, title, content, type = "project", importance = 3) {
-  return service.saveWithDedupe({ type, title, content, importance }).memory;
-}
-
-function sleepConfig(overrides = {}) {
-  return {
-    sleepModeEnabled: true,
-    sleepConflictStrictness: "normal",
-    sleepArchiveDays: 30,   // 30-90 天窗口 → 压缩为摘要
-    sleepCompressDays: 90,  // >=90 天 → 直接归档
-    sleepPatternMinMemories: 100, // 记忆数不足 → pattern 阶段跳过
-    sleepMaxPatternPerRun: 3,
-    ...overrides
-  };
-}
-
-function mockCtx() {
-  return {
-    logger: { warn: () => {}, info: () => {} },
-    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "sleep-model" }) },
-    llm: {
-      async *stream() {
-        yield { type: "text-delta", index: 0, text: "[]" };
-        yield { type: "finish", reason: { kind: "stop" } };
-      }
-    }
-  };
-}
-
-async function run(memories, service, config) {
-  const now = Date.now();
-  for (const [mem, daysAgo] of memories) {
-    service.touchLastAccess(mem.id, new Date(now - daysAgo * DAY).toISOString());
-  }
-  const result = await runSleep(mockCtx(), service, config, { warn: () => {}, info: () => {} }, null, null);
-  return result.phases?.["demotion"];
-}
-
-test("cold low-importance history past the compress tier archives (heat gate open)", async () => {
-  const { store, service } = setup();
-  const mem = saveMemory(service, "久远的会话记录", "早期讨论内容", "history", 2);
-  const demotion = await run([[mem, 120]], service, sleepConfig());
-  assert.ok(demotion, "demotion phase ran");
-  assert.ok(demotion.archived.includes(mem.id), "120 天 ref + 热值≈0.03<0.05 + importance 2 → 归档");
-  assert.equal(store.getById(mem.id).archived, true);
-  store.close();
-});
-
-test("importance 5 protects a memory even when the heat is icy", async () => {
-  const { store, service } = setup();
-  const mem = saveMemory(service, "关键决策", "不可丢失的重要结论", "decision", 5);
-  const demotion = await run([[mem, 400]], service, sleepConfig());
-  assert.ok(demotion, "demotion phase ran");
-  // decision λ=0.002, 400 天热值≈0.03<0.05，但 importance=5 → 保护，绝不降级。
-  assert.ok(!demotion.archived.includes(mem.id), "紧要记忆不被归档");
-  assert.ok(!demotion.demoted.includes(mem.id), "紧要记忆不被压缩");
-  assert.equal(store.getById(mem.id).archived, false);
-  store.close();
-});
-
-test("immune preference (λ=0, heat=1.0) is never demoted even when ancient", async () => {
-  const { store, service } = setup();
-  const mem = saveMemory(service, "用户偏好", "喜欢简洁的总结", "preference", 3);
-  const demotion = await run([[mem, 400]], service, sleepConfig());
-  assert.ok(!demotion.archived.includes(mem.id), "免疫类型不归档");
-  assert.ok(!demotion.demoted.includes(mem.id), "免疫类型不压缩");
-  assert.equal(store.getById(mem.id).archived, false);
-  store.close();
-});
-
-test("slow-decay project stays heat-protected at the compress tier (λ=0.0008)", async () => {
-  const { store, service } = setup();
-  const mem = saveMemory(service, "项目A", "慢衰减的进行中项目", "project", 2);
-  const demotion = await run([[mem, 100]], service, sleepConfig());
-  // 100 天已越过 90 天归档窗，但 project 热值≈0.28>0.05 → heat 闸拦下。
-  assert.ok(!demotion.archived.includes(mem.id), "慢衰减类型热值仍高 → 不归档");
-  assert.equal(store.getById(mem.id).archived, false);
-  store.close();
-});
-
-test("demote tier (30-90d) fires when the type's λ is cold enough", async () => {
-  const { store, service } = setup();
-  const mem = saveMemory(service, "中期会话摘要", "可压缩的历史碎片", "history", 2);
-  // 调高 history 的 λ 到 0.05 → 40 天热值≈0.009<0.05，解锁 30-90 天压缩窗口。
-  const config = sleepConfig({ heatTypeDecay: { history: 0.05 } });
-  const demotion = await run([[mem, 40]], service, config);
-  assert.ok(!demotion.archived.includes(mem.id), "40 天未到归档线");
-  assert.ok(demotion.demoted.includes(mem.id), "热值足够冷 + importance 2 → 压缩为摘要");
-  const after = store.getById(mem.id);
-  assert.ok(after._full_content, "全文停放在 _full_content");
-  store.close();
-});

package/dsh-mneme/test/tag-boost.test.js

@@ -1,125 +0,0 @@
-// v0.6.4 Tag 加权召回测试。
-// 覆盖：extractQueryTags（#标签/已知 tag/去重/空）/ applyTagBoost（交集乘系数/
-// 无交集不变/双叠加封顶/降序/标记）/ searchMemories 集成（开/关行为）。
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { extractQueryTags, applyTagBoost } from "../src/search/tag-boost.js";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-
-function makeService(config = {}) {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config });
-  return { store, service };
-}
-
-// ============================================================ extractQueryTags
-
-test("extractQueryTags: extracts #hashtags including CJK", () => {
-  const tags = extractQueryTags("查看 #规划 和 #meeting_123");
-  assert.deepEqual(tags, ["规划", "meeting_123"]);
-});
-
-test("extractQueryTags: matches known tags without #", () => {
-  const tags = extractQueryTags("规划会议纪要", ["规划", "会议"]);
-  assert.deepEqual(tags, ["规划", "会议"]);
-});
-
-test("extractQueryTags: dedupes and merges explicit and known tags", () => {
-  const tags = extractQueryTags("#规划 规划进度", ["规划", "项目"]);
-  assert.deepEqual(tags, ["规划"]);
-});
-
-test("extractQueryTags: empty/invalid query returns empty array", () => {
-  assert.deepEqual(extractQueryTags(""), []);
-  assert.deepEqual(extractQueryTags(null), []);
-});
-
-// ============================================================ applyTagBoost
-
-test("applyTagBoost: boosts candidates overlapping query tags", () => {
-  const out = applyTagBoost([{ id: "a", score: 0.8, tags: ["规划"] }], {
-    queryTags: ["规划"],
-    factor: 1.15,
-  });
-  assert.ok(Math.abs(out[0].score - 0.92) < 1e-9, "0.8 × 1.15 ≈ 0.92 (float-safe)");
-  assert.equal(out[0].tagBoost, true);
-});
-
-test("applyTagBoost: leaves non-overlapping candidates unchanged and stable", () => {
-  const out = applyTagBoost(
-    [
-      { id: "a", score: 0.5, tags: ["x"] },
-      { id: "b", score: 0.5, tags: ["y"] },
-    ],
-    { queryTags: ["z"] }
-  );
-  assert.deepEqual(out.map((m) => m.score), [0.5, 0.5]);
-  assert.deepEqual(out.map((m) => m.id), ["a", "b"]);
-  assert.ok(!out.some((m) => m.tagBoost));
-});
-
-test("applyTagBoost: applies both boosts and caps at 1", () => {
-  const out = applyTagBoost([{ id: "a", score: 0.9, tags: ["规划", "热门"] }], {
-    queryTags: ["规划"],
-    sessionTags: ["热门"],
-    factor: 1.15,
-    sessionFactor: 1.08,
-  });
-  assert.equal(out[0].score, 1);
-  assert.equal(out[0].tagBoost, true);
-});
-
-test("applyTagBoost: sorts results by boosted score descending", () => {
-  const out = applyTagBoost(
-    [
-      { id: "low", score: 0.9, tags: ["x"] },
-      { id: "high", score: 0.8, tags: ["plan"] },
-    ],
-    { queryTags: ["plan"], factor: 1.25 }
-  );
-  assert.deepEqual(out.map((m) => m.id), ["high", "low"]);
-  assert.equal(out[0].tagBoost, true);
-});
-
-// ============================================================ searchMemories 集成
-
-test("searchMemories: tagBoostEnabled tags the matching memory", async () => {
-  const { store, service } = makeService({ tagBoostEnabled: true });
-  const a = service.saveWithDedupe({
-    type: "preference", title: "规划笔记", content: "项目规划方案", importance: 3,
-  }).memory;
-  store.setMemoryTags(a.id, ["规划"]);
-  const results = await service.searchMemories("项目 #规划", {
-    mode: "hybrid", limit: 10, useRerank: false, trustEpistemicWeighting: false,
-  });
-  const tagged = results.find((r) => r.id === a.id);
-  assert.ok(tagged, "tagged memory should be returned");
-  assert.equal(tagged.tagBoost, true, "boosted candidate carries tagBoost marker");
-});
-
-test("searchMemories: tagBoostEnabled=false adds no tagBoost markers", async () => {
-  const { store, service } = makeService({ tagBoostEnabled: false });
-  const a = service.saveWithDedupe({
-    type: "preference", title: "规划笔记", content: "项目规划方案", importance: 3,
-  }).memory;
-  store.setMemoryTags(a.id, ["规划"]);
-  const results = await service.searchMemories("项目 #规划", {
-    mode: "hybrid", limit: 10, useRerank: false, trustEpistemicWeighting: false,
-  });
-  assert.ok(!results.some((r) => r.tagBoost), "no tagBoost marker when disabled");
-});
-
-test("searchMemories: no tag in query → no boost even when enabled", async () => {
-  const { store, service } = makeService({ tagBoostEnabled: true });
-  const a = service.saveWithDedupe({
-    type: "preference", title: "规划笔记", content: "项目规划方案", importance: 3,
-  }).memory;
-  store.setMemoryTags(a.id, ["规划"]);
-  // query carries no #tag and no known-tag mention → boost is gated off
-  const results = await service.searchMemories("项目", {
-    mode: "hybrid", limit: 10, useRerank: false, trustEpistemicWeighting: false,
-  });
-  assert.ok(results.length > 0, "results returned");
-  assert.ok(!results.some((r) => r.tagBoost), "no tagBoost marker without a tag-bearing query");
-});