@modusensus/dsh-mneme 0.8.10 → 0.8.11

package/README.md

@@ -5,7 +5,7 @@
 [![npm version](https://img.shields.io/npm/v/@modusensus/dsh-mneme?color=blue&label=npm)](https://www.npmjs.com/package/@modusensus/dsh-mneme)
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![Awesome](https://awesome-dsh-plugin.com/badge.svg)](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin)
-[![tests](https://img.shields.io/badge/tests-1431%20passed-success)](https://github.com/slow-stack/mneme)
+[![tests](https://img.shields.io/badge/tests-1437%20passed-success)](https://github.com/slow-stack/mneme)
 [![CI](https://img.shields.io/github/actions/workflow/status/slow-stack/mneme/ci.yml)](https://github.com/slow-stack/mneme/actions)
 [![node](https://img.shields.io/badge/node-22%2B-blue)](https://nodejs.org)
 [![npm downloads](https://img.shields.io/npm/d18m/@modusensus/dsh-mneme.svg?color=blue&label=downloads)](https://www.npmjs.com/package/@modusensus/dsh-mneme)

package/assets/icon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 16 16" fill="none" stroke="#4176e6" stroke-width="1" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M4.43 12.31C2.19 10.17 2.27 6.81 4.18 4.84C6.10 2.88 9.06 2.99 10.74 4.68C12.43 6.37 12.28 8.92 10.82 10.33C9.35 11.74 7.22 11.55 6.08 10.32C4.95 9.08 5.18 7.35 6.18 6.50C6.57 6.17 7.03 5.99 7.48 5.97"/>
+</svg>

package/lib/client.js

@@ -68,19 +68,37 @@ window.__ModuleLoader__.load({
       if (ops.filter((o) => o.kind !== "same").length > 200) return null;
       return ops;
     }
-    // #287 归档图标跨代兼容：primitives 在 0.1.7 把图标命名从「像素后缀」改成
-    // 「字重后缀」（IconArchiveOutline20 → …OutlineRegular / …OutlineMedium），
-    // 旧名不留别名，而 peerDependencies 同时覆盖 0.1.6 与 0.1.7 两代宿主——
-    // 只认某一代的名字，另一代就会取到 undefined，h(undefined) 即 React #130
-    // （整个 slot entry 崩掉）。故按「旧名 → 新名」顺序取第一个存在的；
-    // 两代都缺时降级为不渲染图标，宁可无图标也不把 slot 打崩。
-    const IconArchive = primitives.IconArchiveOutline20
-      ?? primitives.IconArchiveOutlineRegular
-      ?? primitives.IconArchiveOutlineMedium
-      ?? null;
-
-    /** 渲染归档图标；宿主未提供任一候选名时返回 null（无图标，不影响其余内容）。 */
-    const renderArchiveIcon = (props) => (IconArchive ? h(IconArchive, props) : null);
+    // --- mneme mark：插件自己的标识图标 -------------------------------------
+    // 不再借宿主的 IconArchiveOutline*，两个原因：
+    //  · 语义撞车——「归档盒」和记忆库里的归档动作是同一个符号，用户反馈看不出
+    //    这是记忆插件（issue 走维护者自开通道）；
+    //  · 宿主耦合——宿主图标名会换代（#287：Outline20 → OutlineRegular/Medium），
+    //    只认某一代就取到 undefined，h(undefined) 即 React #130 把整个 slot entry
+    //    崩掉。自绘后这一整类问题消失，也不再需要「探测多代名字 + 缺名降级」。
+    // 形状：单线螺旋（记忆痕迹 / 召回回路）。规格逐条对齐宿主图标，才不像外来户：
+    // 16 栅格、fill:none、stroke:currentColor、描边 1（宿主 Regular 档）、圆头圆角。
+    // 路径是 6 段三次贝塞尔拟合同一螺旋（拟合版与逐点采样版逐像素一致，已核验），
+    // 所以源码里只有 200 字符，不是一百多个采样点。
+    // 改形状只需换 MNEME_MARK_D，并同步 assets/icon.svg（插件列表那份，同一个 d）。
+    const MNEME_MARK_D = "M4.43 12.31C2.19 10.17 2.27 6.81 4.18 4.84C6.10 2.88 9.06 2.99 10.74 4.68C12.43 6.37 12.28 8.92 10.82 10.33C9.35 11.74 7.22 11.55 6.08 10.32C4.95 9.08 5.18 7.35 6.18 6.50C6.57 6.17 7.03 5.99 7.48 5.97";
+
+    /** mneme mark 的内联 SVG；currentColor + 描边 1，随主题与字号走。 */
+    const MnemeMark = ({ size = 16, className }) => h("svg", {
+      width: size,
+      height: size,
+      className,
+      viewBox: "0 0 16 16",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      "aria-hidden": "true",
+      stroke: "currentColor",
+      strokeWidth: 1,
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }, h("path", { d: MNEME_MARK_D }));
+
+    /** 渲染 mneme mark：四个入口（浮层标题栏 / footer 回退 / 侧边栏 portal / better-sidebar tab）共用同一颗。 */
+    const renderMnemeMark = (props) => h(MnemeMark, props);
 
     // Portal target for the hero fallback surface. The host whitelists
     // react-dom for its own bundles (dsh-client-ui-trajectory requires it);
@@ -1328,11 +1346,26 @@ window.__ModuleLoader__.load({
       ".mneme-heat--warm{color:var(--dsw-alias-label-secondary)}",
       ".mneme-heat--cold{color:var(--dsw-alias-label-tertiary)}",
       ".mneme-heat--cold .mneme-heatpct{display:none}",
-      // 纵向 flex 容器按原生按钮的宽度与外边距分配空间，保留展开和收起态的对齐。
+      // 侧边栏入口两种形态的样式（挂载与搬移逻辑见 SidebarTopEntry 的头注释）。
+      // 展开态兜底：逐条镜像宿主 panelRow（36px 行高 / 透明底 / 2px 外边距 /
+      // 7px 8px 内边距）——宿主面板行类名在或不在，观感都是「插件 / 自动化任务」
+      // 那一档，不会再退回 v0.8.10 那种高亮大按钮。
+      // 收起态：按钮带宿主 newSession 类名，标题栏固定几何（position:fixed、
+      // 顶部居中、28px 圆钮、次级文字色、hover 填充）整套继承宿主规则，我们只用
+      // 一条更具体的规则把 left 从宿主的 48px 推到 84px——即「新会话」右侧，
+      // 不再像 v0.8.10 那样压在它身上（用户实测确认的遮挡 bug）。
+      // 84 = 48（宿主给「新会话」的 left）+ 28（钮宽）+ 8（间距）；120 = 84 + 28 + 8，
+      // 让「应用 / 编辑」菜单顺延到我们右侧。宿主侧出处：SidebarRoot.module.css 的
+      // `.collapsed .newSession{left:48px}` 与
+      // `html[data-windows-titlebar]:has([data-sidebar-collapsed=true]){--dsh-windows-menu-start:84px}`。
       ".mneme-topentry{display:flex;flex-direction:column;position:relative}",
-      ".mneme-topentry-native{background:var(--dsw-alias-bg-layer-1);border:1px solid var(--dsw-alias-border-l2);color:var(--dsw-alias-label-primary)}",
+      ".mneme-topentry-native{box-sizing:border-box;min-height:36px;border:none;border-radius:var(--dsw-radius-md);background:0 0;color:var(--dsw-alias-label-primary);font:inherit;text-align:left;cursor:pointer;align-items:center;gap:8px;margin:0 2px;padding:7px 8px;line-height:22px;display:flex}",
       ".mneme-topentry-native:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
+      ".mneme-topentry-native:focus-visible{outline:var(--dsw-focus-ring-width) solid var(--dsw-focus-ring-color,var(--dsw-alias-state-business-primary));outline-offset:-2px}",
       ".mneme-topentry-native .mneme-topentry-label{white-space:nowrap}",
+      "html[data-windows-titlebar] .mneme-topentry .mneme-topentry-rail{left:84px}",
+      // 菜单让位只在「收起 + 入口确实挂在标题栏里」时生效；展开态完全不碰宿主变量。
+      "html[data-windows-titlebar]:has([data-sidebar-collapsed=true]):has([data-plugin-entry=\"@modusensus/dsh-mneme\"]){--dsh-windows-menu-start:120px}",
       // --- 功能开关：一行一开关，Claude 式安静排版 ---
       ".mneme-featgroup{flex:none;font-size:12px;font-weight:600;letter-spacing:.02em;color:var(--dsw-alias-label-tertiary);margin:16px 0 2px}",
       ".mneme-featrow{display:flex;align-items:center;gap:14px;padding:11px 2px;border-bottom:1px solid var(--dsw-alias-border-l1)}",
@@ -3031,6 +3064,10 @@ window.__ModuleLoader__.load({
     // MemoryExplorer 内部状态（选中行、过滤）由各自的跳转回调处理。
     function openLibrary() {
       setOverlayOpen(true);
+      // 打开面板 = 用户正准备处理冻结冲突：顺手把入口红点重取一次，别让他
+      // 对着一个已经过期的计数（裁决走别的路径、或后台 autoDream 刚写过库时，
+      // 计数不该等 60s 兜底轮询才对齐）。
+      conflictBadgeCount.refresh();
     }
 
     // --- Hero fallback overlay state (module-level pub/sub) ---
@@ -3098,7 +3135,7 @@ window.__ModuleLoader__.load({
         h("div", { className: "mneme-overlay", role: "region", "aria-label": t("memory.view.label"), ref: panelRef },
           h("div", { className: "mneme-overlaybar" },
             h("span", { className: "mneme-overlaytitle" },
-              renderArchiveIcon({ size: 15 }),
+              renderMnemeMark({ size: 15 }),
               t("memory.view.label")
             ),
             h("button", {
@@ -4924,32 +4961,80 @@ window.__ModuleLoader__.load({
       );
     }
 
-    // --- Sidebar entry: 工作区上方的记忆按钮 ---
+    // --- Sidebar entry: 侧边栏里的记忆入口 ---
     // 注册仍在 sidebar.footer.action（list 插槽）——它既是 React 树的挂载
-    // 锚点，也是 portal 失效时的原位回退。真实按钮 portal 插到「新会话」行
-    // 之后、插件入口组的最前：任务看板/技能中心等生态插件也把入口插在新会话
-    // 行后（它们的后插入者在上），若我们固定在 regionArea 之前就会被打成
-    // 入口组末尾的孤立位（issue #130），所以观察器发现错位就搬回锚点位。
-    // 几何对齐方案：读取宿主「新会话」按钮的实时 className 原样套用，再用
-    // 我们的修饰类覆盖配色（次级观感）。这样展开态与收起态（rail）都直接
-    // 继承宿主自己的盒模型与间距——宿主改版/缩进动画零位移，无需硬编码。
+    // 锚点，也是 portal 失效时的原位回退；常驻 sheet 也从这个插槽挂载。
+    // 入口形状跟着宿主 v0.2 的侧边栏走，分两态：
+    //  · 展开态：宿主把「插件 / 自动化任务」这类全局面板渲染成 nav.panelList
+    //    里的 panelRow（36px 行高、透明底、图标 + 标题）。我们把按钮 portal 进
+    //    同一组并原样套用宿主 panelRow 的实时类名，于是它是该组的第三行——低调，
+    //    而不是 v0.8.10 那样长得像第二个高亮「新会话」按钮。
+    //  · 收起态（Windows 标题栏）：panelList / regionArea / footArea 被宿主
+    //    display:none，只有开关与「新会话」被改成固定在标题栏上。我们把按钮搬回
+    //    标题栏、并排在「新会话」右侧（84px / 120px 的算法见上面 CSS 注释），
+    //    三颗图标各就各位——v0.8.10 把入口留在宿主的 48px 上把它盖住了。
+    // 承载类名一律从活元素读取（宿主/皮肤会异步改写哈希类名），不硬编码；
+    // 面板列表不存在（没装任何面板插件）时退回「新会话」行之后。
     // 宿主结构异常时约 2 秒后放弃 portal，footer 回退按钮保持可用。
-    // #177：未处理冲突数 badge——数据走 dream-status 的 pendingConflicts（状态卡
-    // 同一端点），60s 轮询 + 打开面板即刷新。挂侧边栏入口按钮右上角（portal 与
-    // 回退两处都挂），让用户不进面板也知道有冻结要裁决。
-    function useConflictBadgeCount(t) {
-      const [pending, setPending] = useState(0);
+    // #177：未处理冲突数 badge——数据走 dream-status 的 pendingConflicts（与状态卡
+    // 同一端点）。挂侧边栏入口按钮右上角（portal 与回退两处都挂），让用户不进面板
+    // 也知道有冻结要裁决。
+    // 刷新时机（用户反馈「裁决完红点消失得很慢」后重做）：
+    //  · 裁决成功时冲突队列广播 mneme:conflicts-changed → 立刻重取，不必等下一轮；
+    //    此前这条广播只有状态卡订阅，红点漏订，才慢到要等 60s 兜底轮询；
+    //  · openLibrary 打开面板时重取（见上）；
+    //  · 60s 兜底轮询——后台 autoDream 自己产生/消解冲突时没人广播，靠它浮现。
+    // 计数是模块级单例：入口按钮的 portal 与 footer 回退是两个组件，原先各起一个
+    // 60s 轮询（两份请求、两个互不同步的计数）。现在共享一个 store：一次取回广播给
+    // 全部订阅者，in-flight 请求也去重，最后一个订阅者离开才停表。
+    const conflictBadgeCount = (() => {
+      const listeners = new Set();
+      let value = 0;
+      let timer = null;
+      let inflight = null;
+      const publish = (next) => {
+        if (next === value) return;
+        value = next;
+        listeners.forEach((fn) => {
+          try { fn(value); } catch { /* 单个订阅者出错不拖垮其余 */ }
+        });
+      };
+      const refresh = () => {
+        if (inflight) return inflight;
+        inflight = apiFetch("/api/dsh-mneme/dream-status")
+          .then((res) => (res.ok ? res.json() : { pendingConflicts: 0 }))
+          .then((d) => { publish(Number((d && d.pendingConflicts) ?? 0) || 0); })
+          .catch(() => { publish(0); })
+          .finally(() => { inflight = null; });
+        return inflight;
+      };
+      return {
+        get: () => value,
+        refresh,
+        subscribe: (fn) => {
+          listeners.add(fn);
+          fn(value);
+          if (listeners.size === 1) {
+            refresh();
+            timer = setInterval(refresh, 60_000);
+          }
+          return () => {
+            listeners.delete(fn);
+            if (listeners.size === 0 && timer !== null) { clearInterval(timer); timer = null; }
+          };
+        }
+      };
+    })();
+    function useConflictBadgeCount() {
+      const [pending, setPending] = useState(() => conflictBadgeCount.get());
       useEffect(() => {
-        let cancelled = false;
-        const tick = () => {
-          apiFetch("/api/dsh-mneme/dream-status")
-            .then((res) => (res.ok ? res.json() : { pendingConflicts: 0 }))
-            .then((d) => { if (!cancelled) setPending(Number((d && d.pendingConflicts) ?? 0) || 0); })
-            .catch(() => { if (!cancelled) setPending(0); });
+        const unsubscribe = conflictBadgeCount.subscribe(setPending);
+        const onChanged = () => { conflictBadgeCount.refresh(); };
+        window.addEventListener("mneme:conflicts-changed", onChanged);
+        return () => {
+          unsubscribe();
+          window.removeEventListener("mneme:conflicts-changed", onChanged);
         };
-        tick();
-        const timer = setInterval(tick, 60_000);
-        return () => { cancelled = true; clearInterval(timer); };
       }, []);
       return pending;
     }
@@ -4959,7 +5044,7 @@ window.__ModuleLoader__.load({
         pending > 99 ? "99+" : String(pending));
     }
     function SidebarFallbackTrigger({ wide, t }) {
-      const pending = useConflictBadgeCount(t);
+      const pending = useConflictBadgeCount();
       // #295 评审：.mneme-trigger 自身 overflow:hidden 且无定位上下文，badge
       // 直接放里面会被裁剪——包一层定位容器，badge 挂在容器上。
       return h("div", { className: "mneme-triggerwrap" },
@@ -4973,7 +5058,7 @@ window.__ModuleLoader__.load({
           onClick: openLibrary,
           "data-mneme-overlay-opener": "true"
         },
-          renderArchiveIcon({ size: wide ? 16 : 18 }),
+          renderMnemeMark({ size: wide ? 16 : 18 }),
           wide && h("span", { className: "mneme-trigger-label" }, t("memory.panel.open"))
         ),
         h(ConflictBadge, { pending })
@@ -4982,14 +5067,25 @@ window.__ModuleLoader__.load({
 
     function SidebarTopEntry({ wide, t, fallback }) {
       const [host, setHost] = useState(null);
-      const [nativeCls, setNativeCls] = useState("");
-      const pending = useConflictBadgeCount(t);
+      const [cls, setCls] = useState({ row: "", glyph: "", title: "" });
+      const pending = useConflictBadgeCount();
       useEffect(() => {
         if (!reactDom || typeof document === "undefined") return undefined;
         let tries = 0, timer = null, created = null, mo = null;
+        const findRegion = () => {
+          const region = document.querySelector('[class*="regionArea"]');
+          return region && region.parentElement ? region : null;
+        };
         const findNative = (region) =>
           region.parentElement.querySelector('[class*="newSession"]')
           || region.previousElementSibling;
+        const findPanelList = (region) =>
+          region.parentElement.querySelector('[class*="panelList"]');
+        // 宿主自己的面板行：排除我们自己 portal 进去的那颗按钮（它也带 panelRow）。
+        const findPanelRow = (region) => {
+          const list = findPanelList(region);
+          return list ? list.querySelector('[class*="panelRow"]:not(.mneme-topentry-native)') : null;
+        };
         // 占位锚点：新会话行（现役外壳里 newSession 按钮嵌在 logoRow 内，
         // 旧外壳是根的直接子按钮）。判定与生态插件的 sidebar-entry-core
         // 一致；锚点不可靠时回退到 regionArea 之前的旧位置。
@@ -5008,32 +5104,61 @@ window.__ModuleLoader__.load({
         // insertBefore(x, x) 在 Chromium 里不是 no-op，会触发 mutation 造成
         // 观察器自激风暴、冻死整个 SPA。
         const place = (region) => {
+          if (!created) return;
           const parent = region.parentElement;
           if (!parent) return;
+          // 展开态落进宿主的面板列表（紧跟「插件 / 自动化任务」）；宿主没有面板
+          // 列表时退回「新会话」行之后，由 .mneme-topentry-native 兜住低调行样式。
+          const list = wide ? findPanelList(region) : null;
+          if (list) {
+            if (created.parentElement === list && created === list.lastElementChild) return;
+            list.appendChild(created);
+            return;
+          }
           const anchor = findAnchor(region);
           const target = anchor ? anchor.nextSibling : region;
           if (target === created) return;
           if (created.parentElement === parent && created.nextSibling === target) return;
           parent.insertBefore(created, target);
         };
+        // 类名一律从活元素读。展开态借宿主面板行的盒模型，并剔掉激活态修饰类
+        // （否则我们的行会跟着宿主当前选中的面板一起常亮）；收起态借「新会话」
+        // 按钮的类名拿整套标题栏固定几何。两处都取不到时留空，由我们的类兜底。
+        const readCls = (region) => {
+          if (!wide) return { row: findNative(region)?.className || "", glyph: "", title: "" };
+          const row = findPanelRow(region);
+          const btn = row || findNative(region);
+          const glyph = row && row.querySelector('[class*="panelGlyph"]');
+          const title = row && row.querySelector('[class*="panelTitle"]');
+          return {
+            row: (btn?.className || "")
+              .split(/\s+/)
+              .filter((name) => name && !name.includes("panelActive"))
+              .join(" "),
+            glyph: (glyph && glyph.className) || "",
+            title: (title && title.className) || ""
+          };
+        };
+        const sync = (region) => {
+          const next = readCls(region);
+          setCls((prev) => (prev.row === next.row && prev.glyph === next.glyph && prev.title === next.title ? prev : next));
+        };
         const attempt = () => {
-          const region = document.querySelector('[class*="regionArea"]');
-          if (region && region.parentElement) {
-            // 「新会话」按钮与 regionArea 同级且紧邻其前，借它的类名获得
-            // 与原生侧边栏项完全一致的盒模型（含收起态 rail 几何）。
-            // 宿主/皮肤会异步改写按钮类名，用 MutationObserver 持续同步，
-            // 否则 portal 按钮会停留在捕获时刻的旧类上（宽度/对齐失配）。
+          const region = findRegion();
+          if (region) {
+            // 宿主切换展开/收起时会重排 DOM（面板列表 → 标题栏固定位），所以每次
+            // 变动都重新落位并重读类名；宿主/皮肤异步改写类名也靠这条同步，否则
+            // portal 按钮会停留在捕获时刻的旧类上（宽度/对齐失配）。
             created = document.createElement("div");
             created.dataset.pluginEntry = "@modusensus/dsh-mneme";
             place(region);
             setHost(created);
-            setNativeCls(findNative(region)?.className || "");
+            sync(region);
             mo = new MutationObserver(() => {
-              const cur = document.querySelector('[class*="regionArea"]');
-              if (!cur || !cur.parentElement) return;
+              const cur = findRegion();
+              if (!cur) return;
               place(cur);
-              const cls = findNative(cur)?.className || "";
-              setNativeCls((prev) => (prev === cls ? prev : cls));
+              sync(cur);
             });
             mo.observe(region.parentElement, {
               attributes: true,
@@ -5052,13 +5177,19 @@ window.__ModuleLoader__.load({
           if (mo) mo.disconnect();
           if (created && created.parentElement) created.parentElement.removeChild(created);
         };
-      }, []);
+      }, [wide]);
       if (!host) return fallback;
+      // 图标与「插件 / 自动化任务」同档（16px）；收起态沿用标题栏里原来的 18px。
+      const icon = renderMnemeMark({ size: wide ? 16 : 18 });
       return reactDom.createPortal(
         h("div", { className: "mneme-topentry" },
           h("button", {
             type: "button",
-            className: `${nativeCls} mneme-topentry-native`.trim(),
+            // 展开态：宿主面板行类名 + 我们的同款兜底；收起态：宿主「新会话」类名
+            // + 只覆盖 left 的 rail 规则（整套标题栏几何继承宿主）。
+            className: wide
+              ? `${cls.row} mneme-topentry-native`.trim()
+              : `${cls.row} mneme-topentry-rail`.trim(),
             "aria-label": pending > 0
               ? `${t("memory.sidebar.aria")} · ${t("memory.status.conflicts")} ${pending}`
               : t("memory.sidebar.aria"),
@@ -5066,8 +5197,9 @@ window.__ModuleLoader__.load({
             onClick: openLibrary,
             "data-mneme-overlay-opener": "true"
           },
-            renderArchiveIcon({ size: wide ? 15 : 18 }),
-            wide && h("span", { className: "mneme-topentry-label" }, t("memory.panel.open")),
+            // 图标套上宿主面板行的槽位类名，视觉与同组入口完全一致；取不到时裸渲染。
+            cls.glyph ? h("span", { className: cls.glyph, "aria-hidden": "true" }, icon) : icon,
+            wide && h("span", { className: `${cls.title} mneme-topentry-label`.trim() }, t("memory.panel.open")),
             h(ConflictBadge, { pending })
           )
         ), host);
@@ -5128,7 +5260,7 @@ window.__ModuleLoader__.load({
                   reg.registerTab({
                     id: TAB_ID,
                     title: () => t("memory.view.label"),
-                    icon: (size) => renderArchiveIcon({ size }),
+                    icon: (size) => renderMnemeMark({ size }),
                     order: 60,
                     component: () => h(MemoryExplorer, { t })
                   });

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "mneme",
+    "description": "Cross-session memory: auto-distill each session into a local SQLite store, inject on demand, consolidate while idle (autoDream)."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "mneme 记忆库",
+    "description": "跨会话记忆：自动把会话沉淀进本机 SQLite，需要时按需注入，空闲时巩固（做梦）。"
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 9 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.8.10",
+  "version": "0.8.11",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -13,6 +13,7 @@
   },
   "type": "module",
   "main": "lib/index.js",
+  "icon": "assets/icon.svg",
   "bin": {
     "dsh-mneme": "bin/cli.mjs",
     "dsh-mneme-mcp": "bin/dsh-mneme-mcp.mjs"
@@ -24,11 +25,14 @@
     "./client": {
       "default": "./lib/client.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./locale/*": "./locale/*"
   },
   "files": [
+    "assets",
     "bin",
     "lib",
+    "locale",
     "src",
     "scripts",
     "test",

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");