@modusensus/dsh-mneme 0.8.10 → 0.8.12

package/test/baseline-persist.test.js

@@ -0,0 +1,248 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DatabaseSync } from "node:sqlite";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createDreamScheduler } from "../src/dream.js";
+
+// 回归（issue #89 基线半边）：阈值基线 baseline{count,chars} 只活在调度器闭包里，
+// 进程重启归零。库里记忆远多于阈值时，重启后第一条写入（更新类写入同样计入
+// notifyWrite）就让 overBase 成立，绕过阈值开跑一整轮巩固——0.8.11 实测四次重启
+// 分别只新增 6/7/0/8 条记忆（阈值 10 条 / 5000 字符），每轮约 16 万 tokens。
+// #291 只持久化了 lastRunAt（时间闸门那半边），本文件锁另一半：
+//   1. lastDreamBaseline 只认「成功轮落下的完整基线」，按 run_type 隔离；
+//   2. 播种后重启不再绕过阈值——同库同写入的无种子对照组仍触发，锁的正是这个差异；
+//   3. 播种不妨碍阈值正常累积（计数长到 +10 仍然触发）；
+//   4. runDream 成功轮把基线落库并回给调度器（进程内刷新与跨重启播种同一份数字）；
+//   5. 老库两列由幂等迁移补上，存量行认不出基线 → 退回零基线（升级前行为）。
+
+/** 与阈值判定同口径的活跃库规模（测试侧独立实现，避免与被测代码共用一份过滤条件）。 */
+function activeSize(store) {
+  const rows = store.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document");
+  return {
+    count: rows.length,
+    chars: rows.reduce((sum, m) => sum + m.title.length + m.content.length, 0)
+  };
+}
+
+function seedMemories(service, n, tag = "a") {
+  // 标题必须全局唯一：saveWithDedupe 的去重键是 type+title+scope，同名会被合并成
+  // 同一条（条数不增长），「累计到阈值」的断言就会假失败。
+  for (let i = 0; i < n; i++) {
+    service.saveWithDedupe({ type: "history", title: `${tag}-${i}`, content: "x".repeat(300), importance: 3 });
+  }
+}
+
+test("issue#89: store.lastDreamBaseline reads the last baseline-advancing run only", () => {
+  const store = createStore(":memory:");
+  assert.equal(store.lastDreamBaseline(), null, "empty trail → null (never ran)");
+  // 非 ok 轮不推进基线（既有语义）→ 不落这两列，播种端必须无视它
+  store.saveDreamRun({ status: "failed", snapshot_hash: "h0", input_count: 1, receipt: "r0", created_at: "2026-09-30T10:00:00.000Z", run_type: "auto" });
+  assert.equal(store.lastDreamBaseline("auto"), null, "failed run carries no baseline");
+  store.saveDreamRun({ status: "ok", snapshot_hash: "h1", input_count: 1, receipt: "r1", created_at: "2026-09-30T10:01:00.000Z", run_type: "auto", store_count: 4, store_chars: 400 });
+  assert.deepEqual(store.lastDreamBaseline("auto"), { count: 4, chars: 400 });
+  // sleep/organize 的轮次不参与 auto 的阈值判定
+  store.saveDreamRun({ status: "ok", snapshot_hash: "h2", input_count: 1, receipt: "r2", created_at: "2026-09-30T10:02:00.000Z", run_type: "sleep", store_count: 9, store_chars: 900 });
+  assert.deepEqual(store.lastDreamBaseline("auto"), { count: 4, chars: 400 }, "sleep rows are filtered out of the auto baseline");
+  assert.deepEqual(store.lastDreamBaseline("sleep"), { count: 9, chars: 900 });
+  // 半个基线（只有条数没有字符数）写入侧就该拒绝：否则阈值会按 0 字符起算
+  store.saveDreamRun({ status: "ok", snapshot_hash: "h3", input_count: 1, receipt: "r3", created_at: "2026-09-30T10:03:00.000Z", run_type: "auto", store_count: 7 });
+  assert.deepEqual(store.lastDreamBaseline("auto"), { count: 4, chars: 400 }, "half a baseline is not accepted");
+  store.close();
+});
+
+test("issue#89: a seeded baseline survives a restart — the first write no longer bypasses the threshold", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  seedMemories(service, 12); // 条数与字符数都远超阈值（12 ≥ 10 条）
+  // 上一进程的成功轮把「当时的库规模」落进审计表，然后进程重启：
+  const size = activeSize(store);
+  store.saveDreamRun({
+    status: "ok", snapshot_hash: "h", input_count: 1, receipt: "r",
+    created_at: new Date(Date.now() - 10).toISOString(), run_type: "auto",
+    store_count: size.count, store_chars: size.chars
+  });
+  const opts = { onRun: async () => ({ ok: false }), thresholdCount: 10, thresholdChars: 5000, delayMs: 0, logger: { warn: () => {} } };
+  const seeded = createDreamScheduler({ ...opts, baselineSeed: store.lastDreamBaseline("auto") });
+  assert.equal(seeded.maybeSchedule(service), false, "seeded baseline blocks the first write after restart");
+  // 对照组：同一个库、同一次写入，没有种子就是被修掉的那个缺陷。若哪天播种被忽略，
+  // 上面那条断言会与这条同真同假——所以两条必须成对存在。
+  const unseeded = createDreamScheduler(opts);
+  assert.equal(unseeded.maybeSchedule(service), true, "without the seed the threshold is bypassed (the defect this test locks)");
+  await unseeded.dispose(); // 清掉 0ms 待跑计时器，别让对照组真开跑
+  store.close();
+});
+
+test("issue#89: a seeded baseline still lets the threshold accumulate", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  seedMemories(service, 12);
+  const dream = createDreamScheduler({
+    onRun: async () => ({ ok: false }), thresholdCount: 10, thresholdChars: 5000, delayMs: 0,
+    baselineSeed: activeSize(store), logger: { warn: () => {} }
+  });
+  seedMemories(service, 5, "b");
+  assert.equal(dream.maybeSchedule(service), false, "half the threshold is not enough");
+  seedMemories(service, 5, "c"); // 累计 +10 条
+  assert.equal(dream.maybeSchedule(service), true, "the threshold still fires once the store grew by it");
+  await dream.dispose();
+  store.close();
+});
+
+test("issue#89: the run-reported baseline is what the scheduler keeps (single source of truth)", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  seedMemories(service, 12);
+  const reported = { count: 50, chars: 50000 };
+  const dream = createDreamScheduler({
+    onRun: async () => ({ ok: true, baseline: reported }),
+    thresholdCount: 10, thresholdChars: 5000, delayMs: 0, logger: { warn: () => {} }
+  });
+  assert.equal(dream.maybeSchedule(service), true, "no seed yet → the first run is allowed");
+  await new Promise((r) => setTimeout(r, 10)); // 让 run 收尾并刷新基线
+  // 运行后再长 15 条：若调度器改用「现场计算」的基线（12），这里会触发；用 run
+  // 自报的 50 则不触发。这条差异就是「审计行与内存基线同一份数字」的锁。
+  seedMemories(service, 15, "grow");
+  assert.equal(dream.maybeSchedule(service), false, "the persisted-reported baseline governs, not the live store size");
+  await dream.dispose();
+  store.close();
+});
+
+test("issue#89: an ok run persists its post-run store size; a failed run persists none", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const a = service.saveWithDedupe({ type: "project", title: "旧1", content: "第一段内容" });
+  const b = service.saveWithDedupe({ type: "project", title: "旧2", content: "第二段内容" });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0, logger: { warn: () => {} } });
+
+  // 失败轮（无路由）：不能留下任何基线——否则重启播种会拿到一个「没推进过」的假基线
+  const failed = await dream.runDream({ llm: { stream: async function* () {} }, logger: { warn: () => {} } }, service, {});
+  assert.equal(failed.ok, false, "no route → failed run");
+  assert.equal(failed.baseline, undefined, "failed run reports no baseline");
+  assert.equal(store.lastDreamBaseline("auto"), null, "failed run persists no baseline");
+
+  // 成功轮：落库的数字 = 本轮结束后的活跃库规模（合并已归档一方，summary 不计入）
+  let calls = 0;
+  const ctx = {
+    llm: {
+      stream: async function* () {
+        calls++;
+        const text = calls === 1
+          ? JSON.stringify([{ action: "merge", ids: [a.memory.id, b.memory.id], title: "合并标题", content: "合并后的内容", importance: 4, keepSource: a.memory.id }])
+          : "记忆库总览摘要文本";
+        yield { type: "text-delta", text };
+        yield { type: "finish", reason: { kind: "ok" } };
+      }
+    },
+    logger: { warn: () => {} }
+  };
+  const ok = await dream.runDream(ctx, service, { dreamProvider: "deepseek", dreamModel: "deepseek-chat" });
+  assert.equal(ok.ok, true, "run with decisions + summary is ok");
+  const expected = activeSize(store);
+  assert.deepEqual(ok.baseline, expected, "the run reports the post-run store size");
+  assert.deepEqual(store.lastDreamBaseline("auto"), expected, "the audit row carries the same numbers");
+  store.close();
+});
+
+test("issue#89: legacy dream_runs gains the baseline columns on open (idempotent ALTER)", () => {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-mneme-baseline-migrate-"));
+  const dbPath = join(dir, "legacy.db");
+  try {
+    const legacy = new DatabaseSync(dbPath);
+    legacy.exec(`CREATE TABLE dream_runs (
+      id TEXT PRIMARY KEY, created_at TEXT NOT NULL, status TEXT NOT NULL, error TEXT,
+      provider TEXT, model TEXT, snapshot_hash TEXT NOT NULL, input_count INTEGER NOT NULL,
+      input TEXT, decisions TEXT, outcome TEXT, applied INTEGER NOT NULL DEFAULT 0,
+      summary_stored INTEGER NOT NULL DEFAULT 0, receipt TEXT NOT NULL,
+      policy_epoch INTEGER NOT NULL DEFAULT 0, run_type TEXT NOT NULL DEFAULT 'auto', skipped TEXT
+    );`);
+    legacy.prepare(
+      `INSERT INTO dream_runs (id, created_at, status, snapshot_hash, input_count, applied, summary_stored, receipt)
+       VALUES ('legacy', '2026-09-30T10:00:00.000Z', 'ok', 'h', 1, 0, 0, 'r')`
+    ).run();
+    legacy.close();
+
+    const store = createStore(dbPath);
+    const cols = store.db.prepare("PRAGMA table_info(dream_runs)").all().map((c) => c.name);
+    assert.ok(cols.includes("store_count") && cols.includes("store_chars"), "baseline columns added to legacy db");
+    // 存量行两列皆 NULL：反推不出「那轮结束时库有多大」，认不出就不认——退回零基线
+    assert.equal(store.lastDreamBaseline("auto"), null, "legacy rows carry no baseline");
+    store.close();
+
+    const again = createStore(dbPath); // 二次打开：ALTER 幂等，不抛 duplicate column
+    assert.equal(again.lastDreamBaseline("auto"), null);
+    again.close();
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("issue#89: an unusable seed is treated as no baseline at all", () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  seedMemories(service, 12);
+  const opts = { onRun: async () => ({ ok: false }), thresholdCount: 10, thresholdChars: 5000, delayMs: 0, logger: { warn: () => {} } };
+  // 库里的持久化值可能是老库的 NULL、或手工改坏的库：半个基线（只有条数）若被当成
+  // 「12 条 0 字符」，阈值会按 0 字符起算——比不认还糟。非法种子一律退回零基线。
+  for (const bad of [{ count: 12 }, { chars: 2000 }, { count: -1, chars: 2000 }, { count: 1.5, chars: 10 }, "nope"]) {
+    const sched = createDreamScheduler({ ...opts, baselineSeed: bad });
+    assert.equal(sched.maybeSchedule(service), true, `unusable seed ${JSON.stringify(bad)} falls back to the zero baseline`);
+    sched.dispose();
+  }
+  store.close();
+});
+
+test("issue#89: a failing baseline read never breaks the run nor fakes a baseline", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const a = service.saveWithDedupe({ type: "project", title: "旧1", content: "第一段内容" });
+  // finish 阶段读库失败（关库 / IO 故障）：必须不反噬巩固本身（审计行照写），也不
+  // 写一个猜出来的基线（落 NULL → 下次重启退回零基线，而不是拿假基线抬高阈值）。
+  // 故障点在「总览出文本之后」才武装：runDream 前面还要读两次库（候选集与总览输入），
+  // 过早抛错会把整轮打成 failed，验的就不是收尾取证这条路了。
+  const realAll = service.all.bind(service);
+  let armed = false;
+  let calls = 0;
+  service.all = () => {
+    if (armed) throw new Error("store closed");
+    return realAll();
+  };
+  const ctx = {
+    llm: {
+      stream: async function* () {
+        if (calls++ === 0) {
+          yield { type: "text-delta", text: JSON.stringify([{ action: "keep", ids: [a.memory.id] }]) };
+        } else {
+          armed = true;
+          yield { type: "text-delta", text: "记忆库总览摘要文本" };
+        }
+        yield { type: "finish", reason: { kind: "ok" } };
+      }
+    },
+    logger: { warn: () => {} }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0, logger: { warn: () => {} } });
+  const ok = await dream.runDream(ctx, service, { dreamProvider: "deepseek", dreamModel: "deepseek-chat" });
+  assert.equal(ok.ok, true, "the run still completes when the baseline read fails");
+  assert.equal(ok.baseline, undefined, "no made-up baseline is reported");
+  assert.ok(store.listDreamRuns({ limit: 1 })[0], "the audit row is still written");
+  assert.equal(store.listDreamRuns({ limit: 1 })[0].store_count, undefined, "the audit row carries no baseline");
+  store.close();
+});
+
+// --- CodeRabbit 在 #291 上的同类要求：index.js 的 seed 是单行无分支接线，仓库没有
+// 插件级挂载 harness（apply 需要完整宿主 ctx），改为源码级锁——删掉该注入行即红。
+// import 用 URL 相对本文件解析，不依赖测试进程 CWD。
+const indexSrc = readFileSync(fileURLToPath(new URL("../src/index.js", import.meta.url)), "utf8");
+
+test("issue#89: index.js wires the dream baseline seed from the audit trail", () => {
+  assert.match(
+    indexSrc,
+    /baselineSeed:\s*store\.lastDreamBaseline\("auto"\)/,
+    "dream scheduler must seed its threshold baseline from dream_runs (run_type='auto') — remove this line and the restart-bypass returns"
+  );
+});

package/test/client.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync, existsSync, readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { spawnSync } from "node:child_process";
@@ -63,9 +63,13 @@ test("sidebar entry opens the sheet; conversation-view tab stays retired", () =>
     "no dialog surface should remain"
   );
   assert.ok(
-    /function openLibrary\(\) \{\s*setOverlayOpen\(true\);\s*\}/.test(clientSource),
+    /function openLibrary\(\) \{\s*setOverlayOpen\(true\);/.test(clientSource),
     "the entry must open the overlay directly (no tab activation)"
   );
+  assert.ok(
+    clientSource.includes("conflictBadgeCount.refresh();"),
+    "opening the library must re-read the conflict count (badge must not show a stale number)"
+  );
   assert.equal(
     clientSource.includes('ctx.slots.inject("conversation.view"'),
     false,
@@ -126,16 +130,20 @@ test("trigger renders a wide row or a rail icon from the wide flag", () => {
     "the label span must render only when wide"
   );
   assert.ok(
-    /size: wide \? 15 : 18/.test(clientSource),
-    "the portalled icon must follow the native rail sizing convention"
+    /size: wide \? 16 : 18/.test(clientSource),
+    "the portalled icon must follow the host panel-row size (16) and the rail size (18)"
   );
 });
 
-// The entry lives at the top of the plugin-entry group: the real button is
-// portalled right after the host's New-Session row (above the entries other
-// plugins inject there), while the sidebar.footer.action registration remains
-// as the React anchor and the in-place fallback when the host markup changes.
-test("sidebar entry portals above the workspaces region with footer fallback", () => {
+// 入口的两态形状（宿主内核 0.2 侧边栏改版后重写，见 lib/client.js 的
+// SidebarTopEntry 头注释）：
+//  · 展开：混进宿主 nav.panelList 里「插件 / 自动化任务」那一组，套用宿主
+//    panelRow 的实时类名 → 一颗低调面板行，不再是第二个高亮「新会话」按钮；
+//  · 收起：宿主把面板列表整组 display:none，只有 fixed 到标题栏的开关与
+//    「新会话」还可见，所以入口必须搬回那个位置（见下一条用例）。
+// 本用例锁「展开态借的是宿主面板行」，回归表现是入口退回成大按钮或落回
+// 新会话行后面变成孤立项。
+test("sidebar entry portals into the host panel list with footer fallback", () => {
   assert.ok(
     clientSource.includes('ctx.slots.inject("sidebar.footer.action"'),
     "the footer slot registration must stay as anchor + fallback"
@@ -149,20 +157,24 @@ test("sidebar entry portals above the workspaces region with footer fallback", (
     "the portal must anchor at the host's regionArea container"
   );
   assert.ok(
-    clientSource.includes("insertBefore(created, target)"),
-    "the entry must be placed through the idempotent place() helper"
+    clientSource.includes(`'[class*="panelList"]'`),
+    "the wide shape must target the host panel list (the 插件 / 自动化任务 group)"
   );
   assert.ok(
-    clientSource.includes("if (!host) return fallback;"),
-    "the portal entry persists across collapse (no footer jump); footer fallback only covers portal failure"
+    clientSource.includes(`'[class*="panelRow"]:not(.mneme-topentry-native)'`),
+    "the panel-row class must come from a host row, never from our own portalled button"
   );
   assert.ok(
-    clientSource.includes('className: `${nativeCls} mneme-topentry-native`'),
-    "the entry must reuse the host New-Session button class for native geometry alignment"
+    clientSource.includes("list.appendChild(created)"),
+    "the wide entry must be appended into that group, below the host's own entries"
   );
   assert.ok(
-    /querySelector\('\[class\*="newSession"\]'\)/.test(clientSource),
-    "the native class must be read from the live New-Session button, not hardcoded"
+    clientSource.includes("insertBefore(created, target)"),
+    "the entry must keep the idempotent place() helper for hosts without a panel list"
+  );
+  assert.ok(
+    clientSource.includes("if (!host) return fallback;"),
+    "the portal entry persists across collapse (no footer jump); footer fallback only covers portal failure"
   );
   assert.ok(
     clientSource.includes('"memory.view.label"'),
@@ -178,7 +190,7 @@ test("sidebar entry portals above the workspaces region with footer fallback", (
 // sidebar-entry-core (logoRow row, legacy direct-child button), (b) re-asserts
 // its slot from the existing observer, and (c) stays idempotent — the anchor
 // check short-circuits before any DOM write, so observers never ping-pong.
-test("entry re-asserts the New-Session-adjacent slot against ecosystem entries", () => {
+test("entry re-asserts its slot against ecosystem entries", () => {
   assert.ok(
     clientSource.includes(`btn.closest('[class*="logoRow"]')`),
     "the anchor must resolve the New-Session logo row like the ecosystem core"
@@ -192,18 +204,55 @@ test("entry re-asserts the New-Session-adjacent slot against ecosystem entries",
     "placement must be idempotent so the observer never writes on steady state"
   );
   assert.ok(
-    /place\(cur\);\s*\n\s*const cls = findNative\(cur\)/.test(clientSource),
-    "the observer must re-place the entry on childList churn, not just re-sync the class"
+    /place\(cur\);\s*\n\s*sync\(cur\);/.test(clientSource),
+    "the observer must re-place the entry and re-read its classes on childList churn"
+  );
+});
+
+// 用户实测确认的遮挡 bug（v0.8.10）：收起侧边栏时入口沿用宿主给「新会话」的
+// left:48px，正好压在「新会话」图标上把它盖掉，左上角只剩两颗图标。
+// 修法：不再共用那个 left，用一条更具体的规则推到 84px（「新会话」右侧 =
+// 宿主 48px + 钮宽 28px + 间距 8px），并把宿主的面板菜单变量
+// --dsh-windows-menu-start（宿主收起态自己设 84px）顺延到 120px。
+// 回归表现：左上角少一颗图标，或「应用 / 编辑」与记忆图标叠在一起。
+test("collapsed entry vacates the New-Session slot instead of covering it", () => {
+  assert.ok(
+    clientSource.includes("html[data-windows-titlebar] .mneme-topentry .mneme-topentry-rail{left:84px}"),
+    "the collapsed entry must sit right of the host's 48px New-Session slot"
+  );
+  assert.ok(
+    // 源码里这段 CSS 含转义引号（注入 <style> 后才还原成普通引号），断言按源码字面量写。
+    clientSource.includes(':has([data-plugin-entry=\\"@modusensus/dsh-mneme\\"]){--dsh-windows-menu-start:120px}'),
+    "the caption menu must shift right so the memory icon never overlaps 应用 / 编辑"
+  );
+  assert.ok(
+    clientSource.includes(":has([data-sidebar-collapsed=true]):has("),
+    "the menu shift must apply only while the sidebar is collapsed"
+  );
+  assert.ok(
+    clientSource.includes("`${cls.row} mneme-topentry-rail`.trim()"),
+    "the collapsed button carries the host New-Session class plus our rail offset rule"
+  );
+});
+
+// 宿主面板行的类名带着激活态修饰类（.xxx_panelActive），而我们的入口不是
+// panel 插槽的成员、永远不该常亮；照抄整串类名会让记忆入口跟着宿主当前选中
+// 的面板一起高亮。这里锁「读类名时必须剔掉激活态」。
+test("panel-row highlight never leaks onto the memory entry", () => {
+  assert.ok(
+    clientSource.includes('!name.includes("panelActive")'),
+    "panelActive must be filtered out of the copied host row classes"
   );
 });
 
 // Three alignment/softness guarantees born from field feedback: (a) the
-// portalled entry keeps tracking the live New-Session class (host and skin
-// rewrite it asynchronously, so a mount-time snapshot goes stale), (b) it
-// inherits that button's width and margins along with its native centering,
-// (c) the toolbar dropdown escapes the transform stacking trap — the
+// portalled entry re-reads the live host classes on every mutation — the host
+// and skins rewrite hashed class names asynchronously, so a mount-time snapshot
+// goes stale (收起态尤其依赖这条：搬迁后类名必须重新对齐宿主「新会话」按钮),
+// (b) it never hardcodes a width, so whichever host class it carries decides the
+// box model, (c) the toolbar dropdown escapes the transform stacking trap — the
 // container needs the z-index because transform creates the context.
-test("entry tracks native class, inherits native sizing, and lifts the toolbar dropdown", () => {
+test("entry re-reads the live host classes and lifts the toolbar dropdown", () => {
   assert.ok(
     clientSource.includes("new MutationObserver"),
     "the entry must re-sync the copied class via MutationObserver"
@@ -334,33 +383,99 @@ test("graph toggle uses a node-graph glyph, not the share icon", () => {
   );
 });
 
-// #287 跨代图标守卫：primitives 在 0.1.7 把归档图标从「像素后缀」改名成「字重后缀」
-// （IconArchiveOutline20 → …OutlineRegular / …OutlineMedium），旧名不留别名，而
-// peerDependencies 仍同时覆盖 0.1.6 与 0.1.7 两代宿主。只认某一代的名字，另一代就会
-// 把 undefined 交给 h()，落成 slot entry 里的 React #130（该 entry 整块崩），因此必须
-// 探测两代名字、并在全缺时降级为不渲染图标。
-test("#287: archive glyph probes both naming generations and degrades to no glyph", () => {
-  assert.ok(
-    /primitives\.IconArchiveOutline20\s*\?\?\s*primitives\.IconArchiveOutlineRegular\s*\?\?\s*primitives\.IconArchiveOutlineMedium/.test(clientSource),
-    "the glyph must probe the 0.1.6 pixel name before the 0.1.7 weight names"
-  );
+// #287 的成因已经不存在了，但那条教训要留着：当年的崩法是「宿主图标名换代 →
+// 取到 undefined → h(undefined) 即 React #130，整个 slot entry 崩掉」。现在的解法
+// 不是继续探测多代名字，而是**不再依赖宿主图标库**——插件自己画 mneme mark。
+// 这条用例锁三件事：(a) 客户端里不再有对宿主 IconArchive* 名字的探测（回到探测
+// 就等于把 #287 那类耦合请回来）；(b) mark 走一个内联 SVG 组件、自带路径常量；
+// (c) 四个入口共用同一个 helper，避免某处漏改又出现"归档盒"。
+test("mneme mark is self-drawn: no host icon-name probing left (#287 root cause)", () => {
   assert.equal(
-    /h\(IconArchiveOutline20/.test(clientSource),
+    /primitives\.IconArchiveOutline(20|Regular|Medium)/.test(clientSource),
     false,
-    "the raw constant must never reach h() — on a host lacking that name it renders undefined (React #130)"
+    "the client must not probe host archive glyph names any more"
+  );
+  assert.ok(
+    /const MNEME_MARK_D = "M[^"]+"/.test(clientSource),
+    "the mark must carry its own path constant"
+  );
+  assert.ok(
+    clientSource.includes('viewBox: "0 0 16 16"') && clientSource.includes('stroke: "currentColor"'),
+    "the mark must follow the host icon spec (16 grid, currentColor) so it reads as first-party"
   );
   assert.ok(
-    /const renderArchiveIcon = \(props\) => \(IconArchive \? h\(IconArchive, props\) : null\)/.test(clientSource),
-    "the glyph must render through a null-guarded helper so a missing icon degrades to nothing"
+    /const renderMnemeMark = \(props\) => h\(MnemeMark, props\)/.test(clientSource),
+    "the mark must render through one shared helper"
   );
   for (const site of [
-    "renderArchiveIcon({ size: 15 })",              // 浮层标题栏
-    "renderArchiveIcon({ size: wide ? 16 : 18 })",  // 侧栏 trigger
-    "renderArchiveIcon({ size: wide ? 15 : 18 })",  // portal 到宿主原生侧栏的入口
-    "renderArchiveIcon({ size })"                   // better-sidebar tab 图标
+    "renderMnemeMark({ size: 15 })",              // 浮层标题栏
+    "renderMnemeMark({ size: wide ? 16 : 18 })",  // 侧栏 trigger + portal 入口（面板行档 16 / 标题栏档 18）
+    "renderMnemeMark({ size })"                   // better-sidebar tab 图标
   ]) {
     assert.ok(clientSource.includes(site), `every render site must go through the helper: ${site}`);
   }
+  assert.equal(
+    /renderArchiveIcon/.test(clientSource),
+    false,
+    "the retired archive-glyph helper must be gone, not left as a second path"
+  );
+});
+
+// 插件列表那颗图标由宿主从 package.json 的 `icon` 读：必须是**包内相对路径**、
+// 落在 files 白名单里、且宿主只接受 SVG/PNG/JPEG/WebP ≤256KiB。
+// 宿主 `iconOf()` 的硬规则：绝对路径或带 scheme 直接报错、realpath 后不许跑出
+// manifest 目录、超 256KiB 报错；缺文件/坏文件时静默回落成通用插画（等于用户
+// 看到的不是自家图标）。这里把可静态检的部分全锁住。
+test("plugin-list icon: declared, in-package, and shipped in files", () => {
+  const icon = pkg.icon;
+  assert.equal(typeof icon, "string", "package.json must declare an icon");
+  assert.equal(icon, "assets/icon.svg", "the icon must be the self-drawn mark");
+  assert.ok(!/^([A-Za-z]:|[A-Za-z][A-Za-z\d+.-]*:)/.test(icon), "the icon must be a relative path (host rejects absolute/URL)");
+  assert.ok(pkg.files.includes("assets"), "the assets dir must ship, or the published package has no icon");
+  const file = join(root, icon);
+  assert.ok(existsSync(file), `the declared icon must exist: ${icon}`);
+  const bytes = readFileSync(file);
+  assert.ok(bytes.length > 0 && bytes.length <= 256 * 1024, "the icon must be a non-empty file under the host's 256 KiB cap");
+  const svg = bytes.toString("utf8");
+  assert.ok(svg.includes("<svg") && svg.includes("viewBox"), "the icon must be an SVG with a viewBox");
+  // <img> 不能继承 currentColor：文件必须自带颜色，否则会渲染成黑块/不可见。
+  assert.ok(/stroke="#[0-9a-fA-F]{6}"/.test(svg), "the standalone file must bake its own colour (<img> cannot inherit currentColor)");
+  // 文件与客户端内联路径必须是同一颗：两边形状漂移是最容易悄悄发生的事。
+  const inline = clientSource.match(/const MNEME_MARK_D = "([^"]+)"/)[1];
+  assert.ok(svg.includes(inline), "assets/icon.svg must use the same path as the inline mark (no shape drift)");
+});
+
+// 插件列表的标题/描述读包内的 `locale/<语言码>.json`：宿主 readPluginMeta 先解析
+// `<specifier>/locale/en.json`，再遍历同目录的每个 *.json（文件名必须过语言码正则），
+// 取 meta.title / meta.description；一个都读不到就回落到 package.json 的 name——
+// 也就是裸包名 "@modusensus/dsh-mneme"（用户看到的现状）。
+// ⚠️ 真正的门槛是**能否被 Node 解析**：宿主用 ESM resolver 取这个文件，而 exports
+// 字段会把没列出的子路径**全部挡掉**，且 optionalResourcePath 对"读不到"是静默的
+// （返回 undefined 继续走回落），不报错。所以少了 "./locale/*" 这一行，文件乖乖躺在
+// 包里也永远不生效——这条回归极难靠肉眼发现，必须锁死。
+test("plugin-list title/description are localized through locale/*.json", () => {
+  assert.ok(
+    Object.keys(pkg.exports).includes("./locale/*"),
+    "exports must expose ./locale/* or the host resolver silently never reads the dictionaries"
+  );
+  assert.ok(pkg.files.includes("locale"), "the locale dir must ship in files, or the published package loses it");
+  const dir = join(root, "locale");
+  assert.ok(existsSync(dir), "locale/ must exist");
+  const files = readdirSync(dir).filter((name) => name.endsWith(".json"));
+  assert.ok(files.length >= 2, "at least an English and a Chinese dictionary must ship");
+  for (const name of files) {
+    const language = name.slice(0, -5);
+    assert.match(language, /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/, `locale/${name} must be named after a language id`);
+    const parsed = JSON.parse(readFileSync(join(dir, name), "utf8"));
+    assert.equal(typeof parsed.meta, "object", `locale/${name} must carry a meta block`);
+    assert.ok(typeof parsed.meta.title === "string" && parsed.meta.title.trim() !== "", `locale/${name}: meta.title must be a non-empty string`);
+    assert.ok(
+      typeof parsed.meta.description === "string" && parsed.meta.description.trim() !== "",
+      `locale/${name}: meta.description must be a non-empty string`
+    );
+  }
+  const en = JSON.parse(readFileSync(join(dir, "en.json"), "utf8"));
+  assert.ok(en.meta.title !== pkg.name, "the English title must not be the bare package name (that is the bug this fixes)");
 });
 
 // 方案 A：查询收敛。状态页只做仪表盘（小页预览 + 服务端 total + 查看全部），
@@ -937,11 +1052,96 @@ test("conflict queue: actionable status card and sidebar entry badge", () => {
   assert.ok(clientSource.includes("mneme-statuscard--actionable"), "highlight CSS must exist");
   assert.ok((clientSource.match(/h\(ConflictBadge, \{ pending \}\)/g) || []).length === 2,
     "badge must be wired into both entry buttons");
-  assert.ok((clientSource.match(/= useConflictBadgeCount\(t\)/g) || []).length === 2,
-    "both entry components must subscribe to the badge count");
+  assert.ok((clientSource.match(/= useConflictBadgeCount\(\);/g) || []).length === 2,
+    "both entry components must subscribe to the shared badge count");
   assert.ok(clientSource.includes('"/api/dsh-mneme/dream-status"'), "badge must reuse the dream-status endpoint");
 });
 
+// 用户反馈「裁决完红点消失得很慢」的根因：裁决成功时冲突队列广播
+// mneme:conflicts-changed，但只有状态卡订阅了它，侧边栏红点漏订——红点于是只能
+// 等 60s 兜底轮询。本用例锁三类回归：(a) 红点订阅该广播并立即重取；(b) 计数走
+// 模块级单例（原先 portal 与 footer 回退各起一个 60s 轮询 → 两份请求且互不同步）；
+// (c) 兜底轮询保留（后台 autoDream 自己产生/消解冲突时没人广播，靠它浮现）。
+test("sidebar badge clears on the conflicts-changed broadcast, not on the next poll", () => {
+  assert.ok(
+    /window\.addEventListener\("mneme:conflicts-changed", onChanged\)/.test(clientSource),
+    "the badge must subscribe to the broadcast the conflict queue already emits"
+  );
+  assert.ok(
+    clientSource.includes("const conflictBadgeCount = (() => {"),
+    "the count must live in one module-level store shared by both entry components"
+  );
+  assert.ok(
+    clientSource.includes("if (listeners.size === 1) {"),
+    "exactly one poll timer per store, refcounted by its subscribers"
+  );
+  assert.ok(
+    /setInterval\(refresh, 60_000\)/.test(clientSource),
+    "the 60s fallback poll must stay: background autoDream resolves conflicts without broadcasting"
+  );
+  assert.ok(
+    clientSource.includes("if (inflight) return inflight;"),
+    "concurrent refreshes (broadcast + open + first subscriber) must collapse into one request"
+  );
+});
+
+// 上一条锁的是"接线在不在"，这条锁"接线真的按预期跑"。把源码里那段 store 抠出来
+// 用受控的 apiFetch / setInterval 真跑一遍——用户抱怨的正是时序（慢），而
+// "存在某个字符串" 证明不了任何时序。回归表现：第二个订阅者又开一条轮询、
+// 广播后不立刻反映、并发 refresh 打两次请求、订阅者走光后定时器还在跑。
+test("badge store: one poll for both entries, immediate publish after a refresh", async () => {
+  const src = clientSource.match(/const conflictBadgeCount = \(\(\) => \{[\s\S]*?\}\)\(\);/);
+  assert.ok(src, "the badge store source block must be extractable verbatim");
+  const calls = [];
+  const resolvers = [];
+  const timers = [];
+  let cleared = 0;
+  const makeStore = new Function("apiFetch", "setInterval", "clearInterval",
+    `${src[0]}\nreturn conflictBadgeCount;`);
+  const store = makeStore(
+    (path) => {
+      calls.push(path);
+      return new Promise((resolve) => { resolvers.push(resolve); });
+    },
+    (fn, ms) => { timers.push({ fn, ms }); return timers.length; },
+    () => { cleared += 1; }
+  );
+  const settle = async (payload) => {
+    const batch = resolvers.splice(0, resolvers.length);
+    batch.forEach((r) => r({ ok: true, json: () => Promise.resolve(payload) }));
+    await new Promise((r) => setTimeout(r, 0));
+  };
+
+  const seen = [];
+  const un1 = store.subscribe((v) => seen.push(v));
+  assert.equal(calls.length, 1, "the first subscriber must trigger exactly one fetch");
+  assert.equal(timers.length, 1, "and exactly one timer");
+  assert.equal(timers[0].ms, 60_000, "the fallback cadence stays 60s");
+  const un2 = store.subscribe((v) => seen.push(v));
+  assert.equal(calls.length, 1, "a second subscriber must reuse the poll, not start another");
+  assert.equal(timers.length, 1, "still one timer for both entry buttons");
+
+  await settle({ pendingConflicts: 3 });
+  assert.deepEqual(seen, [0, 0, 3, 3], "both subscribers must see the same published value");
+
+  // 广播路径：冲突队列裁决成功后 dispatch mneme:conflicts-changed → hook 调 refresh()
+  store.refresh();
+  store.refresh();
+  assert.equal(calls.length, 2, "concurrent refreshes collapse into a single in-flight request");
+  await settle({ pendingConflicts: 0 });
+  assert.equal(store.get(), 0, "the count must drop as soon as the refreshed value lands");
+  assert.equal(seen[seen.length - 1], 0, "and both subscribers must be notified");
+
+  store.refresh();
+  await settle({ pendingConflicts: 0 });
+  assert.deepEqual(seen, [0, 0, 3, 3, 0, 0], "an unchanged value must not re-render subscribers");
+
+  un1();
+  assert.equal(cleared, 0, "the timer must survive while one subscriber remains");
+  un2();
+  assert.equal(cleared, 1, "the timer must stop when the last subscriber leaves");
+});
+
 // --- issue #179：注入预览（状态页卡片 + /inject-preview 端点透传的旁路快照） ---
 test("a11y+preview: inject preview card is wired on the status tab", () => {
   assert.ok(clientSource.includes('"/api/dsh-mneme/inject-preview"'), "card must fetch the preview endpoint");