@modusensus/dsh-mneme 0.8.6 → 0.8.8

package/lib/client.js

@@ -26,7 +26,61 @@ window.__ModuleLoader__.load({
       liveRegion.textContent = "";
       window.requestAnimationFrame(() => { if (liveRegion) liveRegion.textContent = text; });
     }
-    const IconArchiveOutline20 = primitives.IconArchiveOutline20;
+
+    // #177 词级 diff：经典 LCS 对齐——删除片段标红、新增标绿、公共部分原样。
+    // 分词两段式：Han 段先切出再逐字打散（\p{L} 把整句中文当一个词，必须单列），
+    // 其余按 Unicode 词边界（拉丁按词、标点独立）。相邻同侧片段合并成 run。
+    // 输入先截 800 字符；O(n·m) DP 仅在小文本启用（任一侧 > 800 词或 edit run
+    // > 200 时返回 null），caller 退回原文展示，不为极端文本烧内存。
+    function wordDiff(aText, bText) {
+      const HAN = /^[\u{3400}-\u{4DBF}\u{4E00}-\u{9FFF}\u{F900}-\u{FAFF}]+$/u;
+      const tokenize = (s) => (s || "")
+        .split(/([\u{3400}-\u{4DBF}\u{4E00}-\u{9FFF}\u{F900}-\u{FAFF}]+)/u)
+        .filter(Boolean)
+        .flatMap((seg) => HAN.test(seg)
+          ? [...seg]
+          : seg.split(/(?=[^\p{L}\p{N}])|(?<=[^\p{L}\p{N}])/u).filter(Boolean));
+      const a = tokenize((aText || "").slice(0, 800)), b = tokenize((bText || "").slice(0, 800));
+      const n = a.length, m = b.length;
+      if (n === 0 && m === 0) return null;
+      if (n > 800 || m > 800) return null; // ponytail: O(n·m) DP，800×800 封顶（~2.5MB Int32），超限退回原文
+      const dp = new Int32Array((n + 1) * (m + 1));
+      const at = (i, j) => i * (m + 1) + j;
+      for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+          dp[at(i, j)] = a[i] === b[j] ? dp[at(i + 1, j + 1)] + 1 : Math.max(dp[at(i + 1, j)], dp[at(i, j + 1)]);
+        }
+      }
+      const ops = [];
+      const push = (kind, text) => {
+        const last = ops[ops.length - 1];
+        if (last && last.kind === kind) last.text += text;
+        else ops.push({ kind, text });
+      };
+      let i = 0, j = 0;
+      while (i < n && j < m) {
+        if (a[i] === b[j]) { push("same", a[i]); i++; j++; }
+        else if (dp[at(i + 1, j)] >= dp[at(i, j + 1)]) { push("del", a[i]); i++; }
+        else { push("ins", b[j]); j++; }
+      }
+      while (i < n) { push("del", a[i]); i++; }
+      while (j < m) { push("ins", b[j]); j++; }
+      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);
 
     // Portal target for the hero fallback surface. The host whitelists
     // react-dom for its own bundles (dsh-client-ui-trajectory requires it);
@@ -327,6 +381,9 @@ window.__ModuleLoader__.load({
         "memory.features.autoInject.hint": "每轮对话自动携带相关记忆",
         "memory.features.injectGuidanceEnabled": "能力说明",
         "memory.features.injectGuidanceEnabled.hint": "在工具描述与一次性提示段里说明怎么用记忆（何时查、何时写、拿不准就不做）",
+        "memory.features.continuityRescueEnabled": "压缩边缘抢救",
+        "memory.features.continuityRescueEnabled.hint": "上下文即将被精简前，落一条连续性快照（正在做什么 / 下一步 / 未决问题）并追加到对话末尾，让它活过这次压缩",
+        "memory.features.parentOff": "父开关关闭时不生效",
         "memory.features.autoSummarize": "自动总结",
         "memory.features.autoSummarize.hint": "对话结束自动提炼记忆条目",
         "memory.features.hotMemoryEnabled": "热记忆",
@@ -340,6 +397,13 @@ window.__ModuleLoader__.load({
         "memory.features.entityExtractionReasoning.low": "低",
         "memory.features.entityExtractionReasoning.medium": "中",
         "memory.features.entityExtractionReasoning.high": "高",
+        "memory.features.summarizeReasoningEffort": "蒸馏思考强度",
+        "memory.features.summarizeReasoningEffort.off": "关闭思考",
+        "memory.features.summarizeReasoningEffort.none": "跟随默认",
+        "memory.features.summarizeReasoningEffort.low": "低",
+        "memory.features.summarizeReasoningEffort.medium": "中",
+        "memory.features.summarizeReasoningEffort.high": "高",
+        "memory.features.summarizeReasoningEffort.hint": "思考型模型建议选低档或关闭思考，避免推理烧光输出预算导致总结失败；改后重启 DSH 生效",
         "memory.features.entityExtractionModelHint": "Provider/模型留空 = 跟随主对话模型；思考强度 none = 服务商默认",
         "memory.features.codingRetrospect": "编码记忆蒸馏",
         "memory.features.codingRetrospect.hint": "用完整转录（含工具调用与报错）提炼踩坑、约束与被否决方案",
@@ -401,6 +465,10 @@ window.__ModuleLoader__.load({
         "memory.features.dreamProvider": "巩固模型 Provider",
         "memory.features.dreamModel": "巩固用模型名",
         "memory.features.dreamModelHint": "留空 = 跟随主对话模型；只影响记忆巩固（autoDream）用的模型",
+        "memory.features.dreamPeakHours": "高峰时段（不做梦）",
+        "memory.features.dreamPeakHours.hint": "空 = 关闭。逗号分隔、可带星期前缀、支持跨零点，如 09:00-18:00 或 mon-fri 08:00-12:00,14:00-18:00。命中时段不调模型，顺延到最近的高峰结束时刻补跑（最多顺延 dreamPeakMaxDeferMinutes 分钟，避免长高峰把巩固饿死）",
+        "memory.features.summarizePeakHours": "高峰时段（不蒸馏）",
+        "memory.features.summarizePeakHours.hint": "空 = 关闭。与上方巩固侧同一份时段语法；命中时蒸馏顺延到非高峰、窗口累积后一次蒸",
         "memory.features.sleepProvider": "睡眠 Provider",
         "memory.features.sleepModel": "睡眠模型",
         "memory.features.sleepModelHint": "留空 = 用巩固模型或当前模型；建议选非思考模型",
@@ -491,6 +559,14 @@ window.__ModuleLoader__.load({
         "memory.status.conflictQueue.resolved": "已裁决：保留{name}",
         "memory.status.conflictQueue.refresh": "刷新队列",
         "memory.status.conflictQueue.refreshed": "冲突队列已刷新",
+        "memory.status.conflictQueue.frozenBadge": "⏸ 冻结中",
+        "memory.status.conflictQueue.frozenTitle": "冻结中：不参与注入与巩固，等你裁决",
+        "memory.status.conflictQueue.similarity": "相似度",
+        "memory.status.conflictQueue.diffTitle": "差异已高亮：红=删除、绿=新增",
+        "memory.status.conflictQueue.diffFallback": "两段文本差异较大，请对照原文阅读",
+        "memory.status.conflictQueue.emptyTitle": "暂无待确认冲突",
+        "memory.status.conflictQueue.emptyBody": "当巩固发现两条互相矛盾或高度相似的记忆时，会先冻结在这里等你裁决，不会自动修改。裁决前双方都不参与注入。",
+        "memory.status.conflictQueue.applyHintTitle": "确认后：保留方正文追加已否决注记，另一方归档",
         "memory.status.workbench": "工作动态",
         "memory.status.dreamConsolidate": "记忆巩固",
         "memory.status.summarize": "总结提炼",
@@ -508,6 +584,7 @@ window.__ModuleLoader__.load({
         "memory.status.recallStats": "记忆复用",
         "memory.status.recallHint": "复用率 {rate} · 僵尸 {zombie}/{active}（豁免 {exempt}）· 30 天回执 {runs} 次 · Top：{top}",
         "memory.status.recallInject": "注入 {runs} 轮 {count} 条，槽位填充 {fill}%",
+        "memory.status.recallArchive": "归档 {total} 行（{add}/天），精确重复可压掉 {compress} 行",
         "memory.status.viewAll": "查看全部",
         "memory.status.depositedCount": "沉淀的记忆（{n}）",
         "memory.status.archivedCount": "已归档的记忆（{n}）",
@@ -705,6 +782,9 @@ window.__ModuleLoader__.load({
         "memory.features.autoInject.hint": "Carry relevant memories into every turn",
         "memory.features.injectGuidanceEnabled": "Capability guide",
         "memory.features.injectGuidanceEnabled.hint": "Explain how to use memory (when to search, when to save, when to do nothing) in tool descriptions plus a one-time prompt section",
+        "memory.features.continuityRescueEnabled": "Compaction-edge rescue",
+        "memory.features.continuityRescueEnabled.hint": "Before context compaction, record a continuity snapshot (current work / next step / open questions) and append it near the end of the conversation so it survives the compaction",
+        "memory.features.parentOff": "Inactive while auto injection is off",
         "memory.features.autoSummarize": "Auto summarization",
         "memory.features.autoSummarize.hint": "Distill memory entries when a conversation ends",
         "memory.features.hotMemoryEnabled": "Hot memory",
@@ -718,6 +798,13 @@ window.__ModuleLoader__.load({
         "memory.features.entityExtractionReasoning.low": "Low",
         "memory.features.entityExtractionReasoning.medium": "Medium",
         "memory.features.entityExtractionReasoning.high": "High",
+        "memory.features.summarizeReasoningEffort": "Distill reasoning effort",
+        "memory.features.summarizeReasoningEffort.off": "No reasoning",
+        "memory.features.summarizeReasoningEffort.none": "Follow default",
+        "memory.features.summarizeReasoningEffort.low": "Low",
+        "memory.features.summarizeReasoningEffort.medium": "Medium",
+        "memory.features.summarizeReasoningEffort.high": "High",
+        "memory.features.summarizeReasoningEffort.hint": "Prefer low or No reasoning for thinking models so reasoning cannot drain the output budget; takes effect after a DSH restart",
         "memory.features.entityExtractionModelHint": "Provider / model empty = follow the main conversation model; reasoning none = provider default",
         "memory.features.codingRetrospect": "Coding retrospection",
         "memory.features.codingRetrospect.hint": "Distill pitfalls, constraints and rejected solutions from full transcripts (tools and errors included)",
@@ -779,6 +866,10 @@ window.__ModuleLoader__.load({
         "memory.features.dreamProvider": "Consolidation provider",
         "memory.features.dreamModel": "Consolidation model",
         "memory.features.dreamModelHint": "Leave empty to follow the main conversation model; only affects autoDream consolidation",
+        "memory.features.dreamPeakHours": "Peak hours (no dreaming)",
+        "memory.features.dreamPeakHours.hint": "Empty = off. Comma-separated windows, optional weekday prefix, midnight-crossing allowed — e.g. 09:00-18:00 or mon-fri 08:00-12:00,14:00-18:00. Inside these windows no LLM call is made; the run is deferred to the nearest peak-end (capped by dreamPeakMaxDeferMinutes so an all-day peak cannot starve consolidation)",
+        "memory.features.summarizePeakHours": "Peak hours (no distillation)",
+        "memory.features.summarizePeakHours.hint": "Empty = off. Same window syntax as the consolidation side above; inside a peak, distillation is deferred and the window accumulates for one bigger run",
         "memory.features.sleepProvider": "Sleep provider",
         "memory.features.sleepModel": "Sleep model",
         "memory.features.sleepModelHint": "Leave empty to reuse the consolidation model; a non-reasoning model is recommended",
@@ -869,6 +960,14 @@ window.__ModuleLoader__.load({
         "memory.status.conflictQueue.resolved": "Resolved: kept {name}",
         "memory.status.conflictQueue.refresh": "Refresh queue",
         "memory.status.conflictQueue.refreshed": "Conflict queue refreshed",
+        "memory.status.conflictQueue.frozenBadge": "⏸ Frozen",
+        "memory.status.conflictQueue.frozenTitle": "Frozen: excluded from injection and consolidation, awaiting your review",
+        "memory.status.conflictQueue.similarity": "similarity",
+        "memory.status.conflictQueue.diffTitle": "Differences highlighted: red = removed, green = added",
+        "memory.status.conflictQueue.diffFallback": "The two texts differ substantially — compare the originals",
+        "memory.status.conflictQueue.emptyTitle": "No pending conflicts",
+        "memory.status.conflictQueue.emptyBody": "When consolidation finds two contradictory or highly similar memories, it freezes them here for your review instead of changing anything automatically. Neither side participates in injection until resolved.",
+        "memory.status.conflictQueue.applyHintTitle": "On confirm: a veto note is appended to the kept side and the other side is archived",
         "memory.status.workbench": "Activity",
         "memory.status.dreamConsolidate": "Consolidation",
         "memory.status.summarize": "Summarization",
@@ -886,6 +985,7 @@ window.__ModuleLoader__.load({
         "memory.status.recallStats": "Recall reuse",
         "memory.status.recallHint": "reuse {rate} · zombie {zombie}/{active} (exempt {exempt}) · {runs} runs in 30d · top: {top}",
         "memory.status.recallInject": "injected {runs} turns · {count} items ({fill}% slots)",
+        "memory.status.recallArchive": "archived {total} rows (+{add}/day) · {compress} exactly-duplicate rows compressible",
         "memory.status.viewAll": "View all",
         "memory.status.depositedCount": "Deposited memories ({n})",
         "memory.status.archivedCount": "Archived memories ({n})",
@@ -1148,7 +1248,7 @@ window.__ModuleLoader__.load({
       ".mneme-heat--cold{color:var(--dsw-alias-label-tertiary)}",
       ".mneme-heat--cold .mneme-heatpct{display:none}",
       // 纵向 flex 容器按原生按钮的宽度与外边距分配空间，保留展开和收起态的对齐。
-      ".mneme-topentry{display:flex;flex-direction:column}",
+      ".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:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
       ".mneme-topentry-native .mneme-topentry-label{white-space:nowrap}",
@@ -1213,6 +1313,31 @@ window.__ModuleLoader__.load({
       ".mneme-conflict-missing{font-size:12px;color:var(--dsw-alias-label-tertiary)}",
       ".mneme-conflict-actions{display:flex;align-items:center;gap:6px;flex-wrap:wrap}",
       ".mneme-conflict-hint{font-size:11px;color:var(--dsw-alias-label-tertiary);margin-right:auto}",
+      // #177 冲突队列视觉批次：A/B 侧色、相似度条、词级 diff、主色按钮、空态
+      ".mneme-conflict-side--a{border-color:color-mix(in srgb,var(--dsw-alias-state-business-primary) 35%,transparent);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 4%,transparent)}",
+      ".mneme-conflict-side--a .mneme-conflict-sidelabel{color:var(--dsw-alias-state-business-primary);font-weight:600}",
+      ".mneme-conflict-side--b{border-color:color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 45%,transparent);background:color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 5%,transparent)}",
+      ".mneme-conflict-side--b .mneme-conflict-sidelabel{color:var(--dsw-alias-state-warning,#e6a23c);font-weight:600}",
+      ".mneme-conflict-simrow{display:flex;align-items:center;gap:8px;font-size:11px;color:var(--dsw-alias-label-secondary)}",
+      ".mneme-conflict-simbar{position:relative;flex:1;height:5px;border-radius:3px;background:var(--dsw-alias-interactive-bg-hover);overflow:hidden}",
+      ".mneme-conflict-simfill{position:absolute;top:0;bottom:0;left:0;border-radius:3px;background:var(--dsw-alias-state-business-primary)}",
+      ".mneme-conflict-diff{font-size:12px;line-height:18px;color:var(--dsw-alias-label-primary);display:-webkit-box;-webkit-line-clamp:4;-webkit-box-orient:vertical;overflow:hidden}",
+      ".mneme-conflict-mark{text-decoration:none;border-radius:3px;padding:0 1px}",
+      ".mneme-conflict-mark--del{background:color-mix(in srgb,var(--dsw-alias-state-error,#c33) 16%,transparent);text-decoration:line-through}",
+      ".mneme-conflict-mark--ins{background:color-mix(in srgb,var(--dsw-alias-state-success,#3c9) 18%,transparent)}",
+      ".mneme-conflict-primary{display:inline-flex;align-items:center;gap:4px;height:24px;padding:0 10px;border-radius:8px;border:none;background:var(--dsw-alias-state-business-primary);color:var(--dsw-alias-bg-layer-1);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px}",
+      ".mneme-conflict-primary:disabled{opacity:.55;cursor:default}",
+      ".mneme-conflict-primary:hover:not(:disabled){background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 85%,black)}",
+      ".mneme-badge--frozen{color:var(--dsw-alias-state-warning,#e6a23c);background:color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 12%,transparent)}",
+      ".mneme-conflict-empty{border:1px dashed var(--dsw-alias-border-l2);border-radius:10px;padding:12px 14px;display:flex;flex-direction:column;gap:4px}",
+      ".mneme-conflict-empty-title{font-size:12.5px;font-weight:600;color:var(--dsw-alias-label-secondary)}",
+      ".mneme-conflict-empty-body{font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary)}",
+      ".mneme-statuscard--actionable{border-color:color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 55%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 35%,transparent)}",
+      ".mneme-entrybadge{position:absolute;top:-3px;right:-3px;min-width:16px;height:16px;padding:0 4px;border-radius:8px;background:var(--dsw-alias-state-error,#c33);color:var(--dsw-alias-bg-layer-1,#fff);font-size:10.5px;line-height:16px;font-weight:600;text-align:center;box-shadow:0 0 0 2px var(--dsw-alias-bg-layer-1)}",
+      ".mneme-triggerwrap{position:relative;pointer-events:none}",
+      ".mneme-triggerwrap .mneme-trigger{pointer-events:auto}",
+      ".mneme-conflict-jump .mneme-statuscard{border-color:color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 55%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--dsw-alias-state-warning,#e6a23c) 35%,transparent)}",
+      ".mneme-conflict-jump:focus-visible{outline:2px solid var(--dsw-alias-state-business-primary);outline-offset:2px;border-radius:12px}",
       // 详情抽屉：sheet 内右侧滑出，覆盖在浏览区之上
       ".mneme-xmain{position:relative}",
       "@keyframes mneme-slidein{from{opacity:0;transform:translateX(16px)}to{opacity:1;transform:translateX(0)}}",
@@ -1827,8 +1952,14 @@ window.__ModuleLoader__.load({
     // 分组排版：核心/增强/巩固常驻，注入策略等收进「高级」折叠，普通用户
     // 不被专业项淹没。429 调速器参数、distillMaxChars、codingBoostFactor
     // 属调优噪音，按对齐结论留在配置文件，不上 UI。
+    // #249 第二批：注入形态的父／子开关（父 = autoInject）。子项紧跟父行、缩进
+    // 显示；父关时子项加一句「不生效」，但开关仍可点——父关是「不生效」而不是
+    // 「重置用户配置」，子项自己勾着的值要留着，也应该能提前设好。同一份关系在
+    // 后端 src/config.js 的 INJECT_CHILD_FLAGS（运行时闸门），两侧漂移由
+    // test/inject-parent-gate.test.js 钉住。
+    const FEATURE_CHILDREN = { autoInject: ["injectGuidanceEnabled", "continuityRescueEnabled"] };
     const FEATURE_GROUPS = [
-      { key: "group.core", items: ["autoInject", "injectGuidanceEnabled", "autoSummarize", "hotMemoryEnabled", "memoryQualityFilter.enabled", "llmAudit.enabled"] },
+      { key: "group.core", items: ["autoInject", "autoSummarize", "hotMemoryEnabled", "memoryQualityFilter.enabled", "llmAudit.enabled"] },
       { key: "group.enhance", items: ["entityExtractionEnabled", "codingRetrospect", "rerankEnabled", "resilientModelDownload", "searchSemanticDedup", "bm25SearchEnabled", "heatEnabled", "documentMemoryEnabled"] },
       { key: "group.dream", items: ["autoDream", "sleepModeEnabled"] },
       // v0.8.0 A4（issue #17）：作用域隔离组——标注总开关 + 严格硬过滤。
@@ -1837,13 +1968,19 @@ window.__ModuleLoader__.load({
     const FEATURE_ADVANCED_BOOLS = ["hybridInject", "selectiveInjectEnabled", "adaptiveThresholdEnabled", "reflectionUpdateEnabled", "reflectionFailureTracking", "conflictFreezeEnabled", "trustEpistemicWeighting"];
     // 字符串键（blur/Enter 提交，空串合法 = 跟随默认）：巩固模型与语义
     // 检索路线。embedProvider 是枚举，用下拉单独渲染。
-    const FEATURE_STRINGS = ["dreamProvider", "dreamModel", "sleepProvider", "sleepModel", "entityExtractionProvider", "entityExtractionModel", "localEmbedModel", "ollamaBaseUrl", "ollamaModel"];
+    const FEATURE_STRINGS = ["dreamProvider", "dreamModel", "sleepProvider", "sleepModel", "entityExtractionProvider", "entityExtractionModel", "localEmbedModel", "ollamaBaseUrl", "ollamaModel",
+      // Issue #239 第 4 项：错峰时段串（巩固侧与蒸馏侧）。此前只有后端白名单、
+      // 面板调不到——两个错峰键一个能调一个不能比都不给更让人困惑。
+      "dreamPeakHours", "summarizePeakHours"];
     const EMBED_PROVIDERS = ["openai", "local", "ollama"];
     // 实体抽取思考强度（issue #109）：与后端 FEATURE_FLAG_ENUMS 枚举对齐。
     const ENTITY_REASONING = ["none", "low", "medium", "high"];
+    // 蒸馏思考强度（issue #315）：比 entity 多一个 off（显式关思考，思考型模型
+    // 蒸馏防推理烧预算）。后端枚举含 off，面板必须能选到，否则操作者用不上。
+    const SUMMARIZE_REASONING = ["off", "none", "low", "medium", "high"];
 
-    function FeatureRow({ name, hint, on, disabled, onToggle }) {
-      return h("div", { className: "mneme-featrow" },
+    function FeatureRow({ name, hint, on, disabled, onToggle, sub }) {
+      return h("div", { className: "mneme-featrow", style: sub ? { paddingLeft: 18, opacity: 0.86 } : undefined },
         h("div", { className: "mneme-featmain" },
           h("div", { className: "mneme-featname" }, name),
           h("div", { className: "mneme-feathint" }, hint)
@@ -1934,15 +2071,24 @@ window.__ModuleLoader__.load({
         put({ [key]: raw });
       };
 
-      const boolRow = (k) => h(FeatureRow, {
+      const boolRow = (k, opts = {}) => h(FeatureRow, {
         key: k,
         name: t(`memory.features.${k}`),
-        hint: t(`memory.features.${k}.hint`),
+        hint: t(`memory.features.${k}.hint`)
+          + (opts.gate && !eff[opts.gate] ? ` · ${t("memory.features.parentOff")}` : ""),
         on: !!eff[k],
         disabled: busy,
+        sub: !!opts.sub,
         onToggle: () => put({ [k]: !eff[k] })
       });
 
+      // 带子项的父开关：父行 + 紧随其后的子行（子行缩进，父关时标注不生效）。
+      const flagRow = (k) => {
+        const kids = FEATURE_CHILDREN[k];
+        if (!kids) return boolRow(k);
+        return h(react.Fragment, { key: k }, boolRow(k), kids.map((c) => boolRow(c, { sub: true, gate: k })));
+      };
+
       // 模型枚举项的统一形状：string 或 {id, name?}（/llm-providers 契约）。
       const modelLabel = (m) => (typeof m === "string" ? m : String((m && (m.name || m.id)) ?? ""));
       const modelValue = (m) => (typeof m === "string" ? m : String((m && m.id) ?? ""));
@@ -2087,7 +2233,11 @@ window.__ModuleLoader__.load({
         Array.isArray(routes)
           ? routeSelects("dreamProvider", "dreamModel", dreamTest, setDreamTest, "dreamReasoningEffort")
           : h(react.Fragment, null, strRow("dreamProvider"), strRow("dreamModel")),
-        h("div", { className: "mneme-featsubhint" }, t("memory.features.dreamModelHint"))
+        h("div", { className: "mneme-featsubhint" }, t("memory.features.dreamModelHint")),
+        // Issue #239 第 4 项镜像到巩固：高峰时段串（空 = 关闭）。放在 autoDream
+        // 子块内——它是巩固的排程，开关关掉时不该还在界面上留着可编辑的输入框。
+        strRow("dreamPeakHours"),
+        h("div", { className: "mneme-featsubhint" }, t("memory.features.dreamPeakHours.hint"))
       );
 
       // 睡眠模型：sleepModeEnabled 开着才展开（sleepProvider/sleepModel 随本版
@@ -2117,6 +2267,27 @@ window.__ModuleLoader__.load({
         h("div", { className: "mneme-featsubhint" }, t("memory.features.entityExtractionModelHint"))
       );
 
+      // 蒸馏思考强度（issue #315）：autoSummarize 开着才展开，档位与实体抽取
+      // 同款枚举下拉、即时提交。蒸馏没有独立 provider/model 路由键（跟随会话
+      // 头或 config 文件的 summarizeProvider/summarizeModel），不上连通性测试。
+      const summarizeSub = eff.autoSummarize && h("div", { className: "mneme-featsub" },
+        h("div", { className: "mneme-featnum" },
+          h("span", { className: "mneme-featnumlabel" }, t("memory.features.summarizeReasoningEffort")),
+          h("select", {
+            className: "mneme-select",
+            value: eff.summarizeReasoningEffort || "none",
+            disabled: busy,
+            onChange: (e) => put({ summarizeReasoningEffort: e.target.value })
+          },
+            SUMMARIZE_REASONING.map((r) => h("option", { key: r, value: r }, t(`memory.features.summarizeReasoningEffort.${r}`))))
+        ),
+        h("div", { className: "mneme-featsubhint" }, t("memory.features.summarizeReasoningEffort.hint")),
+        // Issue #239 第 4 项：蒸馏侧错峰时段串（空 = 关闭）。与思考强度同处一个
+        // autoSummarize 子块——两处错峰开关都能在面板上调（巩固侧见 dreamSub）。
+        strRow("summarizePeakHours"),
+        h("div", { className: "mneme-featsubhint" }, t("memory.features.summarizePeakHours.hint"))
+      );
+
       if (error && !state) return h("section", { className: "mneme-set-card" },
         h("div", { className: "mneme-set-title" }, t("memory.features.title")),
         h("div", { className: "mneme-set-hint" }, error));
@@ -2133,7 +2304,8 @@ window.__ModuleLoader__.load({
           : h(react.Fragment, null,
               FEATURE_GROUPS.map((g) => h(react.Fragment, { key: g.key },
                 h("div", { className: "mneme-featgroup" }, t(`memory.features.${g.key}`)),
-                g.items.map(boolRow),
+                g.items.map(flagRow),
+                g.key === "group.core" && h(react.Fragment, null, summarizeSub),
                 g.key === "group.enhance" && h(react.Fragment, null, embedSub, entitySub),
                 g.key === "group.dream" && h(react.Fragment, null, dreamSub, sleepSub)
               )),
@@ -2147,7 +2319,7 @@ window.__ModuleLoader__.load({
                   h(Icon, { name: showAdv ? "chevronDown" : "chevronRight", size: 12 }),
                   t("memory.features.advancedToggle"))
               ),
-              showAdv && FEATURE_ADVANCED_BOOLS.map(boolRow)
+              showAdv && FEATURE_ADVANCED_BOOLS.map((k) => boolRow(k))
             )
       );
     }
@@ -2257,7 +2429,7 @@ window.__ModuleLoader__.load({
       // 版本/平台方便归档，正文同款模板；纯链接零后端成本。
       const feedbackEnv = `**插件版本**: ${pkgVersion}\n**平台**: ${platformLabel()}\n`;
       const feedbackBody = feedbackEnv + "**问题描述**:\n- 期望行为:\n- 实际行为:\n- 复现步骤:\n";
-      const issueHref = "https://github.com/slow-stack/dsh-mneme/issues/new?title="
+      const issueHref = "https://github.com/slow-stack/mneme/issues/new?title="
         + encodeURIComponent("[dsh-mneme] 问题反馈")
         + "&body=" + encodeURIComponent(feedbackBody);
       const mailHref = "mailto:work@modusensus.space?subject="
@@ -2690,7 +2862,7 @@ window.__ModuleLoader__.load({
           h("div", { style: { display: "flex", flexDirection: "column", gap: 2 } },
             h("a", { className: "mneme-feed-link", href: issueHref, target: "_blank", rel: "noopener noreferrer" }, t("memory.settings.feedback.newIssue")),
             h("a", { className: "mneme-feed-link", href: mailHref }, t("memory.settings.feedback.email")),
-            h("a", { className: "mneme-feed-link", href: "https://github.com/slow-stack/dsh-mneme/issues", target: "_blank", rel: "noopener noreferrer" }, t("memory.settings.feedback.browse"))
+            h("a", { className: "mneme-feed-link", href: "https://github.com/slow-stack/mneme/issues", target: "_blank", rel: "noopener noreferrer" }, t("memory.settings.feedback.browse"))
           ),
           h("div", { className: "mneme-featsubhint", style: { marginTop: 8 } }, t("memory.settings.feedback.hint"))
         )
@@ -2772,7 +2944,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" },
-              h(IconArchiveOutline20, { size: 15 }),
+              renderArchiveIcon({ size: 15 }),
               t("memory.view.label")
             ),
             h("button", {
@@ -3084,19 +3256,25 @@ window.__ModuleLoader__.load({
       const [state, setState] = useState({ loading: true, error: false, lastRun: null, pending: 0 });
       useEffect(() => {
         let cancelled = false;
-        apiFetch("/api/dsh-mneme/dream-status")
-          .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
-          .then((d) => {
-            if (cancelled) return;
-            setState({
-              loading: false,
-              error: false,
-              lastRun: (d && d.lastRun) || null,
-              pending: Number((d && d.pendingConflicts) ?? 0)
-            });
-          })
-          .catch(() => { if (!cancelled) setState({ loading: false, error: true, lastRun: null, pending: 0 }); });
-        return () => { cancelled = true; };
+        const loadOnce = () => {
+          apiFetch("/api/dsh-mneme/dream-status")
+            .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
+            .then((d) => {
+              if (cancelled) return;
+              setState({
+                loading: false,
+                error: false,
+                lastRun: (d && d.lastRun) || null,
+                pending: Number((d && d.pendingConflicts) ?? 0)
+              });
+            })
+            .catch(() => { if (!cancelled) setState({ loading: false, error: true, lastRun: null, pending: 0 }); });
+        };
+        loadOnce();
+        // #295 评审：裁决完成后队列会广播 mneme:conflicts-changed，这里重取
+        // 计数，状态卡的「待确认冲突」不再停留旧值。
+        window.addEventListener("mneme:conflicts-changed", loadOnce);
+        return () => { cancelled = true; window.removeEventListener("mneme:conflicts-changed", loadOnce); };
       }, []);
       const run = state.lastRun;
       const num = run ? formatRelativeTime(run.created_at, t) : t("memory.status.dreamNever");
@@ -3113,6 +3291,7 @@ window.__ModuleLoader__.load({
           role: pending ? "button" : undefined,
           tabIndex: pending ? 0 : undefined,
           "aria-label": pending ? t("memory.status.conflictQueue.goto") : undefined,
+          className: pending ? "mneme-conflict-jump" : undefined,
           style: pending ? { cursor: "pointer" } : undefined,
           onClick: pending ? gotoQueue : undefined,
           onKeyDown: pending ? (e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); gotoQueue(); } } : undefined
@@ -3205,15 +3384,19 @@ window.__ModuleLoader__.load({
     // 队列为空时整块不渲染（不打扰无冲突实例）。
     function ConflictsQueue({ t }) {
       const [items, setItems] = useState(null);
+      const [loadError, setLoadError] = useState(false);
       const [busy, setBusy] = useState(false);
-      const load = () => {
+      const load = (silent) => {
         apiFetch("/api/dsh-mneme/conflicts")
           .then((res) => { if (!res.ok) throw new Error("http"); return res.json(); })
-          .then((d) => { setItems(d.items || []); announce(t("memory.status.conflictQueue.refreshed")); })
-          .catch(() => setItems([]));
+          .then((d) => { setItems(d.items || []); setLoadError(false); if (!silent) announce(t("memory.status.conflictQueue.refreshed")); })
+          // #295 评审：加载失败 ≠ 没有冲突——错误态渲染错误卡而不是空态教育卡，
+          // 不能让 500 把「暂时看不到」伪装成「没有冲突」。
+          .catch(() => { setItems([]); setLoadError(true); });
       };
       useEffect(() => { load(); }, []);
-      if (!items || items.length === 0) return null;
+      // #177：空队列不再整块消失——空态教育卡要渲染（原 return null 已移除）。
+      if (!items) return null;
       const resolve = (id, winner) => {
         if (busy) return;
         setBusy(true);
@@ -3228,37 +3411,93 @@ window.__ModuleLoader__.load({
           .then(() => {
             announce(t("memory.status.conflictQueue.resolved").replace("{name}",
               (winner === "a" ? (it.memory_a && it.memory_a.title) : winner === "b" ? (it.memory_b && it.memory_b.title) : "") || ""));
-            load();
+            // #295 评审：裁决改变了 pending 总数——DreamStatusCards 只在挂载时
+            // 读一次 dream-status，不广播的话状态卡停留在旧计数。同页两个组件
+            // 用一个 window 事件对齐（比提升状态到 StatusPanel 少动三处）。
+            try { window.dispatchEvent(new CustomEvent("mneme:conflicts-changed")); } catch { /* 非浏览器环境 */ }
+            load(true);
           })
           .catch(() => {})
           .finally(() => setBusy(false));
       };
-      const side = (s, label) => h("div", { className: "mneme-conflict-side" },
+      const side = (s, label, sideClass, ops, diffSide) => h("div", { className: `mneme-conflict-side ${sideClass}` },
         h("div", { className: "mneme-conflict-sidelabel" }, label),
         s.missing
           ? h("div", { className: "mneme-conflict-missing" }, t("memory.status.conflictQueue.missing"))
           : h(react.Fragment, null,
               h("div", { className: "mneme-conflict-sidetitle", title: s.title }, s.title || "…"),
-              h("div", { className: "mneme-conflict-snippet" }, (s.content || "").slice(0, 140)),
-              s.archived && h("span", { className: "mneme-badge mneme-badge--archived" }, t("memory.explorer.archivedBadge")))
+              // #177：词级 diff 可用（LCS 无损对齐成功）时用高亮视图替代纯文本。
+              // 侧别过滤（#295 评审修正）：A 侧渲染 same+del（它被删的部分高亮），
+              // B 侧渲染 same+ins（它新增的部分高亮）——每列忠实于自己的原文。
+              // title 提示颜色语义；diff 不可用时保留原 snippet。
+              ops
+                ? h("div", { className: "mneme-conflict-diff", title: t("memory.status.conflictQueue.diffTitle") },
+                    ops.map((o, k) => {
+                      if (o.kind === "same") return o.text;
+                      if (o.kind === "del" && diffSide === "a") {
+                        return h("span", { key: k, className: "mneme-conflict-mark mneme-conflict-mark--del" }, o.text);
+                      }
+                      if (o.kind === "ins" && diffSide === "b") {
+                        return h("span", { key: k, className: "mneme-conflict-mark mneme-conflict-mark--ins" }, o.text);
+                      }
+                      return null; // 对侧的编辑片段不出现在本列
+                    }))
+                : h("div", { className: "mneme-conflict-snippet" }, (s.content || "").slice(0, 140)),
+              // #177：预裁决阶段两侧都还活着——「已归档」徽章换成「冻结中」，
+              // 原注销记说明（applyHint）挪进 tooltip，不再整段占一行动态区。
+              h("span", {
+                className: "mneme-badge mneme-badge--frozen",
+                title: `${t("memory.status.conflictQueue.frozenTitle")} ${t("memory.status.conflictQueue.applyHintTitle")}`
+              }, t("memory.status.conflictQueue.frozenBadge")))
       );
+      // #177：相似度从 reason 文本中回收（sleep 路径写「相似度 0.87」，dream 路径
+      // 是 LLM 自由文本）——回收得到就画进度条，否则不画，绝不显示编造的数字。
+      // 防误报：只认「相似度 0.87 / similarity 0.87」这类锚定短语，不在全文里
+      // 捞数字（否则 reason 里的年份、条数都会被当成相似度）。
+      const similarityOf = (reason) => {
+        const m = /(?:相似度|similarity)\s*([01](?:\.\d+)?)/i.exec(String(reason || ""));
+        const v = m ? Number(m[1]) : NaN;
+        return v >= 0 && v <= 1 ? v : null;
+      };
       return h("div", { className: "mneme-conflictq" },
         h("div", { className: "mneme-conflictq-head" },
           h("span", { className: "mneme-xcount" }, t("memory.status.conflicts")),
           h("button", { className: "mneme-footbtn", onClick: () => load() },
             h(Icon, { name: "refresh", size: 12 }), t("memory.status.conflictQueue.refresh"))),
-        items.map((it) => h("div", { key: it.id, className: "mneme-conflict-item" },
+        // #177 空态教育卡：队列没有条目时也渲染（整块此前直接 return null），
+        // 解释「什么情况会产生冲突、冻结是什么」——新用户第一次遇见冻结时
+        // 状态页已有解释在等他。加载失败时显示错误卡而不是空态卡。
+        items.length === 0 && (loadError
+          ? h("div", { className: "mneme-conflict-empty", role: "alert" },
+              h("div", { className: "mneme-conflict-empty-title" }, t("memory.status.error")))
+          : h("div", { className: "mneme-conflict-empty" },
+              h("div", { className: "mneme-conflict-empty-title" }, t("memory.status.conflictQueue.emptyTitle")),
+              h("div", { className: "mneme-conflict-empty-body" }, t("memory.status.conflictQueue.emptyBody")))),
+        items.map((it) => {
+          const sim = similarityOf(it.reason);
+          const aText = (it.memory_a && it.memory_a.content) || "";
+          const bText = (it.memory_b && it.memory_b.content) || "";
+          // diff 与相似度条互补：reason 给不出数字时才跑 LCS（两者表达同一信息）。
+          const diff = (sim === null && !it.memory_a.missing && !it.memory_b.missing)
+            ? wordDiff(aText, bText) : null;
+          return h("div", { key: it.id, className: "mneme-conflict-item" },
           it.reason && h("div", { className: "mneme-conflict-reason" },
             `${t("memory.status.conflictQueue.reason")}: ${it.reason}`),
+          sim !== null && h("div", { className: "mneme-conflict-simrow" },
+            h("span", null, t("memory.status.conflictQueue.similarity")),
+            h("span", { className: "mneme-conflict-simbar" },
+              h("span", { className: "mneme-conflict-simfill", style: { width: `${Math.round(sim * 100)}%` } })),
+            h("span", null, `${Math.round(sim * 100)}%`)),
           h("div", { className: "mneme-conflict-pair" },
-            side(it.memory_a, t("memory.status.conflictQueue.sideA")),
-            side(it.memory_b, t("memory.status.conflictQueue.sideB"))),
+            side(it.memory_a, t("memory.status.conflictQueue.sideA"), "mneme-conflict-side--a", diff, "a"),
+            side(it.memory_b, t("memory.status.conflictQueue.sideB"), "mneme-conflict-side--b", diff, "b")),
           h("div", { className: "mneme-conflict-actions" },
-            h("span", { className: "mneme-conflict-hint" }, t("memory.status.conflictQueue.applyHint")),
-            h("button", { className: "mneme-footbtn", disabled: busy, "aria-label": `${t("memory.status.conflictQueue.keepA")}: ${(it.memory_a && it.memory_a.title) || ""}`, onClick: () => resolve(it.id, "a") }, t("memory.status.conflictQueue.keepA")),
-            h("button", { className: "mneme-footbtn", disabled: busy, "aria-label": `${t("memory.status.conflictQueue.keepB")}: ${(it.memory_b && it.memory_b.title) || ""}`, onClick: () => resolve(it.id, "b") }, t("memory.status.conflictQueue.keepB")),
-            h("button", { className: "mneme-footbtn", disabled: busy, onClick: () => resolve(it.id, null) }, t("memory.status.conflictQueue.markReviewed"))))
-        ));
+            h("span", { className: "mneme-conflict-hint", title: t("memory.status.conflictQueue.applyHintTitle") },
+              t("memory.status.conflictQueue.applyHint")),
+            h("button", { className: "mneme-conflict-primary", disabled: busy, "aria-label": `${t("memory.status.conflictQueue.keepA")}: ${(it.memory_a && it.memory_a.title) || ""}`, onClick: () => resolve(it.id, "a") }, t("memory.status.conflictQueue.keepA")),
+            h("button", { className: "mneme-conflict-primary", disabled: busy, "aria-label": `${t("memory.status.conflictQueue.keepB")}: ${(it.memory_b && it.memory_b.title) || ""}`, onClick: () => resolve(it.id, "b") }, t("memory.status.conflictQueue.keepB")),
+            h("button", { className: "mneme-footbtn", disabled: busy, onClick: () => resolve(it.id, null) }, t("memory.status.conflictQueue.markReviewed"))));
+        }));
     }
 
     // --- 状态页工作台：让用户切实看见插件在干活 ---
@@ -3446,7 +3685,7 @@ window.__ModuleLoader__.load({
     // 口径不可信）或库为空时整卡不渲染，前端不感知；truncated（扫描超上限）
     // 只影响 hint 里的回执计数，不挡渲染。
     function RecallStatsCard({ t }) {
-      const [state, setState] = useState({ loading: true, off: false, rate: null, zombie: 0, active: 0, exempt: 0, runs: 0, top: "", inject: "" });
+      const [state, setState] = useState({ loading: true, off: false, rate: null, zombie: 0, active: 0, exempt: 0, runs: 0, top: "", inject: "", archive: "" });
       useEffect(() => {
         let cancelled = false;
         apiFetch("/api/dsh-mneme/recall-stats?window=30")
@@ -3454,7 +3693,11 @@ window.__ModuleLoader__.load({
           .then((d) => {
             if (cancelled) return;
             const z = d.zombie || {};
-            const hasData = (d.coverage?.runsScanned ?? 0) > 0 || (z.activeCount ?? 0) > 0;
+            // 归档侧第五指标（#275）不能只靠 run/active 两路撑整张卡：整库归档是它的正常
+            // 工作状态，那种库「窗口内没有召回回执、也没有活跃僵尸行」时若 hasData 为假，
+            // 组件直接走 off 分支 return null，归档指标永远没机会显示。
+            const hasData = (d.coverage?.runsScanned ?? 0) > 0 || (z.activeCount ?? 0) > 0
+              || (d.archive?.total ?? 0) > 0;
             if (!hasData) {
               setState({ loading: false, off: true });
               return;
@@ -3471,10 +3714,19 @@ window.__ModuleLoader__.load({
                 .replace("{count}", String(inj.injectedCount ?? 0))
                 .replace("{fill}", inj.slotFillRate == null ? "—" : String(Math.round(inj.slotFillRate * 100)))
               : "";
+            // 第五指标（#275）：归档净增速率 + 可压掉行数。与注入口径同款自门控
+            // ——归档区为空时整段省略，不往卡里塞一个恒 0 的数字。
+            const ar = d.archive || {};
+            const archive = (ar.total ?? 0) > 0
+              ? t("memory.status.recallArchive")
+                .replace("{total}", String(ar.total ?? 0))
+                .replace("{add}", String(ar.perDay ?? 0))
+                .replace("{compress}", String(ar.compressible?.rows ?? 0))
+              : "";
             setState({
               loading: false, off: false, rate,
               zombie: z.zombieCount ?? 0, active: z.activeCount ?? 0,
-              exempt: z.exemptCount ?? 0, runs: d.coverage?.runsScanned ?? 0, top, inject
+              exempt: z.exemptCount ?? 0, runs: d.coverage?.runsScanned ?? 0, top, inject, archive
             });
           })
           .catch(() => { if (!cancelled) setState({ loading: false, off: true }); });
@@ -3493,7 +3745,7 @@ window.__ModuleLoader__.load({
           .replace("{active}", String(state.active))
           .replace("{exempt}", String(state.exempt))
           .replace("{runs}", String(state.runs))
-          .replace("{top}", state.top || "—") + (state.inject ? " · " + state.inject : "")
+          .replace("{top}", state.top || "—") + (state.inject ? " · " + state.inject : "") + (state.archive ? " · " + state.archive : "")
       });
     }
 
@@ -4475,23 +4727,56 @@ window.__ModuleLoader__.load({
     // 我们的修饰类覆盖配色（次级观感）。这样展开态与收起态（rail）都直接
     // 继承宿主自己的盒模型与间距——宿主改版/缩进动画零位移，无需硬编码。
     // 宿主结构异常时约 2 秒后放弃 portal，footer 回退按钮保持可用。
+    // #177：未处理冲突数 badge——数据走 dream-status 的 pendingConflicts（状态卡
+    // 同一端点），60s 轮询 + 打开面板即刷新。挂侧边栏入口按钮右上角（portal 与
+    // 回退两处都挂），让用户不进面板也知道有冻结要裁决。
+    function useConflictBadgeCount(t) {
+      const [pending, setPending] = useState(0);
+      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); });
+        };
+        tick();
+        const timer = setInterval(tick, 60_000);
+        return () => { cancelled = true; clearInterval(timer); };
+      }, []);
+      return pending;
+    }
+    function ConflictBadge({ pending }) {
+      if (!pending || pending <= 0) return null;
+      return h("span", { className: "mneme-entrybadge", "aria-hidden": "true" },
+        pending > 99 ? "99+" : String(pending));
+    }
     function SidebarFallbackTrigger({ wide, t }) {
-      return h("button", {
-        type: "button",
-        className: wide ? "mneme-trigger" : "mneme-trigger mneme-rail",
-        "aria-label": t("memory.sidebar.aria"),
-        title: t("memory.panel.open"),
-        onClick: openLibrary,
-        "data-mneme-overlay-opener": "true"
-      },
-        h(IconArchiveOutline20, { size: wide ? 16 : 18 }),
-        wide && h("span", { className: "mneme-trigger-label" }, t("memory.panel.open"))
+      const pending = useConflictBadgeCount(t);
+      // #295 评审：.mneme-trigger 自身 overflow:hidden 且无定位上下文，badge
+      // 直接放里面会被裁剪——包一层定位容器，badge 挂在容器上。
+      return h("div", { className: "mneme-triggerwrap" },
+        h("button", {
+          type: "button",
+          className: wide ? "mneme-trigger" : "mneme-trigger mneme-rail",
+          "aria-label": pending > 0
+            ? `${t("memory.sidebar.aria")} · ${t("memory.status.conflicts")} ${pending}`
+            : t("memory.sidebar.aria"),
+          title: t("memory.panel.open"),
+          onClick: openLibrary,
+          "data-mneme-overlay-opener": "true"
+        },
+          renderArchiveIcon({ size: wide ? 16 : 18 }),
+          wide && h("span", { className: "mneme-trigger-label" }, t("memory.panel.open"))
+        ),
+        h(ConflictBadge, { pending })
       );
     }
 
     function SidebarTopEntry({ wide, t, fallback }) {
       const [host, setHost] = useState(null);
       const [nativeCls, setNativeCls] = useState("");
+      const pending = useConflictBadgeCount(t);
       useEffect(() => {
         if (!reactDom || typeof document === "undefined") return undefined;
         let tries = 0, timer = null, created = null, mo = null;
@@ -4567,13 +4852,16 @@ window.__ModuleLoader__.load({
           h("button", {
             type: "button",
             className: `${nativeCls} mneme-topentry-native`.trim(),
-            "aria-label": t("memory.sidebar.aria"),
+            "aria-label": pending > 0
+              ? `${t("memory.sidebar.aria")} · ${t("memory.status.conflicts")} ${pending}`
+              : t("memory.sidebar.aria"),
             title: t("memory.panel.open"),
             onClick: openLibrary,
             "data-mneme-overlay-opener": "true"
           },
-            h(IconArchiveOutline20, { size: wide ? 15 : 18 }),
-            wide && h("span", { className: "mneme-topentry-label" }, t("memory.panel.open"))
+            renderArchiveIcon({ size: wide ? 15 : 18 }),
+            wide && h("span", { className: "mneme-topentry-label" }, t("memory.panel.open")),
+            h(ConflictBadge, { pending })
           )
         ), host);
     }
@@ -4633,7 +4921,7 @@ window.__ModuleLoader__.load({
                   reg.registerTab({
                     id: TAB_ID,
                     title: () => t("memory.view.label"),
-                    icon: (size) => h(IconArchiveOutline20, { size }),
+                    icon: (size) => renderArchiveIcon({ size }),
                     order: 60,
                     component: () => h(MemoryExplorer, { t })
                   });