dsh-memu-memory 1.2.0 → 1.2.2

package/lib/client.js

@@ -8,7 +8,7 @@ window.__ModuleLoader__.load({
     const exports = module.exports
 
     const NS = 'dsh-memu-memory'
-    const SETTINGS_PAGES = ['engine', 'connection', 'settings', 'folders', 'libraries', 'browser', 'global', 'prompts', 'stats', 'memories', 'logs']
+    const SETTINGS_PAGES = ['engine', 'connection', 'settings', 'folders', 'libraries', 'browser', 'global', 'prompts', 'stats', 'memories', 'logs', 'lexicon', 'help']
     const EMPTY_SESSIONS = Object.freeze({ byId: Object.freeze({}), ids: Object.freeze([]) })
     const TAB_ID = `${NS}:memory`
     const TAB_KIND = 'dsh-memu-memory'
@@ -135,12 +135,43 @@ window.__ModuleLoader__.load({
       logClear: '清空日志',
       runLogTitle: '整理记录',
       runLogEmpty: '还没有整理记录。',
+      runLogOpen: '全部日志',
+      dedupedNotice: '未写入：库里已有几乎相同的记忆 [{id}]。要补充内容请在原条目上编辑合并；确属两次独立观测时才需要 allow_duplicate 重写。',
+      consolidateFeedTitle: '整理提醒',
+      consolidateFailedCol: '失败',
+      consolidateOkCol: '成功',
+      consolidateFailed: '失败',
+      consolidateDone: '完成',
+      consolidateFailedCount: '失败 {n}',
+      consolidateJumpHint: '在记忆工作室中打开这条记忆所在的库',
+      consolidateExpand: '展开',
+      consolidateCollapse: '收起',
+      consolidateClear: '清除失败记录',
+      consolidateClearHint: '只删除失败的整理日志；成功记录与其它日志不动',
+      consolidateCleared: '已清除 {n} 条失败记录',
       allLibraries: '全部记忆库',
+      wallAllBlocked: '当前宿主只允许单库读取，已显示第一个记忆库',
+      linkCountTag: '关联 {n}',
+      linkRemoved: '关联已移除',
       searchMemories: '搜索标题、内容或标签',
       poolReview: '待复核',
       poolInactive: '已失效',
       wallReadError: '部分记忆库读取失败',
       wallLimit: '仅展示最近 300 条',
+      wallScopePrivate: '私有',
+      wallScopeGlobal: '全局',
+      wallFilterScope: '范围',
+      wallFilterStatus: '状态',
+      wallFilterLayer: '层级',
+      wallAllLayers: '全部层级',
+      multiSelect: '多选',
+      wallSelected: '已选 {n} 条',
+      wallSelectAll: '全选本页',
+      wallClearSelection: '清空选择',
+      wallMultiExit: '退出多选',
+      viewMemory: '查看此记忆',
+      entityDelete: '删除实体',
+      entityDeleteForceHint: '仍被记忆或关系引用；再点一次将连同引用一起删除',
       openMemu: '打开 MemU WebUI',
       saved: '已保存',
       copied: '已复制',
@@ -162,7 +193,17 @@ window.__ModuleLoader__.load({
       characterId: '当前角色 ID',
       worldId: '世界线 ID',
       branchId: '剧情分支 ID',
-      exportImages: '导出含图片',
+      exportZip: '导出 ZIP（含图片）',
+      exportStarted: '已开始导出：{file}',
+      memorySaved: '记忆已保存',
+      memoryArchived: '记忆已归档',
+      memoryRestored: '记忆已恢复',
+      memoryDeleted: '记忆已删除',
+      bulkDone: '批量操作完成：{n} 条',
+      curatorReview: '全局记忆审核',
+      descCuratorReview: '控制全局提炼的写入方式：自动模式只暂扣冲突、缺证据与高风险改写；全部待审把每个内容改动都送进复核队列。',
+      curatorReviewAuto: '自动（默认）',
+      curatorReviewAll: '全部待审',
       archiveTooLarge: '附件包超过单次导入上限（16 MB），请拆分',
       openSettings: '打开设置页',
       sidebarSettings: '在侧边栏保留完整设置',
@@ -173,7 +214,7 @@ window.__ModuleLoader__.load({
       adjacency: '邻接列表',
       graphView: '关系图',
       viewMemories: '记忆',
-      viewRelations: '关系',
+      viewRelations: '节点图',
       close: '关闭',
       openInBrowser: '在记忆浏览中打开',
       globalReadOnly: '全局记忆在这里只读；需要修改请去全局记忆页。',
@@ -192,6 +233,7 @@ window.__ModuleLoader__.load({
       entityAliases: '别名（逗号分隔）',
       entityKind: '实体类型',
       graphEmpty: '还没有关联',
+      graphAutoLink: '自动',
       deletedNode: '[已删除]',
       graphLimited: '仅显示最多 200 个节点',
       graphFit: '适应全图',
@@ -273,6 +315,13 @@ window.__ModuleLoader__.load({
       reviews: '待复核',
       reviewsEmpty: '没有等待复核的记忆。',
       reviewScopePrivate: '私有库',
+      // 包 F2：集合吸收（absorb）复核与撤销。
+      absorbTag: '集合吸收 · {n} 条',
+      absorbSourcesTag: '集合记忆 · {n} 条来源',
+      absorbUndo: '撤销合并',
+      absorbUndone: '已撤销合并，来源记忆已恢复',
+      absorbSourcesLabel: '吸收来源',
+      absorbLinksLabel: '关联记忆',
       accuracyTag: '细节未必准',
       accept: '接受',
       reject: '丢弃',
@@ -610,7 +659,170 @@ window.__ModuleLoader__.load({
       rememberChoice: '记住我的选择，下次新对话直接用',
       confirm: '确定',
       later: '稍后',
+      // —— 词典页 ——
+      pageLexicon: '词典',
+      descLexicon: '每个记忆库一本词典：黑话、梗、触发词与术语的释义、归档与命中统计。',
+      lexiconScope: '词条管理',
+      lexiconNoLibrary: '还没有记忆库；词典随私有记忆库创建。',
+      lexiconTotal: '共 {total} 条',
+      lexiconTerm: '词条',
+      lexiconKind: '类型',
+      lexiconAllKinds: '全部类型',
+      lexiconKindSlang: '黑话',
+      lexiconKindMeme: '梗',
+      lexiconKindTrigger: '触发词',
+      lexiconKindTerm: '术语',
+      lexiconMeaning: '释义',
+      lexiconUsage: '用法',
+      lexiconAliases: '别名（逗号分隔）',
+      lexiconExamples: '例句（每行一条）',
+      lexiconSensitivity: '敏感度',
+      lexiconSensitivityAll: '全部敏感度',
+      lexiconNormal: '普通',
+      lexiconSensitive: '敏感',
+      lexiconStatus: '状态',
+      lexiconAllStatus: '全部状态',
+      lexiconStPending: '待审',
+      lexiconStRejected: '已驳回',
+      lexiconPending: '待审',
+      lexiconApprove: '通过',
+      lexiconReject: '驳回',
+      lexiconHits: '命中次数',
+      lexiconStrength: '强度',
+      lexiconSourceMemory: '来源记忆 ↗',
+      lexiconSearch: '搜索词条 / 释义 / 别名',
+      lexiconNew: '新建词条',
+      lexiconCreate: '写入词典',
+      lexiconEdit: '编辑词条',
+      lexiconSaveDone: '词条已保存。',
+      lexiconReviewDone: '审核完成。',
+      lexiconAddDone: '词条已写入。',
+      lexiconDelete: '删除词条',
+      lexiconDeleteHint: '删除是永久的：先点一下「删除词条」，再点「确认删除」。',
+      lexiconDeleted: '已删除 {n} 条词条。',
+      lexiconPrev: '上一页',
+      lexiconNext: '下一页',
+      lexiconPageOf: '第 {page} / {pages} 页',
+      lexiconEmpty: '这个词库还没有词条。',
+      lexiconNoMatch: '没有匹配的词条。',
+      lexiconTabActive: '使用中 ({n})',
+      lexiconTabArchived: '已归档 ({n})',
+      lexiconArchivedEmpty: '没有已归档的词条。',
+      lexiconArchive: '归档',
+      lexiconRestore: '恢复',
+      lexiconArchiveDone: '词条已归档，可随时恢复。',
+      lexiconRestoreDone: '词条已恢复。',
+      lexiconArchivedCount: '已归档 {n} 条词条。',
+      lexiconRestoredCount: '已恢复 {n} 条词条。',
+      lexiconCardUsage: '用法',
+      lexiconCardAliases: '别名',
       loading: '加载中…',
+      // ── 包 C/D/E 新增键（词典提案态 + 实体可见性 + 帮助页）──
+      lexiconProposal: '提案',
+      lexiconPendingEmpty: '没有待审的词条提案。',
+      lexiconHitsDetail: '命中明细：候选 {candidate} · 注入 {injection} · 查询 {query}',
+      orphanEntities: '未关联实体 ({n})',
+      orphanPruneHint: '这些实体没有被任何记忆或关系引用，插件下次启动时会自动清理。',
+      entityEmpty: '这个词库还没有实体。',
+      firstRunTitle: '先建一个记忆库',
+      firstRunDesc: '还没有任何记忆库。新建一个私有库后，会话里的记忆才有地方落。',
+      firstRunGoLibraries: '去新建库',
+      firstRunGuide: '查看快速上手',
+      pageHelp: '帮助',
+      descHelp: '快速上手、作用域/标注说明、常见问题与反馈入口',
+      helpQuickStart: '快速开始',
+      helpGoTo: '前往 →',
+      helpStep1: '新建一个私有库：在「记忆库」页新建。成功时列表里出现当前项目的库，文件夹页也能看到它。',
+      helpStep2: '在会话里绑定库：在对话中让助手调用 memu_bind（或发送 /memu 绑定），或在新会话卡里选定作用域。成功后侧栏会话卡显示已绑定这个库。',
+      helpStep3: '选择注入模式：在设置的「注入模式」里选 smart（按需）/ anchor-only（只锚点）/ per-turn（每轮）/ off（关闭）。成功时状态卡显示已选模式，下一轮按它注入。',
+      helpStep4: '在记忆页确认与修正：MemU 记忆页列出召回与写入的条目。点开抽屉看全文、改错字、归档不需要的内容；成功时改动立即生效。',
+      helpStep5: '在词典页维护黑话：AI 写入的词条会自动 active 并参与注入；你可以编辑、归档/恢复、彻底删除，sensitive trigger 只能由你添加或修改。成功时词条出现在「使用中」，归档的进入「已归档」可恢复。',
+      helpScopes: '私有与全局怎么判断',
+      helpScopesDesc: '先看文件夹上限，再看本会话开关，最后得到生效作用域。',
+      helpScopesChain: '判断顺序：工作区 → 文件夹策略（useLibrary / useGlobal 上限）→ 会话绑定（实际开关）→ effectiveScope。文件夹是天花板，会话只能在天花板以内生效。',
+      helpScopesPrivate: '私有 = 本文件夹内所有会话共享同一个库：换对话仍读同一份，写入对所有会话可见，可编辑、归档与恢复。',
+      helpScopesGlobal: '全局 = curator 在后台跨会话整理写入，按 domain 与 applies_to 过滤；界面上只读，只能复核、撤销合并或移除链接，不能手改正文。',
+      helpScopesWhere: '在哪里改：文件夹页设上限；侧栏会话卡设本对话开关；全局页只审阅。',
+      helpScopesPitfallsTitle: '常见误区',
+      helpScopesPitfall1: '文件夹关掉全局后，会话无法再打开它——上限优先，开关会显示为禁用。',
+      helpScopesPitfall2: '只开全局、不开私有的对话没有私有库，私有记忆工具会明确报错而不是凭空建库。',
+      helpScopesPitfall3: '条目带上下文（频道/角色/世界线/分支/knownBy）时，不匹配的会话看不到它；这是过滤，不是丢失。',
+      helpTitleCards: '标题卡与召回',
+      helpTitleCardsBody: '锚点与本回合召回只显示标题卡：标题、标签和 id，正文不注入；全文仍在记忆页抽屉与召回工具里。',
+      helpTitleCardsRecall: '标题是目录：用标题关键词，或标题卡里方括号内的 id 调 memu_private_recall / memu_global_recall，工具返回仍是全文。',
+      helpTitleCardsRule: '标题写作：8–40 字，写具体的人/物/事件或结论（如「Yuike 名字来自小时候的白猫」），不要空标题或「关于XX的事」；细节放进 content。',
+      helpArchiveDelete: '归档、删除与撤回',
+      helpArchiveDeleteArchive: '归档 = 软删除：随时可恢复，关系与链接保留，不级联；条目移到「已归档」页签，不再注入。',
+      helpArchiveDeleteDelete: '彻底删除：界面只对已归档条目开放，需两段确认，永久且不可撤销；会级联清掉指向它的入边，并清理因此孤立的实体。',
+      helpArchiveDeleteLexicon: '词典同口径：归档可恢复，删除永久；模型没有删除或复核路径，sensitive 词条只有用户能改。',
+      helpArchiveDeleteAbsorb: '合并（absorb）：合并稿成为新 active，目标标记 superseded，来源归档；在全局页对合并稿点「撤销合并」可整体撤回，全局链接也可逐条移除。',
+      helpArchiveDeleteSessionGone: '删除的对话不会触发整理失败：扫描会标记 sessionGone 并跳过，不反复重试。',
+      helpVector: '向量库',
+      helpVectorSetup: 'memoryBackend=api + vectorSource=local 表示：MemU 负责存储与检索，本地受管 embedding 模型提供向量。到「连接与向量」选本地来源，并在同页的受管向量区下载运行时与模型，就绪后切换。',
+      helpVectorCount: '「当前已入向量库 N 条」统计的是当前 active 代际里已有向量的条数；条目上的「已入向量库 · gN」是该条写入时的代际标签。',
+      helpVectorFallback: '向量未激活（只有 requested 或重建失败）时，召回自动回退词法检索：仍然可用，只是语义匹配更弱。',
+      helpVectorRebuild: '切换模型或修复失败要重建：新代际建成前旧代际保持只读，成功后的新记忆写入新代际；失败不会改当前代际，可以再点一次续建。',
+      helpAutoLink: '私有自动关联与实体枢纽',
+      helpAutoLinkRule: "先跑算法，不额外花模型 token：同库、同上下文/轨道、可见且非 secret 的两条记忆，若共享稀有名称/别名、内容不冲突，就直接建立 memory↔memory 链接并标 source:'auto'。",
+      helpAutoLinkHub: '实体枢纽：「猫娘yuike」与「yuike名字的由来」共享 yuike，算法会复用或创建 yuike 实体，并把两条记忆连到它；人物/物品类型按保守信号推断。',
+      helpAutoLinkWorker: '拿不准的候选交给本次整理 worker（memu_private_link_suggest）带证据裁决；不会另起一次完整整理，也不重读转录；没有候选就不连。',
+      helpAutoLinkSafety: '自动关联只改图元数据：不改正文、不写向量、不删除。关系图显示「自动」标记和移除（×）；实体删除仍按既有规则。',
+      helpLabels: '标注速查表',
+      helpLabelsDesc: '记忆与关系图上会出现的标记。',
+      helpLabelColLabel: '标注',
+      helpLabelColMeaning: '含义',
+      helpLabelSource: 'source',
+      helpLabelSourceMeaning: '来源：inferred 推断 / user_said 用户原话（可引用）/ told 转述 / imagined 想象。imagined 不能当事实。',
+      helpLabelLayer: 'layer',
+      helpLabelLayerMeaning: '层级：must_remember 必记 / long_term 长期 / short_term 短期指针（只给指针，不含正文）。',
+      helpLabelOpenLoop: 'open_loop',
+      helpLabelOpenLoopMeaning: '未闭环：还有承诺或悬念没交代。',
+      helpLabelMarginalized: 'marginalized',
+      helpLabelMarginalizedMeaning: '已边缘化：移出主记忆但未删除，仍可检索。',
+      helpLabelDate: 'date / anniversary',
+      helpLabelDateMeaning: '日期：date 是一次性某天；anniversary 每年重复（生日/纪念日）。',
+      helpLabelAttachment: '附件N',
+      helpLabelAttachmentMeaning: '标题卡上的附件计数，不展开 caption；正文与图片在抽屉或工具里。',
+      helpLabelVector: '已入向量库 · gN',
+      helpLabelVectorMeaning: '该条已写入第 N 代向量空间；「当前已入向量库 N 条」统计 active 代际。',
+      helpLabelReviewRisk: 'reviewRisk',
+      helpLabelReviewRiskMeaning: '全局条目的复核风险分（0–2）；越高越可能进「待复核」，它不是置信度。',
+      helpLabelLexicon: 'lexicon kind / sensitive / hitCount · 自动',
+      helpLabelLexiconMeaning: '词典：kind 是词条类型；sensitive 仅用户可管；hitCount 是命中次数。关系图「自动」= 算法建立的链接。',
+      helpSidebar: '侧边栏地图',
+      helpSidebarDesc: '侧栏几个提醒与开关的位置。',
+      helpSidebarAlerts: '「整理提醒」跨会话汇总整理结果：失败行需要处理，点 ↗ 打开该条记忆所在的库；「清除失败记录」只删失败日志，成功记录与其他日志不动。',
+      helpSidebarReview: '「待复核」= pending_review：内容还没通过复核，所以不注入；侧栏统计只显示数量，审阅入口在「全局记忆」页的待复核队列（私有条目也在这里带「私有库」标签）。',
+      helpSidebarRunLog: '「整理记录」列最近几次整理的状态、时间与消息；「整理提醒」展开后分失败/成功两列。',
+      helpSidebarReviewMode: '审核模式开关在全局记忆页：「auto」只暂扣冲突、缺证据与高风险改写，「review-all」把所有内容操作送进复核。',
+      helpSidebarFirstRun: '首次安装卡只在没有任何记忆库时出现；建好第一个库后自动消失，没有关闭按钮，也不写本地存储。',
+      helpSidebarFallback: 'WebUI 若不允许「全部库」读取（宿主返回 403），记忆墙会退回第一个可访问的库并明确提示，不会整页空白；多库选项会禁用。',
+      helpSidebarScope: '本对话的作用域卡在侧栏「记忆」页：顶部两层显示文件夹与会话，控制卡里是私有/全局开关，下方折叠卡可设频道/角色/世界线/分支。',
+      helpFaq: '常见问题',
+      helpFaq1: '为什么没有召回？',
+      helpFaq1A: '按顺序检查：会话是否绑定库（memu_bind / /memu 绑定）；注入模式是否 off；文件夹或会话的私有/全局开关是否关掉；条目是否还在 active 且未被上下文（频道/角色/世界线/分支/knownBy）或 domain 过滤。本地向量未激活不会让召回消失，只会回退到词法。',
+      helpFaq2: '私有库和全局记忆有什么区别？',
+      helpFaq2A: '私有库由本文件夹所有会话共享，写入即可编辑、归档、恢复；全局由 curator 在后台跨会话整理写入，按 domain/applies_to 过滤，界面里只读，只能复核、撤销合并或移除链接。',
+      helpFaq3: '为什么有些记忆不会被注入？',
+      helpFaq3A: '常见原因：pending_review（等内容复核）、archived/suppressed/expired/superseded、visibility=secret（自动注入会跳过）、上下文或 domain 不匹配。词典条目没有 pending 复核：写入即 active，归档的才不注入。',
+      helpFaq4: '为什么锚点只有标题？怎么拿到正文？',
+      helpFaq4A: '锚点与本回合召回是目录：只给标题、标签和 id，避免挤占预算，也避免模型引用没拿到的原文。正文用 memu_private_recall / memu_global_recall 按标题关键词或 id 取，工具仍返回全文；也可在记忆页抽屉里直接读。',
+      helpFaq5: '整理合并（absorb）之后，原来的条目去哪了？怎么撤销？',
+      helpFaq5A: '合并不会删除任何东西：合并稿成为新的 active 条目，被吸收的来源归档、被取代的目标标记 superseded。在全局记忆页找到合并稿，点「撤销合并」即可整体恢复原状；全局链接也可以逐条移除。',
+      helpFaq6: '词典为什么自动生效？怎么归档？为什么某条不注入？',
+      helpFaq6A: '词典写入即 active，没有待审队列；归档会立即停止注入且可恢复，彻底删除只在管理面提供、不可撤销。词条不注入时检查是否已归档、上下文/可见性是否匹配。sensitive trigger 只有用户能改。',
+      helpFaq7: '自动关联和实体枢纽怎么撤销？',
+      helpFaq7A: '关系图里带「自动」的边是算法建立的：点旁边的 × 两段确认后即可移除。移除只改图元数据，不改正文、不写向量、不删记忆。实体删除沿用既有规则：被引用时默认拒绝，确认后才连同入边一起移除。',
+      helpFaq8: '自动备份和导出 JSON/ZIP 有什么区别？',
+      helpFaq8A: '自动备份是整机快照：插件状态、全局/私有索引、词典、提示词、附件引用与 MemU 数据库，外加逐文件校验和的 manifest；切换引擎/恢复前会自动做一份。导出 JSON/ZIP 是单库导出，ZIP 额外带图片附件；两种导出都能再导入回来。',
+      helpFaq9: '删除的对话还会被整理吗？',
+      helpFaq9A: '不会。会话被删除后，空闲整理扫描会把它标记为 sessionGone 并跳过，只记一条 check 级日志，不反复重试，也不影响其他会话的整理。',
+      helpFaq10: '本地向量模型未激活怎么办？',
+      helpFaq10A: '没有 active 向量代际时会回退词法检索，仍可用但语义更弱。「当前已入向量库 N 条」指 active 代际里的条数；切换模型或修复失败后要重建，旧代际在重建期间只读，失败不会动当前代际，可再点一次续建。',
+      helpFeedback: '反馈',
+      helpOpenIssue: '提交 Issue',
+      helpCopyDiagnostics: '复制诊断信息',
+      helpDocs: '打开文档',
     }
 
     const en = {
@@ -642,12 +854,43 @@ window.__ModuleLoader__.load({
       logClear: 'Clear log',
       runLogTitle: 'Runs',
       runLogEmpty: 'No runs recorded yet.',
+      runLogOpen: 'All logs',
+      dedupedNotice: 'Not written: the library already holds a near-identical memory [{id}]. Edit and merge into that entry instead; pass allow_duplicate only for two genuinely independent observations.',
+      consolidateFeedTitle: 'Consolidation alerts',
+      consolidateFailedCol: 'Failed',
+      consolidateOkCol: 'Succeeded',
+      consolidateFailed: 'Fail',
+      consolidateDone: 'Done',
+      consolidateFailedCount: '{n} failed',
+      consolidateJumpHint: 'Open the library holding this memory in the memory studio',
+      consolidateExpand: 'Expand',
+      consolidateCollapse: 'Collapse',
+      consolidateClear: 'Clear failures',
+      consolidateClearHint: 'Deletes only failed consolidation logs; successes and other logs stay',
+      consolidateCleared: 'Cleared {n} failure logs',
       allLibraries: 'All libraries',
+      wallAllBlocked: 'This host only allows one library per read; showing the first library',
+      linkCountTag: 'Links {n}',
+      linkRemoved: 'Link removed',
       searchMemories: 'Search titles, content or tags',
       poolReview: 'Review',
       poolInactive: 'Inactive',
       wallReadError: 'Some libraries could not be read',
       wallLimit: 'Showing the latest 300 entries',
+      wallScopePrivate: 'Private',
+      wallScopeGlobal: 'Global',
+      wallFilterScope: 'Scope',
+      wallFilterStatus: 'Status',
+      wallFilterLayer: 'Layer',
+      wallAllLayers: 'All layers',
+      multiSelect: 'Multi-select',
+      wallSelected: '{n} selected',
+      wallSelectAll: 'Select page',
+      wallClearSelection: 'Clear selection',
+      wallMultiExit: 'Exit select',
+      viewMemory: 'View',
+      entityDelete: 'Delete entity',
+      entityDeleteForceHint: 'Still referenced by memories or relations; click again to delete with its links',
       openMemu: 'Open MemU WebUI',
       saved: 'Saved',
       copied: 'Copied',
@@ -669,7 +912,17 @@ window.__ModuleLoader__.load({
       characterId: 'Current character ID',
       worldId: 'World ID',
       branchId: 'Story branch ID',
-      exportImages: 'Export with images',
+      exportZip: 'Export ZIP (with images)',
+      exportStarted: 'Export started: {file}',
+      memorySaved: 'Memory saved',
+      memoryArchived: 'Memory archived',
+      memoryRestored: 'Memory restored',
+      memoryDeleted: 'Memory deleted',
+      bulkDone: 'Bulk action finished: {n}',
+      curatorReview: 'Curation review mode',
+      descCuratorReview: 'How global curation writes: auto holds conflicts, missing evidence and risky rewrites for review; review-everything sends each content change to the review queue.',
+      curatorReviewAuto: 'Auto (default)',
+      curatorReviewAll: 'Review everything',
       archiveTooLarge: 'Attachment archive exceeds 16 MB; split it before importing',
       openSettings: 'Open settings',
       sidebarSettings: 'Keep full settings in the sidebar',
@@ -680,7 +933,7 @@ window.__ModuleLoader__.load({
       adjacency: 'Adjacency',
       graphView: 'Graph',
       viewMemories: 'Memories',
-      viewRelations: 'Relations',
+      viewRelations: 'Node graph',
       close: 'Close',
       openInBrowser: 'Open in the browser',
       globalReadOnly: 'Global memories are read-only here; edit them on the global page.',
@@ -699,6 +952,7 @@ window.__ModuleLoader__.load({
       entityAliases: 'Aliases (comma separated)',
       entityKind: 'Entity kind',
       graphEmpty: 'No connections yet',
+      graphAutoLink: 'Auto',
       deletedNode: '[deleted]',
       graphLimited: 'Showing at most 200 nodes',
       graphFit: 'Fit graph',
@@ -780,6 +1034,13 @@ window.__ModuleLoader__.load({
       reviews: 'Awaiting review',
       reviewsEmpty: 'No memories are waiting for review.',
       reviewScopePrivate: 'private library',
+      // Package F2: set-absorb (absorb) review and undo.
+      absorbTag: 'Set absorb · {n} entries',
+      absorbSourcesTag: 'Merged memory · {n} sources',
+      absorbUndo: 'Undo merge',
+      absorbUndone: 'Merge undone; source memories restored',
+      absorbSourcesLabel: 'Absorbed sources',
+      absorbLinksLabel: 'Linked memories',
       accuracyTag: 'details may be off',
       accept: 'Accept',
       reject: 'Discard',
@@ -1116,7 +1377,170 @@ window.__ModuleLoader__.load({
       rememberChoice: 'Remember this choice for new conversations',
       confirm: 'Confirm',
       later: 'Later',
+      // —— Lexicon page ——
+      pageLexicon: 'Lexicon',
+      descLexicon: 'One lexicon per memory library: slang, memes, triggers and terms with meanings, archive and hit counts.',
+      lexiconScope: 'Terms',
+      lexiconNoLibrary: 'No memory libraries yet; a lexicon comes with each private library.',
+      lexiconTotal: '{total} terms',
+      lexiconTerm: 'Term',
+      lexiconKind: 'Kind',
+      lexiconAllKinds: 'All kinds',
+      lexiconKindSlang: 'Slang',
+      lexiconKindMeme: 'Meme',
+      lexiconKindTrigger: 'Trigger',
+      lexiconKindTerm: 'Term',
+      lexiconMeaning: 'Meaning',
+      lexiconUsage: 'Usage',
+      lexiconAliases: 'Aliases (comma separated)',
+      lexiconExamples: 'Examples (one per line)',
+      lexiconSensitivity: 'Sensitivity',
+      lexiconSensitivityAll: 'All sensitivities',
+      lexiconNormal: 'Normal',
+      lexiconSensitive: 'Sensitive',
+      lexiconStatus: 'Status',
+      lexiconAllStatus: 'All statuses',
+      lexiconStPending: 'Pending',
+      lexiconStRejected: 'Rejected',
+      lexiconPending: 'Pending',
+      lexiconApprove: 'Approve',
+      lexiconReject: 'Reject',
+      lexiconHits: 'Hits',
+      lexiconStrength: 'Strength',
+      lexiconSourceMemory: 'Source memory ↗',
+      lexiconSearch: 'Search terms / meanings / aliases',
+      lexiconNew: 'New term',
+      lexiconCreate: 'Add to lexicon',
+      lexiconEdit: 'Edit term',
+      lexiconSaveDone: 'Term saved.',
+      lexiconReviewDone: 'Review recorded.',
+      lexiconAddDone: 'Term added.',
+      lexiconDelete: 'Delete terms',
+      lexiconDeleteHint: 'Deletion is permanent: click "Delete terms" once, then confirm.',
+      lexiconDeleted: 'Deleted {n} terms.',
+      lexiconPrev: 'Previous',
+      lexiconNext: 'Next',
+      lexiconPageOf: 'Page {page} / {pages}',
+      lexiconEmpty: 'This lexicon has no terms yet.',
+      lexiconNoMatch: 'No matching terms.',
+      lexiconTabActive: 'In use ({n})',
+      lexiconTabArchived: 'Archived ({n})',
+      lexiconArchivedEmpty: 'No archived terms.',
+      lexiconArchive: 'Archive',
+      lexiconRestore: 'Restore',
+      lexiconArchiveDone: 'Term archived — you can restore it anytime.',
+      lexiconRestoreDone: 'Term restored.',
+      lexiconArchivedCount: 'Archived {n} term(s).',
+      lexiconRestoredCount: 'Restored {n} term(s).',
+      lexiconCardUsage: 'Usage',
+      lexiconCardAliases: 'Aliases',
       loading: 'Loading…',
+      // ── Package C/D/E keys (lexicon proposals + entity visibility + help page) ──
+      lexiconProposal: 'Proposal',
+      lexiconPendingEmpty: 'No pending term proposals.',
+      lexiconHitsDetail: 'Hit detail: {candidate} candidates · {injection} injections · {query} queries',
+      orphanEntities: 'Unlinked entities ({n})',
+      orphanPruneHint: 'No memory or relationship references these entities; the plugin cleans them up automatically at the next startup.',
+      entityEmpty: 'No entities in this library yet.',
+      firstRunTitle: 'Create a memory library first',
+      firstRunDesc: 'There are no libraries yet. Memories from your conversations need one to land in.',
+      firstRunGoLibraries: 'Create a library',
+      firstRunGuide: 'Quick start guide',
+      pageHelp: 'Help',
+      descHelp: 'Quick start, scope and label reference, FAQ and feedback',
+      helpQuickStart: 'Quick start',
+      helpGoTo: 'Go →',
+      helpStep1: 'Create a private library: create one on the Libraries page. Success looks like the project library in the list, and the folders page showing it too.',
+      helpStep2: 'Bind the library in the conversation: ask the assistant to call memu_bind (or send the /memu bind command), or pick the scope in the new-session card. Success looks like the sidebar session card naming this library.',
+      helpStep3: 'Pick an injection mode: in Settings → Injection mode choose smart (on demand), anchor-only (anchor only), per-turn (every turn) or off. Success looks like the status card showing the chosen mode and the next turn following it.',
+      helpStep4: 'Confirm and correct on the memory page: the MemU memory page lists recalled and written entries. Open the drawer for the full text, fix mistakes, archive what you do not need; changes take effect immediately.',
+      helpStep5: 'Maintain slang on the lexicon page: entries the AI writes become active automatically and join injection; you can edit, archive/restore and permanently delete, and sensitive triggers are user-only. Success looks like the term under "In use", with archived ones restorable under "Archived".',
+      helpScopes: 'Private vs global',
+      helpScopesDesc: 'The folder sets the ceiling, the conversation sets the switches.',
+      helpScopesChain: 'Decision order: workspace → folder policy (useLibrary / useGlobal ceilings) → session binding (actual switches) → effectiveScope. The folder is a ceiling; a conversation can only work within it.',
+      helpScopesPrivate: 'Private = every conversation in this folder shares one library: another chat in the same folder reads the same entries, writes are visible to all of them, and entries stay editable, archivable and restorable.',
+      helpScopesGlobal: 'Global = the curator consolidates across conversations in the background and writes it, filtered by domain and applies_to; in the UI it is read-only — review, undo a merge or remove a link, never hand-edit the body.',
+      helpScopesWhere: 'Where to change it: the folders page sets the ceilings; the sidebar session card sets this conversation; the global page only reviews.',
+      helpScopesPitfallsTitle: 'Common pitfalls',
+      helpScopesPitfall1: 'With global off in the folder, a conversation cannot turn it back on — the ceiling wins and the switch is shown disabled.',
+      helpScopesPitfall2: 'A conversation with global only has no private library; private-memory tools say so instead of creating one silently.',
+      helpScopesPitfall3: 'Entries carrying context (channel / character / world / branch / knownBy) stay hidden from conversations that do not match; that is filtering, not loss.',
+      helpTitleCards: 'Title cards and recall',
+      helpTitleCardsBody: 'The anchor and per-turn recall show title cards only: title, tags and id; bodies are not injected. The full text still lives in the memory drawer and the recall tools.',
+      helpTitleCardsRecall: 'The title is a directory: recall by title keyword, or by the id shown in brackets on the card, with memu_private_recall / memu_global_recall; the tools still return the full text.',
+      helpTitleCardsRule: 'Title rule: 8–40 characters naming the concrete person/object/event or conclusion ("Yuike is named after a childhood white cat"); no empty titles or "about X" labels; details belong in content.',
+      helpArchiveDelete: 'Archive, delete and undo',
+      helpArchiveDeleteArchive: 'Archive = soft delete: restorable at any time, links and relationships kept, no cascade; the entry moves to the "Archived" tab and stops being injected.',
+      helpArchiveDeleteDelete: 'Permanent delete: the UI offers it only for archived entries, with a two-step confirmation. It is final and also removes inbound links to the entry and prunes entities left orphaned by it.',
+      helpArchiveDeleteLexicon: 'The lexicon follows the same rules: archive is restorable, delete is permanent; the model has no delete or review path, and sensitive terms stay user-managed.',
+      helpArchiveDeleteAbsorb: 'Absorb: the merged entry becomes active, the target is marked superseded and the sources are archived. On the global page press "Undo merge" on the merged entry to roll it all back; global links can also be removed one by one.',
+      helpArchiveDeleteSessionGone: 'A deleted conversation never fails consolidation: the sweep marks it sessionGone and skips it instead of retrying forever.',
+      helpVector: 'Vector store',
+      helpVectorSetup: 'memoryBackend=api with vectorSource=local means MemU keeps storing and retrieving locally while a managed embedding model supplies the vectors. Pick the local source on "Connection & vectors", then download the runtime and model in the managed-vector area on the same page and switch.',
+      helpVectorCount: '"Currently indexed N items" counts entries that already have vectors in the active generation; "In vector store · gN" on an entry is the generation tag it was written into.',
+      helpVectorFallback: 'With no active generation (only requested, or a failed rebuild) recall falls back to lexical search: still usable, weaker semantics.',
+      helpVectorRebuild: 'Rebuild when switching models or repairing a failure: the old generation stays read-only until the new one commits, and new memories then go to the new generation. A failed rebuild leaves the active generation unchanged; press again to resume.',
+      helpAutoLink: 'Private auto-links and entity hubs',
+      helpAutoLinkRule: "Algorithm first, zero extra model tokens: two memories in the same library, same context/track, visible and not secret, sharing a rare name/alias and not conflicting are linked memory↔memory with source:'auto'.",
+      helpAutoLinkHub: 'Entity hub: "猫娘yuike" and "yuike名字的由来" share yuike, so the algorithm reuses or creates a yuike entity and links both memories to it; person/thing kind is inferred conservatively.',
+      helpAutoLinkWorker: 'Uncertain candidates go to the current consolidation worker (memu_private_link_suggest), which adjudicates with evidence; it never starts another full consolidation or rereads the transcript, and no candidates means no links.',
+      helpAutoLinkSafety: 'Auto-links only add graph metadata: no body changes, no vectors, no deletion. The graph shows an "Auto" badge and a remove (×); entity deletion still follows the existing rules.',
+      helpLabels: 'Label cheat sheet',
+      helpLabelsDesc: 'Badges you will see on memories and in the relationship graph.',
+      helpLabelColLabel: 'Label',
+      helpLabelColMeaning: 'Meaning',
+      helpLabelSource: 'source',
+      helpLabelSourceMeaning: 'Provenance: inferred / user_said (quotable) / told / imagined. imagined must never be treated as fact.',
+      helpLabelLayer: 'layer',
+      helpLabelLayerMeaning: 'Layer: must_remember / long_term / short_term pointer (a pointer only, no body).',
+      helpLabelOpenLoop: 'open_loop',
+      helpLabelOpenLoopMeaning: 'Open loop: a promise or suspense line is still unresolved.',
+      helpLabelMarginalized: 'marginalized',
+      helpLabelMarginalizedMeaning: 'Marginalized: pulled out of primary memory but not deleted; still searchable.',
+      helpLabelDate: 'date / anniversary',
+      helpLabelDateMeaning: 'Date: date is one specific day; anniversary repeats every year (birthday / memorial).',
+      helpLabelAttachment: '附件N',
+      helpLabelAttachmentMeaning: 'Attachment count on a title card; captions are not expanded there — body and images live in the drawer or tools.',
+      helpLabelVector: 'In vector store · gN',
+      helpLabelVectorMeaning: 'The entry is in generation N of the vector space; "Currently indexed N items" counts the active generation.',
+      helpLabelReviewRisk: 'reviewRisk',
+      helpLabelReviewRiskMeaning: 'Review risk score (0–2) for global entries; higher means more likely held for review. It is not confidence.',
+      helpLabelLexicon: 'lexicon kind / sensitive / hitCount · Auto',
+      helpLabelLexiconMeaning: 'Lexicon: kind is the term type; sensitive is user-managed; hitCount is how often it hit. Graph "Auto" = an algorithm-created link.',
+      helpSidebar: 'Sidebar map',
+      helpSidebarDesc: 'Where the reminders and switches live in the sidebar.',
+      helpSidebarAlerts: 'Consolidation alerts aggregate results across conversations: failed rows need attention, ↗ opens the library holding that memory, and "Clear failures" deletes only failed logs — successes and other logs stay.',
+      helpSidebarReview: '"Needs review" = pending_review: nobody has approved the content yet, so it is not injected. The sidebar only shows the count; the review queue is on the global page (private items are tagged "private library" there).',
+      helpSidebarRunLog: '"Runs" lists recent consolidation status, time and message; expanding the alerts card splits failures and successes into two columns.',
+      helpSidebarReviewMode: 'The review-mode switch is on the global memory page: "auto" holds only conflicts, missing evidence and risky rewrites; "review-all" sends every content operation to review.',
+      helpSidebarFirstRun: 'The first-install card appears only while there are no libraries; it disappears once the first one exists. There is no dismiss button and no local storage.',
+      helpSidebarFallback: 'If the host forbids all-library browsing (403), the memory wall falls back to the first accessible library and says so instead of going blank; the multi-library option is disabled.',
+      helpSidebarScope: 'The conversation scope card is on the sidebar Memory page: the top shows folder and conversation, the control card holds the private/global switches, and the collapsed card below sets channel / character / world / branch.',
+      helpFaq: 'FAQ',
+      helpFaq1: 'Why is nothing being recalled?',
+      helpFaq1A: 'Check in order: is the conversation bound to a library (memu_bind / the /memu bind command); is the injection mode off; are the folder or conversation private/global switches off; is the entry still active and not filtered by context (channel/character/world/branch/knownBy) or domain. A missing local vector generation does not empty recall — it only falls back to lexical search.',
+      helpFaq2: 'How do private libraries differ from global memory?',
+      helpFaq2A: 'A private library is shared by every conversation in the folder: writes are editable, archivable and restorable. Global memory is written by the curator across conversations, filtered by domain/applies_to, and read-only in the UI — review, undo a merge or remove a link, never hand-edit.',
+      helpFaq3: 'Why are some memories not injected?',
+      helpFaq3A: 'Common reasons: pending_review (waiting for approval), archived/suppressed/expired/superseded, visibility=secret (automatic injection skips it), or a context/domain mismatch. Lexicon terms have no pending review anymore: they are active on write and only archived terms stop being injected.',
+      helpFaq4: 'Why does the anchor show only titles, and how do I get the body?',
+      helpFaq4A: 'The anchor and per-turn recall are a directory: title, tags and id only, to save budget and avoid quoting text the model was not given. Fetch the body with memu_private_recall / memu_global_recall by title keyword or id; the tools still return full text, and the memory-page drawer shows it too.',
+      helpFaq5: 'Where did the original entries go after an absorb, and how do I undo it?',
+      helpFaq5A: 'Absorbing deletes nothing: the merged entry becomes active, the target is marked superseded and the sources are archived. Find the merged entry on the global memory page and press "Undo merge" to restore everything; global links can be removed individually.',
+      helpFaq6: 'The lexicon writes automatically — how do I archive, and why is a term not injected?',
+      helpFaq6A: 'Lexicon terms go active immediately: there is no pending queue. Archiving stops injection at once and is restorable; permanent deletion exists only in the admin UI and cannot be undone. If a term is not injected, check whether it is archived or its context/visibility does not match. Sensitive triggers are user-only.',
+      helpFaq7: 'How do I undo an auto-link or entity hub?',
+      helpFaq7A: 'Edges with the "Auto" badge in the relationship graph were created by the algorithm: press × and confirm to remove one. Removal only touches graph metadata — no body, no vector, no deletion. Entity deletion follows the existing rules: refused while referenced, and force also removes the inbound links.',
+      helpFaq8: 'Automatic backups vs JSON/ZIP export?',
+      helpFaq8A: 'An automatic backup is a whole-install snapshot: plugin state, global/private indexes, lexicon, prompts, attachment references and the MemU databases, plus a manifest with per-file checksums; one is taken before engine switches/restores. JSON/ZIP export is per-library, and ZIP also carries image attachments; both exports can be imported back.',
+      helpFaq9: 'Are deleted conversations still consolidated?',
+      helpFaq9A: 'No. Once a conversation is deleted, the idle sweep marks it sessionGone and skips it, records a check-level log instead of an error, and does not retry forever or affect other conversations.',
+      helpFaq10: 'The vector model is inactive — what happens?',
+      helpFaq10A: 'Recall falls back to lexical search: still usable, weaker semantically. "Currently indexed N items" counts the active generation. Switching models or repairing a failure requires a rebuild; the old generation stays read-only during it, a failed rebuild leaves the active generation unchanged, and pressing again resumes.',
+      helpFeedback: 'Feedback',
+      helpOpenIssue: 'Open an issue',
+      helpCopyDiagnostics: 'Copy diagnostics',
+      helpDocs: 'Documentation',
     }
 
     // One token table for both surfaces. Every colour goes through a DSH alias so
@@ -1226,6 +1650,8 @@ window.__ModuleLoader__.load({
 .dshm-graph-tools{display:flex;flex-wrap:wrap;gap:8px;align-items:center;margin:12px 0}
 .dshm-graph-tools input,.dshm-graph-tools select{min-width:0;max-width:100%;padding:7px;border:1px solid var(--dsw-alias-border-l2,#505158);border-radius:4px;background:var(--dsw-alias-bg-layer-1,#242529);color:inherit;font:inherit}
 .dshm-graph-tools input{flex:1 1 160px}
+.dshm-root select{height:32px;max-width:100%;padding:0 30px 0 10px!important;border:1px solid var(--dsw-alias-border-l1,#dfe1e6);border-radius:9px;background-color:var(--dsw-alias-bg-layer-2,rgba(127,127,127,.08));color:var(--dsw-alias-label-primary,inherit);font:inherit;font-size:12.5px;line-height:1.2;text-overflow:ellipsis;cursor:pointer;appearance:none;-webkit-appearance:none;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='6' viewBox='0 0 10 6'%3E%3Cpath d='M1 1l4 4 4-4' fill='none' stroke='%23808a99' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E")!important;background-repeat:no-repeat!important;background-position:right 9px center!important;background-size:10px 6px!important}
+.dshm-root select:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#2563eb);outline-offset:2px}
 .dshm-graph-list{display:grid;gap:8px;margin:12px 0}
 .dshm-graph-edge{display:flex;align-items:center;gap:8px;border-bottom:1px solid var(--dsw-alias-border-l1,#43444a);padding:10px 0;min-width:0}
 .dshm-graph-edge>div{flex:1;min-width:0;overflow-wrap:anywhere}
@@ -1253,15 +1679,17 @@ window.__ModuleLoader__.load({
 .dshm-graph-missing{opacity:.5}
 /* The sidebar's context-scope form: a collapsed card instead of four bare
    inputs and a browser-default button. */
-.dshm-scope{margin:0 12px 10px;border:1px solid var(--dsw-alias-border-l1,#ddd);border-radius:12px;background:var(--dsw-alias-bg-layer-2,rgba(127,127,127,.05));overflow:hidden}
+.dshm-scope{width:100%;margin:0 0 10px;border:1px solid var(--dsw-alias-border-l1,#ddd);border-radius:12px;background:var(--dsw-alias-bg-layer-2,rgba(127,127,127,.05));overflow:hidden;flex-shrink:0}
 .dshm-scope>summary{display:flex;align-items:center;gap:7px;padding:9px 12px;list-style:none;cursor:pointer;font-size:12px;font-weight:600;color:var(--dsw-alias-label-secondary,rgba(127,127,127,.8));transition:color .18s ease}
 .dshm-scope>summary::-webkit-details-marker{display:none}
 .dshm-scope>summary::before{content:"";width:6px;height:6px;border-right:1.5px solid currentColor;border-bottom:1.5px solid currentColor;transform:rotate(-45deg);transition:transform .2s ease;margin-right:1px}
 .dshm-scope[open]>summary::before{transform:rotate(45deg)}
 .dshm-scope>summary:hover{color:var(--dsw-alias-label-primary,inherit)}
 .dshm-scope>summary:focus-visible{outline:2px solid var(--dsw-alias-brand-primary,#2563eb);outline-offset:-2px}
-.dshm-scope-form{display:grid;grid-template-columns:repeat(auto-fit,minmax(120px,1fr));gap:8px;padding:0 12px 12px}
-.dshm-scope-field{display:flex;flex-direction:column;gap:4px;min-width:0;font-size:11px;color:var(--dsw-alias-label-secondary,rgba(127,127,127,.8))}
+.dshm-scope-form{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px;padding:0 12px 12px}
+.dshm-scope-field{display:flex;flex-direction:column;gap:4px;min-width:0;font-size:11px;line-height:1.35;color:var(--dsw-alias-label-secondary,rgba(127,127,127,.8))}
+.dshm-scope-field>span{display:block;min-height:15px}
+.dshm-tab-body>*{flex-shrink:0}
 .dshm-scope-field input{height:32px;min-width:0;padding:0 10px;border:1px solid var(--dsw-alias-border-l1,#ddd);border-radius:9px;background:var(--dsw-alias-bg-layer-1,transparent);color:var(--dsw-alias-label-primary,inherit);font:inherit;font-size:12.5px;outline:none;transition:border-color .18s ease,box-shadow .18s ease}
 .dshm-scope-field input:focus{border-color:var(--dsw-alias-brand-primary,#2563eb);box-shadow:0 0 0 3px color-mix(in srgb,var(--dsw-alias-brand-primary,#2563eb) 16%,transparent)}
 .dshm-scope-actions{grid-column:1/-1;display:flex;align-items:center;gap:8px;flex-wrap:wrap;margin-top:2px}
@@ -1462,8 +1890,11 @@ window.__ModuleLoader__.load({
      * Note `window.open(..., 'noopener')` returns null even on success, which is
      * why the blocked check must not pass that flag.
      */
-    function openWebUiPage(page = null) {
-      let url = '/dsh-memu-memory/ui#/settings/' + (page || 'memories')
+    function openWebUiPage(page = null, { libraryId = null } = {}) {
+      // libraryId 走 query：SettingsPage 的 standalone 分支从 search 里取 browseLibId，
+      // 跳进去就停在出错记忆所在的库；hash 只决定落到哪个页面。
+      const query = libraryId ? '?libraryId=' + encodeURIComponent(libraryId) : ''
+      let url = '/dsh-memu-memory/ui' + query + '#/settings/' + (page || 'memories')
       try { url = new URL(url, window.location.href).toString() } catch {}
       let win = null
       try { win = window.open(url, '_blank') } catch { win = null }
@@ -1566,6 +1997,7 @@ window.__ModuleLoader__.load({
     const GlyphText = glyph(['M5 6h14', 'M5 11h14', 'M5 16h9'])
     const GlyphLayers = glyph(['M12 3l9 5-9 5-9-5 9-5z', 'M3 13l9 5 9-5'])
     const GlyphChart = glyph(['M4 19V5', 'M4 19h16', 'M8 15v-4', 'M12 15V8', 'M16 15v-6'])
+    const GlyphQuestion = glyph(['M9.1 9a3 3 0 0 1 5.8 1c0 2-3 2.4-3 4', 'M12 17.5h.01'])
 
     // Thirty daily bars, written by hand: the bundle purity gate refuses absolute
     // imports, and a chart this small does not need a library. Zero days still draw
@@ -1664,13 +2096,14 @@ window.__ModuleLoader__.load({
         h('div', { style: { ...S.barFill, width: `${pct}%` } }))
     }
 
-    function Button({ children, onClick, disabled, primary, style, title, type = 'button' }) {
+    function Button({ children, onClick, disabled, primary, style, title, type = 'button', 'aria-pressed': ariaPressed }) {
       return h('button', {
         type,
         className: 'dshm-btn',
         // Without this the prop never reaches the node, and every hover hint on
         // the surface silently stops working.
         title,
+        'aria-pressed': ariaPressed,
         style: { ...S.btn, ...(primary ? S.primary : {}), ...(style || {}), opacity: disabled ? 0.5 : 1 },
         onClick,
         disabled,
@@ -1813,6 +2246,20 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           h('div', { style: { display: 'flex', justifyContent: 'flex-end', gap: 8, marginTop: 16 } }, footer || null)))
     }
 
+    // Library selectors previously showed the whole absolute scope path, which made
+    // every option a long, nearly identical line. Keep the folder leaf as context and
+    // disambiguate same-looking names with a short id suffix only when needed.
+    function libraryBaseLabel(lib) {
+      const name = String(lib?.name || lib?.id || '')
+      const leaf = String(lib?.scopeKey || '').split(/[\\/]/).filter(Boolean).pop() || ''
+      return leaf && leaf.toLowerCase() !== name.toLowerCase() ? `${name} · ${leaf}` : name
+    }
+    function libraryOptionLabel(lib, libraries = []) {
+      const base = libraryBaseLabel(lib)
+      const duplicated = (Array.isArray(libraries) ? libraries : []).filter((item) => libraryBaseLabel(item) === base).length > 1
+      return duplicated ? `${base} · ${String(lib?.id || '').slice(-4)}` : base
+    }
+
     function useRpc(ctx) {
       return React.useCallback((endpoint, payload) => rpc(ctx, endpoint, payload), [ctx])
     }
@@ -1826,7 +2273,7 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         const ui = ctx.get?.('uiSession') || ctx.uiSession
         const cur = ui?.adapter?.current
         if (cur?.getSnapshot) {
-          return { subscribe: cur.subscribe.bind(cur), get: () => cur.getSnapshot()?.key }
+          return { subscribe: typeof cur.subscribe === 'function' ? cur.subscribe.bind(cur) : function () { return function () {} }, get: function () { return cur.getSnapshot()?.key } }
         }
         return null
       }, [ctx])
@@ -2050,6 +2497,8 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       const [entityName, setEntityName] = React.useState('')
       const [entityKind, setEntityKind] = React.useState('person')
       const [armed, setArmed] = React.useState('')
+      // deleteEntity 被后端拒绝（仍被引用）的实体 id：此时再点确认升级为 force。
+      const [deleteRefused, setDeleteRefused] = React.useState('')
       const [error, setError] = React.useState('')
       const requestId = React.useRef(0)
       const mounted = React.useRef(true)
@@ -2091,6 +2540,38 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       }
       const titles = new Map(graph.nodes.map(node => [node.id, node.missing ? t('deletedNode') : node.title]))
       const edges = graph.edges.filter(edge => !focus || edge.from === focus || edge.to === focus).sort((a, b) => b.confidence - a.confidence)
+      // 实体行：改名表单 + 删除按钮。删除是文字按钮（§6.4 包 D，原灰色 × 读不出
+      // 语义）：未 armed 显示「删除」，armed 显示「确认删除」，后端拒绝过（仍被
+      // 引用）再点确认升级为 force——「确认删除!」，连同引用一起删，force 明示的
+      // 代价。title 与两段确认保持不变，后端 force 语义零改动。
+      const entityForm = entity => h('form', { key: entity.id, className: 'dshm-graph-tools', onSubmit: event => {
+        event.preventDefault()
+        const data = new FormData(event.currentTarget)
+        void act('renameEntity', { entityId: entity.id, name: String(data.get('name')), aliases: String(data.get('aliases')).split(',').map(value => value.trim()).filter(Boolean) })
+      } },
+        h('input', { name: 'name', defaultValue: entity.name, 'aria-label': t('entityName') }),
+        h('input', { name: 'aliases', defaultValue: (entity.aliases || []).join(', '), placeholder: t('entityAliases'), 'aria-label': t('entityAliases') }),
+        h('button', { type: 'submit', className: 'dshm-btn', style: S.btn }, t('save')),
+        h('button', {
+          type: 'button',
+          className: `dshm-graph-unlink${armed === 'entity:' + entity.id ? ' is-armed' : ''}`,
+          title: deleteRefused === entity.id ? t('entityDeleteForceHint') : t('entityDelete'),
+          'aria-label': deleteRefused === entity.id ? t('entityDeleteForceHint') : t('entityDelete'),
+          onClick: async () => {
+            const key = 'entity:' + entity.id
+            if (armed !== key) { setArmed(key); return }
+            try {
+              await call('deleteEntity', { libraryId, entityId: entity.id, force: deleteRefused === entity.id })
+              setArmed(''); setDeleteRefused('')
+              notifyMemoryWrite('relation', libraryId)
+              if (mounted.current) await refresh()
+            } catch (failure) {
+              const message = String(failure?.message || failure)
+              if (/referenced|引用/.test(message)) setDeleteRefused(entity.id)
+              if (mounted.current) setError(message)
+            }
+          },
+        }, armed === 'entity:' + entity.id ? (deleteRefused === entity.id ? t('relationConfirm') + '!' : t('relationConfirm')) : t('entityDelete')))
       return h('div', null,
         error ? h('div', { className: 'dshm-toast', role: 'status' }, error) : null,
         h('div', { className: 'dshm-graph-tools' },
@@ -2107,6 +2588,9 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           h('div', { className: 'dshm-graph-list' }, edges.length ? edges.map(edge => h('div', { key: edge.from + edge.to + edge.kind, className: 'dshm-graph-edge' },
             h('div', null, h('button', { type: 'button', className: 'dshm-graph-node', onClick: () => setFocus(edge.from) }, titles.get(edge.from) || edge.from),
               ' → ', h('button', { type: 'button', className: 'dshm-graph-node', onClick: () => setFocus(edge.to) }, titles.get(edge.to) || edge.to),
+              // 私有自动关联（§5.7）：source:'auto' 的边来自算法/实体枢纽，不是用户手连。
+              // 只多一个可点读的小 Tag；kind/confidence/note 与移除按钮保持原样。
+              edge.source === 'auto' ? h('span', { style: { margin: '0 5px', verticalAlign: 'middle' } }, h(Tag, { tone: 'info' }, t('graphAutoLink'))) : null,
               h('small', null, edge.kind + ' · ' + Math.round(edge.confidence * 100) + '% · ' + edge.note)),
             h('button', {
               type: 'button',
@@ -2130,14 +2614,20 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           h('select', { value: entityKind, title: t('entityKind'), onChange: event => setEntityKind(event.target.value) }, ['person', 'place', 'thing', 'org'].map(value => h('option', { key: value, value }, value))),
           h(Button, { disabled: !entityName.trim(), onClick: () => act('createEntity', { name: entityName, kind: entityKind }) }, t('entityNew'))),
         h(RelationshipPanel, { call, libraryId, entities, files, t }),
-        entities.map(entity => h('form', { key: entity.id, className: 'dshm-graph-tools', onSubmit: event => {
-          event.preventDefault()
-          const data = new FormData(event.currentTarget)
-          void act('renameEntity', { entityId: entity.id, name: String(data.get('name')), aliases: String(data.get('aliases')).split(',').map(value => value.trim()).filter(Boolean) })
-        } },
-          h('input', { name: 'name', defaultValue: entity.name, 'aria-label': t('entityName') }),
-          h('input', { name: 'aliases', defaultValue: (entity.aliases || []).join(', '), placeholder: t('entityAliases'), 'aria-label': t('entityAliases') }),
-          h('button', { type: 'submit', className: 'dshm-btn', style: S.btn }, t('save')))))
+        entities.length === 0 ? h(Empty, null, t('entityEmpty')) : null,
+        // 孤立分组（§6.4 包 D）：listEntities 给出 linked 派生标记。被引用的实体照常
+        // 渲染；孤立实体（linked=false，没有任何记忆 link/关系快照指着）收进折叠区，
+        // 默认收起——它们是启动 prune 还没跑到的残余，不该和正常实体平起平坐。
+        entities.filter(entity => entity.linked !== false).map(entityForm),
+        (() => {
+          const orphans = entities.filter(entity => entity.linked === false)
+          if (!orphans.length) return null
+          return h('details', { key: 'dshm-orphans', className: 'dshm-graph-orphans', style: { margin: '8px 0' } },
+            h('summary', { style: { cursor: 'pointer', fontSize: 12, color: V.textDim } },
+              t('orphanEntities').replace('{n}', String(orphans.length))),
+            h('div', { style: { ...S.muted, margin: '6px 0' } }, t('orphanPruneHint')),
+            orphans.map(entityForm))
+        })())
     }
 
     function InboundToolsInput({ names, onChange }) {
@@ -2166,9 +2656,13 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         item.attachmentCount > 1 ? h('span', { className: 'dshm-wall-cover-count' }, '▧ ' + item.attachmentCount) : null)
     }
 
-    function MemoryWallPanel({ call, libraries, revision, stamp, onOpen, t, indexed = null }) {
+    function MemoryWallPanel({ call, libraries, revision, stamp, onOpen, t, indexed = null, focus = null, onNotice = null, initialLibraryId = '' }) {
+      // 成功提示走宿主面板的 notice 通道（spec §6.2）：失败仍走本面板的 error 通道，
+      // 同一动作只走一条。onNotice 缺省时静默（面板也可能在无 notice 通道的宿主里用）。
+      const notice = (message) => { if (typeof onNotice === 'function' && message) onNotice(message) }
       const [data, setData] = React.useState({ items: [], total: 0, errors: [] })
-      const [libraryId, setLibraryId] = React.useState('')
+      const [libraryId, setLibraryId] = React.useState(initialLibraryId || '')
+      const [multiBlocked, setMultiBlocked] = React.useState(false)
       const [view, setView] = React.useState('memories')
       const [graphLib, setGraphLib] = React.useState('')
       const [pool, setPool] = React.useState('active')
@@ -2176,21 +2670,66 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       const [query, setQuery] = React.useState('')
       const [error, setError] = React.useState('')
       const [version, setVersion] = React.useState(0)
+      // 组分类：私有 / 全局两块，默认私有、私有靠前。全局条目只读，所以多选只在私有块。
+      const [scope, setScope] = React.useState('private')
+      const [multi, setMulti] = React.useState(false)
+      const [selectedIds, setSelectedIds] = React.useState(() => new Set())
+      const [wallBusy, setWallBusy] = React.useState(false)
+      const [deleteArmedMulti, setDeleteArmedMulti] = React.useState(false)
       // Opens in place instead of jumping to the browser: one card, one request, and
       // the wall stays where the reader left it. `null` means the drawer is closed.
       const [detail, setDetail] = React.useState(null)
       const [deleteArmed, setDeleteArmed] = React.useState(false)
       const reload = () => setVersion(value => value + 1)
+      // 全局记忆页"查看此记忆"的落点：带着 id 进来，定位到对应块并直接开抽屉。
+      React.useEffect(() => {
+        if (!focus?.id) return
+        setMulti(false)
+        setSelectedIds(new Set())
+        setScope(focus.libraryId ? 'private' : 'global')
+        void openDetail({ id: focus.id, libraryId: focus.libraryId || null, title: focus.title || focus.id })
+      }, [focus])
+      const firstLibraryId = libraries?.[0]?.id || ''
       React.useEffect(() => {
         let alive = true
-        void call('browseWall', { libraryId: libraryId || null, limit: 300 }).then(value => { if (alive) { setData(value); setError('') } })
-          .catch(error => { if (alive) setError(String(error.message || error)) })
+        const load = async () => {
+          try {
+            const value = await call('browseWall', { libraryId: libraryId || null, limit: 300 })
+            if (!alive) return
+            setData(value)
+            setError('')
+          } catch (failure) {
+            if (!alive) return
+            const message = String(failure?.message || failure)
+            // 宿主对“全部记忆库”多库读取返回 403（browseWall 无法表达为单库授权）时，
+            // 退到第一个库并明确告知；单库 + 全局（browseWall 总会带全局）仍能出数据，
+            // 不再整页空。用户可手动切换库；多库选项保留为禁用。
+            if (!libraryId && firstLibraryId && /forbidden|403/i.test(message)) {
+              try {
+                const value = await call('browseWall', { libraryId: firstLibraryId, limit: 300 })
+                if (!alive) return
+                setData(value)
+                setError('')
+                setMultiBlocked(true)
+                setLibraryId(firstLibraryId)
+                return
+              } catch (fallbackFailure) {
+                if (alive) setError(String(fallbackFailure?.message || fallbackFailure))
+                return
+              }
+            }
+            setError(message)
+          }
+        }
+        void load()
         return () => { alive = false }
-      }, [call, libraryId, revision, stamp, version])
+      }, [call, libraryId, revision, stamp, version, firstLibraryId])
       React.useEffect(() => {
-        if (graphLib) return
-        const first = libraryId || libraries[0]?.id || ''
+        if (graphLib && libraries.some((lib) => lib.id === graphLib)) return
+        const selected = libraryId && libraries.some((lib) => lib.id === libraryId) ? libraryId : ''
+        const first = selected || libraries[0]?.id || ''
         if (first) setGraphLib(first)
+        else if (graphLib) setGraphLib('')
       }, [graphLib, libraryId, libraries])
       React.useEffect(() => {
         if (!detail) return undefined
@@ -2207,7 +2746,11 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       const poolOf = item => item.status === 'pending_review' ? 'review' : item.status === 'archived' ? 'archived'
         : ['suppressed', 'expired', 'superseded'].includes(item.status) || item.expiresAt && Date.parse(item.expiresAt) <= Date.now() ? 'inactive' : 'active'
       const items = Array.isArray(data?.items) ? data.items : []
-      const rows = items.filter(item => poolOf(item) === pool)
+      const inScope = item => scope === 'global' ? item.libraryId === null : item.libraryId !== null
+      const scoped = items.filter(inScope)
+      const rows = scoped.filter(item => poolOf(item) === pool)
+      const keyOf = item => (item.libraryId || 'global') + item.id
+      const selectedRows = visible => visible.filter(item => selectedIds.has(keyOf(item)))
       const layerMatch = (item, value) => value === 'all' || (value === 'anchor' ? item.layer === 'must_remember' && poolOf(item) === 'active' : item.layer === value)
       const text = String(query || '').toLowerCase()
       const visible = rows.filter(item => layerMatch(item, layer) && (!text || [item.title, item.preview, (item.tags || []).join(' ')].join(' ').toLowerCase().includes(text)))
@@ -2268,6 +2811,7 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           if (Number.isFinite(confidence)) patch.confidence = Math.max(0, Math.min(1, confidence))
           await call('updateMemory', { libraryId: current.item.libraryId, id: current.item.id, patch })
           await refreshDetail(current)
+          notice(t('memorySaved'))
         } catch (failure) {
           setDetail(prev => prev ? { ...prev, busy: false, error: String(failure?.message || failure) } : prev)
         }
@@ -2279,6 +2823,8 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         try {
           await call('updateMemory', { libraryId: current.item.libraryId, id: current.item.id, patch: { status } })
           await refreshDetail(current)
+          // 归档/恢复/保存是三个不同结果，同一条通知通道但各说各话。
+          notice(status === 'archived' ? t('memoryArchived') : status === 'active' ? t('memoryRestored') : t('memorySaved'))
         } catch (failure) {
           setDetail(prev => prev ? { ...prev, busy: false, error: String(failure?.message || failure) } : prev)
         }
@@ -2292,12 +2838,41 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           setDetail(null)
           setDeleteArmed(false)
           notifyMemoryWrite('memory', current.item.libraryId)
+          notice(t('memoryDeleted'))
           reload()
         } catch (failure) {
           setDetail(prev => prev ? { ...prev, busy: false, error: String(failure?.message || failure) } : prev)
         }
       }
 
+      // —— 多选批量操作（只对私有块生效；全局只读）——
+      // 逐条走既有 RPC（updateMemory patch.status / deleteMemory），循环里失败的条目
+      // 记下来一次性报错：部分成功不能说成全部成功，也不该让一条失败吞掉其余的成果。
+      const exitMulti = () => { setMulti(false); setSelectedIds(new Set()); setDeleteArmedMulti(false) }
+      const bulkApply = async (action) => {
+        const targets = selectedRows(visible).filter(item => action === 'archive'
+          ? ['active', 'inactive'].includes(poolOf(item))
+          : action === 'restore' || action === 'delete' ? item.status === 'archived' : false)
+        if (targets.length === 0) return
+        setWallBusy(true); setError('')
+        let done = 0
+        const failures = []
+        for (const item of targets) {
+          try {
+            if (action === 'delete') await call('deleteMemory', { libraryId: item.libraryId, id: item.id })
+            else await call('updateMemory', { libraryId: item.libraryId, id: item.id, patch: { status: action === 'archive' ? 'archived' : 'active' } })
+            done += 1
+          } catch (failure) { failures.push(`${item.title || item.id}: ${String(failure?.message || failure)}`) }
+        }
+        setWallBusy(false)
+        setDeleteArmedMulti(false)
+        setSelectedIds(new Set())
+        if (done > 0) { notifyMemoryWrite('memory', libraryId || null); reload() }
+        // 部分成功不说成全部成功：有失败只走 error（带 done/total 前缀），全成功才报 notice。
+        if (failures.length > 0) setError(`${done}/${targets.length} · ` + failures.slice(0, 3).join('；'))
+        else if (done > 0) notice(t('bulkDone').replace('{n}', String(done)))
+      }
+
       const shown = detail ? { ...detail.item, ...(detail.file || {}) } : null
       const detailForm = detail && detail.file && !detail.readonly
         ? h('div', { className: 'dshm-drawer-form' },
@@ -2344,9 +2919,30 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
             t('decay') + ' ' + Math.round((Number(shown.decay) || 0) * 100) + '% · ' +
             (shown.updatedAt ? String(shown.updatedAt).slice(0, 16).replace('T', ' ') : '')))
         : detail && detail.file && detail.readonly
-          ? h(React.Fragment, null,
-            h('p', { className: 'dshm-drawer-copy' }, detail.file.content || shown.preview),
-            h('p', { className: 'dshm-drawer-note' }, t('globalReadOnly')))
+          ? (() => {
+            // 全局条目只读（spec §6.7 UI）：详情抽屉里只读展示 links / absorbedFrom，
+            // 不提供编辑、不提供手动全局关联。links 移除按钮在全局页（F1 接入）。
+            const absorbed = Array.isArray(detail.file.absorbedFrom) ? detail.file.absorbedFrom : []
+            const links = Array.isArray(detail.file.links) ? detail.file.links : []
+            return h(React.Fragment, null,
+              h('p', { className: 'dshm-drawer-copy' }, detail.file.content || shown.preview),
+              absorbed.length || links.length
+                ? h('div', { className: 'dshm-drawer-note', style: { lineHeight: 1.7 } },
+                  absorbed.length
+                    ? h('div', null, h('strong', null, t('absorbSourcesTag').replace('{n}', String(absorbed.length))),
+                      h('div', { style: { marginTop: 2 } }, absorbed.slice(0, 8).join('、'),
+                        absorbed.length > 8 ? `… +${absorbed.length - 8}` : ''))
+                    : null,
+                  links.length
+                    ? h('div', { style: absorbed.length ? { marginTop: 6 } : null },
+                      h('strong', null, `${t('absorbLinksLabel')} · ${links.length}`),
+                      h('div', { style: { marginTop: 2 } }, links.slice(0, 8).map((link, index) =>
+                        h('div', { key: `${link.id || index}` }, `· ${link.kind || 'related'} → ${link.to || '?'}`)),
+                      links.length > 8 ? h('div', null, `… +${links.length - 8}`) : null))
+                    : null)
+                : null,
+              h('p', { className: 'dshm-drawer-note' }, t('globalReadOnly')))
+          })()
           : detail && detail.busy
             ? h(Empty, null, t('loading'))
             : null
@@ -2420,7 +3016,8 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           h(Button, { style: S.ghost, onClick: () => setDetail(null) }, t('close')))))
         : null
 
-      const graphLibrary = graphLib || libraryId || libraries[0]?.id || ''
+      const validLib = (id) => id && libraries.some((lib) => lib.id === id) ? id : ''
+      const graphLibrary = validLib(graphLib) || validLib(libraryId) || libraries[0]?.id || ''
       const graphFiles = React.useMemo(() => items
         .filter(item => item.libraryId === graphLibrary)
         .map(item => ({ id: item.id, title: item.title })), [items, graphLibrary])
@@ -2431,39 +3028,140 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
             h('div', { className: 'dshm-graph-tools' },
               h('select', {
                 value: graphLibrary,
-                title: t('currentLibrary'),
+                title: libraries.find((lib) => lib.id === graphLibrary)?.scopeKey || t('currentLibrary'),
                 // One library drives both views, otherwise the graph's focus list can
                 // be empty when the wall is filtered to a different library.
                 onChange: (event) => { setGraphLib(event.target.value); setLibraryId(event.target.value) },
               },
-              libraries.map(lib => h('option', { key: lib.id, value: lib.id }, lib.name || lib.id)))),
+              libraries.map(lib => h('option', { key: lib.id, value: lib.id }, libraryOptionLabel(lib, libraries))))),
             h(GraphPanel, { key: graphLibrary, call, libraryId: graphLibrary, files: graphFiles, t })))
 
+      // Category filters used to reuse the compact nav pills (2px gap, 30px high) and
+      // stacked directly on top of each other. Give every group its own segmented
+      // control, a label and breathing room so the state/layer filters are distinct.
+      const wallTabGroup = (items, current, onSelect, { label = '', className = '', marginTop = 0, extra = null } = {}) => h('div', {
+        className,
+        style: { display: 'flex', alignItems: 'center', gap: 10, flexWrap: 'wrap', margin: `${marginTop}px 0 0` },
+      },
+        label ? h('span', { style: { ...S.muted, fontSize: 11.5, minWidth: 30 } }, label) : null,
+        h('div', {
+          role: 'tablist',
+          'aria-label': label || undefined,
+          style: {
+            display: 'inline-flex', flexWrap: 'wrap', alignItems: 'stretch', gap: 4,
+            padding: 4, maxWidth: '100%', boxSizing: 'border-box',
+            border: `1px solid ${V.borderSoft}`, borderRadius: V.radius, background: V.surface,
+          },
+        }, items.map(([value, text]) => {
+          const selected = current === value
+          return h('button', {
+            key: value, type: 'button', role: 'tab', 'aria-selected': selected,
+            className: 'dshm-nav-item',
+            style: {
+              height: 34, minHeight: 34, padding: '0 14px', border: 0, borderRadius: V.radiusSm,
+              background: selected ? V.accentSoft : 'transparent',
+              color: selected ? V.accent : V.textDim,
+              fontWeight: selected ? 650 : 500, fontSize: 12.5, lineHeight: 1.2,
+              cursor: 'pointer', whiteSpace: 'nowrap',
+              transition: 'background .18s ease, color .18s ease',
+            },
+            onClick: () => onSelect(value),
+          }, text)
+        })),
+        extra)
+
+      const scopeItems = [['private', 'wallScopePrivate'], ['global', 'wallScopeGlobal']]
+        .map(([value, key]) => [value, t(key) + ' (' + items.filter(item => value === 'global' ? item.libraryId === null : item.libraryId !== null).length + ')'])
+      const poolItems = [['active', 'browseActiveTab'], ['archived', 'browseArchivedTab'], ['review', 'poolReview'], ['inactive', 'poolInactive']]
+        .map(([value, key]) => [value, t(key) + ' (' + scoped.filter(item => poolOf(item) === value).length + ')'])
+      const layerItems = ['all', 'must_remember', 'long_term', 'short_term', 'anchor']
+        .map(value => [value, (value === 'all' ? t('wallAllLayers') : enumText(t, LAYER_LABELS, value)) + ' (' + rows.filter(item => layerMatch(item, value)).length + ')'])
+      const selectedLibrary = libraries.find((lib) => lib.id === libraryId) || null
+      const librarySelect = scope === 'private' && libraries.length
+        ? h('select', {
+          value: libraryId,
+          title: selectedLibrary?.scopeKey || t('currentLibrary'),
+          'aria-label': t('currentLibrary'),
+          style: { ...S.input, flex: '0 1 220px', minWidth: 150, maxWidth: 260 },
+          onChange: (event) => {
+            const value = event.target.value
+            setLibraryId(value)
+            if (value) setMultiBlocked(false)
+          },
+        },
+        h('option', { value: '', disabled: multiBlocked }, t('allLibraries')),
+        libraries.map((lib) => h('option', { key: lib.id, value: lib.id }, libraryOptionLabel(lib, libraries))))
+        : null
+      const hasOptionControls = scope === 'private' || multiBlocked || data?.total > items.length
+      const multiToggle = scope === 'private'
+        ? h(Button, {
+          'aria-pressed': multi,
+          style: multi ? { ...S.ghost, color: V.accent, borderColor: V.accent } : S.ghost,
+          onClick: () => { if (multi) exitMulti(); else setMulti(true) },
+        }, multi ? t('wallMultiExit') : t('multiSelect'))
+        : null
+      const multiActions = multi && scope === 'private' ? (() => {
+        const chosen = selectedRows(visible)
+        const archiveN = chosen.filter(item => ['active', 'inactive'].includes(poolOf(item))).length
+        const restoreN = chosen.filter(item => item.status === 'archived').length
+        const deleteN = restoreN
+        return h(React.Fragment, null,
+          h('span', { style: S.muted }, t('wallSelected').replace('{n}', String(chosen.length))),
+          h(Button, { style: S.ghost, disabled: chosen.length === visible.length, onClick: () => setSelectedIds(new Set(visible.map(keyOf))) }, t('wallSelectAll')),
+          h(Button, { style: S.ghost, disabled: chosen.length === 0, onClick: () => setSelectedIds(new Set()) }, t('wallClearSelection')),
+          h(Button, { style: S.ghost, disabled: wallBusy || archiveN === 0, onClick: () => { void bulkApply('archive') } }, t('archive') + ` (${archiveN})`),
+          h(Button, { style: S.ghost, disabled: wallBusy || restoreN === 0, onClick: () => { void bulkApply('restore') } }, t('restore') + ` (${restoreN})`),
+          deleteArmedMulti
+            ? h(React.Fragment, null,
+              h(Button, { style: { ...S.ghost, color: V.danger, borderColor: V.danger }, disabled: wallBusy || deleteN === 0, onClick: () => { void bulkApply('delete') } }, t('confirmDelete') + ` (${deleteN})`),
+              h(Button, { style: S.ghost, disabled: wallBusy, onClick: () => setDeleteArmedMulti(false) }, t('cancelDelete')))
+            : h(Button, { style: { ...S.ghost, color: V.danger }, disabled: wallBusy || deleteN === 0, title: t('browseArchivedHint'), onClick: () => setDeleteArmedMulti(true) }, t('deleteForever') + ` (${deleteN})`))
+      })() : null
+
       return h('div', { className: 'dshm-wall' },
-        h('div', { className: 'dshm-nav-list is-row dshm-wall-views', role: 'tablist' },
-          [['memories', 'viewMemories'], ['relations', 'viewRelations']].map(([value, key]) =>
-            h('button', {
-              key: value, type: 'button', role: 'tab', 'aria-selected': view === value,
-              className: `dshm-nav-item${view === value ? ' on' : ''}`,
-              onClick: () => setView(value),
-            }, t(key)))),
+        wallTabGroup([['memories', t('viewMemories')], ['relations', t('viewRelations')]], view, setView, { className: 'dshm-wall-views' }),
         error || data.errors?.length ? h('p', { className: 'dshm-error', role: 'alert' }, error || t('wallReadError')) : null,
         view === 'relations'
           ? graphView
           : h(React.Fragment, null,
-            data?.total > items.length ? h('p', null, t('wallLimit') + ` (${items.length}/${data.total})`) : null,
-            h('div', { className: 'dshm-graph-tools' },
-              h('input', { type: 'search', value: query, placeholder: t('searchMemories'), 'aria-label': t('searchMemories'), onChange: event => setQuery(event.target.value) }),
-              h('select', { value: libraryId, title: t('currentLibrary'), onChange: event => setLibraryId(event.target.value) },
-                h('option', { value: '' }, t('allLibraries')), libraries.map(lib => h('option', { key: lib.id, value: lib.id }, lib.name || lib.id)))),
-            h('div', { className: 'dshm-nav-list is-row', role: 'tablist' }, [['active', 'browseActiveTab'], ['archived', 'browseArchivedTab'], ['review', 'poolReview'], ['inactive', 'poolInactive']].map(([value, key]) =>
-              h('button', { key: value, type: 'button', role: 'tab', 'aria-selected': pool === value, className: `dshm-nav-item${pool === value ? ' on' : ''}`, onClick: () => setPool(value) },
-                t(key) + ' (' + items.filter(item => poolOf(item) === value).length + ')'))),
-            h('div', { className: 'dshm-nav-list is-row', role: 'tablist' }, ['all', 'must_remember', 'long_term', 'short_term', 'anchor'].map(value =>
-              h('button', { key: value, type: 'button', role: 'tab', 'aria-selected': layer === value, className: `dshm-nav-item${layer === value ? ' on' : ''}`, onClick: () => setLayer(value) },
-                (value === 'all' ? t('allLibraries') : enumText(t, LAYER_LABELS, value)) + ' (' + rows.filter(item => layerMatch(item, value)).length + ')'))),
+            // 组分类：私有 / 全局（默认私有、私有靠前）。计数按各自的块算，切换即重置多选。
+            // The library selector belongs to the scope row, not the search row: it
+            // narrows the same private block the two tabs switch between.
+            wallTabGroup(scopeItems, scope, (value) => { setScope(value); exitMulti() }, { label: t('wallFilterScope'), marginTop: 10, extra: librarySelect }),
+            h('div', { className: 'dshm-graph-tools', style: { marginTop: 10, marginBottom: 0 } },
+              h('input', {
+                type: 'search',
+                style: { ...S.input, width: '100%', flex: '1 1 100%' },
+                value: query, placeholder: t('searchMemories'), 'aria-label': t('searchMemories'),
+                onChange: event => setQuery(event.target.value),
+              })),
+            hasOptionControls ? h('div', {
+              className: 'dshm-graph-tools',
+              role: multi ? 'toolbar' : undefined,
+              'aria-label': multi ? t('multiSelect') : undefined,
+              style: { marginTop: 8, marginBottom: 0 },
+            },
+              // 多选只对私有块：全局条目只读，批量操作没有意义。
+              multiToggle,
+              multiActions,
+              multiBlocked ? h('span', { style: S.muted, role: 'status' }, t('wallAllBlocked')) : null,
+              data?.total > items.length ? h('span', { style: S.muted }, t('wallLimit') + ` (${items.length}/${data.total})`) : null) : null,
+            wallTabGroup(poolItems, pool, setPool, { label: t('wallFilterStatus'), marginTop: 12 }),
+            wallTabGroup(layerItems, layer, setLayer, { label: t('wallFilterLayer'), marginTop: 10 }),
             visible.length ? h('div', { className: 'dshm-wall-grid' }, visible.map(item =>
-              h('button', { key: (item.libraryId || 'global') + item.id, type: 'button', className: 'dshm-wall-item', onClick: () => { void openDetail(item) } },
+              h('button', {
+                key: keyOf(item), type: 'button', className: 'dshm-wall-item' + (multi && selectedIds.has(keyOf(item)) ? ' is-selected' : ''),
+                style: multi && selectedIds.has(keyOf(item)) ? { outline: '2px solid ' + V.accent, outlineOffset: -2 } : undefined,
+                onClick: () => {
+                  // 多选模式下点卡片 = 勾选/取消勾选；正常模式打开抽屉。
+                  if (multi && scope === 'private') {
+                    setSelectedIds(prev => { const next = new Set(prev); if (next.has(keyOf(item))) next.delete(keyOf(item)); else next.add(keyOf(item)); return next })
+                    return
+                  }
+                  void openDetail(item)
+                },
+              },
+                multi && scope === 'private' ? h(Tag, { tone: selectedIds.has(keyOf(item)) ? 'info' : null }, selectedIds.has(keyOf(item)) ? '✓' : '□') : null,
                 h(WallCover, { item }),
                 h('div', { className: 'dshm-wall-meta' }, h('span', null, item.libraryId ? item.libraryName : t('globalMemory')), h('span', null, enumText(t, LAYER_LABELS, item.layer))),
                 h('strong', null, item.title || item.id),
@@ -2478,6 +3176,419 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         detailView)
     }
 
+    // The stored enums stay English (they are data); only the display flips with
+    // the host language.
+    const LEXICON_KIND_LABELS = { slang: 'lexiconKindSlang', meme: 'lexiconKindMeme', trigger: 'lexiconKindTrigger', term: 'lexiconKindTerm' }
+    // 公开生命周期两档：页签文案带计数占位符，数字来自 RPC 的 statusCounts。
+    const LEXICON_TAB_LABELS = { active: 'lexiconTabActive', archived: 'lexiconTabArchived' }
+    const EMPTY_LEXICON_DRAFT = { term: '', kind: 'term', meaning: '', usage: '', aliases: '', examples: '' }
+
+    // 词典页（§2.4）：公开生命周期只有 active / archived，卡片流对齐记忆墙的
+    // 交互约定（筛选/分页都在 RPC 侧完成，每页 50 条，客户端不缓存全量），但没有审核
+    // ——模型写入直接生效，用户只做编辑 / 归档 / 恢复 / 删除。归档与恢复可逆、一击
+    // 生效；删除是管理面独有的永久动作，两段确认。带 sourceMemoryId 的词条可跳回
+    // 记忆墙对应条目（wallFocus 接力棒，见 SettingsPage）。
+    function LexiconPanel({ call, libraries, t, onFocusMemory, sessionId }) {
+      const [libraryId, setLibraryId] = React.useState('')
+      const [data, setData] = React.useState(null)
+      const [status, setStatus] = React.useState('active')
+      const [kind, setKind] = React.useState('')
+      const [queryInput, setQueryInput] = React.useState('')
+      const [query, setQuery] = React.useState('')
+      const [page, setPage] = React.useState(1)
+      const [busy, setBusy] = React.useState(false)
+      const [error, setError] = React.useState('')
+      const [notice, setNotice] = React.useState('')
+      const [editingId, setEditingId] = React.useState('')
+      const [editDraft, setEditDraft] = React.useState(null)
+      const [creating, setCreating] = React.useState(false)
+      const [newDraft, setNewDraft] = React.useState(EMPTY_LEXICON_DRAFT)
+      const [multi, setMulti] = React.useState(false)
+      const [selectedIds, setSelectedIds] = React.useState(() => new Set())
+      const [deleteArmed, setDeleteArmed] = React.useState('')
+      const [armedBulk, setArmedBulk] = React.useState('')
+
+      // 宿主可能把面板与别的块并排渲染；读取状态时保持类型收窄，坏形状按空值处理，
+      // 不在渲染期抛错（设置页任何一块抛错整页都会变空白）。
+      const safeNewDraft = newDraft && typeof newDraft === 'object' ? newDraft : EMPTY_LEXICON_DRAFT
+      const safeQueryInput = typeof queryInput === 'string' ? queryInput : ''
+      const chosenIds = () => selectedIds instanceof Set ? selectedIds : new Set()
+
+      const activeLib = libraryId || libraries[0]?.id || ''
+      const emptyView = { items: [], total: 0, page: 1, pages: 1, counts: {}, statusCounts: { active: 0, archived: 0 } }
+      const load = React.useCallback(async () => {
+        if (!activeLib) { setData(emptyView); return }
+        setBusy(true)
+        try {
+          // 只取当前页、当前页签：状态页签、kind、搜索、分页全在 RPC 侧收窄，
+          // 客户端不缓存任何全量词条列表。
+          const res = await call('lexiconList', {
+            libraryId: activeLib, sessionId: sessionId || undefined, page, pageSize: 50,
+            status, kind: kind || undefined, q: query || undefined,
+          })
+          setData(res || emptyView)
+          setError('')
+        } catch (e) { setError(String(e?.message || e)) } finally { setBusy(false) }
+      }, [call, activeLib, page, status, kind, query, sessionId])
+      React.useEffect(() => { void load() }, [load])
+      React.useEffect(() => {
+        if (!error && !notice) return undefined
+        const timer = setTimeout(() => { setError(''); setNotice('') }, 2600)
+        return () => clearTimeout(timer)
+      }, [error, notice])
+      // 两段确认要能自行退场：armed 不会一直挂着；切页签/筛选/动作也会显式清掉。
+      React.useEffect(() => {
+        if (!deleteArmed && !armedBulk) return undefined
+        const timer = setTimeout(() => { setDeleteArmed(''); setArmedBulk('') }, 2500)
+        return () => clearTimeout(timer)
+      }, [deleteArmed, armedBulk])
+
+      const resetSelection = () => { setSelectedIds(new Set()); setDeleteArmed(''); setArmedBulk('') }
+      const resetTransient = () => { setEditingId(''); setEditDraft(null); setCreating(false); setMulti(false); resetSelection() }
+      const changeLibrary = (value) => { setLibraryId(value); setPage(1); resetTransient() }
+      const changeStatus = (value) => {
+        if (value === status) return
+        setStatus(value); setPage(1); setEditingId(''); setEditDraft(null); resetSelection()
+      }
+      const changeFilter = (setter) => (value) => { setter(value); setPage(1); setEditingId(''); setEditDraft(null); resetSelection() }
+      const applySearch = () => { setQuery(safeQueryInput.trim()); setPage(1); setEditingId(''); setEditDraft(null); resetSelection() }
+      const hitsTotal = (e) => {
+        const counts = e.hitCounts && typeof e.hitCounts === 'object' ? e.hitCounts : {}
+        return (Number(counts.candidate) || 0) + (Number(counts.injection) || 0) + (Number(counts.query) || 0)
+      }
+      const clipText = (value, max) => {
+        const text = String(value ?? '')
+        return text.length > max ? text.slice(0, max) + '…' : text
+      }
+      const draftOf = (e) => ({
+        meaning: e.meaning || '',
+        usage: e.usage || '',
+        aliases: (Array.isArray(e.aliases) ? e.aliases : []).join(', '),
+        examples: (Array.isArray(e.examples) ? e.examples : []).join('\n'),
+        sensitivity: e.sensitivity || 'normal',
+        strength: typeof e.strength === 'number' ? String(e.strength) : '',
+      })
+      const toggleEdit = (e) => {
+        if (editingId === e.id) { setEditingId(''); setEditDraft(null); return }
+        setCreating(false)
+        setEditingId(e.id)
+        setEditDraft(draftOf(e))
+      }
+      const splitList = (value, limit) => String(value || '').split(',').map((item) => item.trim()).filter(Boolean).slice(0, limit)
+      const splitExamples = (value) => String(value || '').split('\n').map((item) => item.trim()).filter(Boolean).slice(0, 8)
+      const strengthOf = (value) => {
+        if (String(value ?? '').trim() === '') return undefined
+        const n = Number(value)
+        return Number.isFinite(n) ? Math.max(0, Math.min(1, n)) : undefined
+      }
+      const act = async (fn) => {
+        setBusy(true)
+        try { await fn() } catch (e) { setError(String(e?.message || e)) } finally { setBusy(false) }
+      }
+      const saveEdit = () => {
+        const current = editingId
+        const draft = editDraft
+        if (!current || !draft) return
+        const patch = {
+          meaning: draft.meaning,
+          usage: draft.usage,
+          aliases: splitList(draft.aliases, 20),
+          examples: splitExamples(draft.examples),
+          sensitivity: draft.sensitivity,
+        }
+        const strength = strengthOf(draft.strength)
+        if (strength !== undefined) patch.strength = strength
+        return act(async () => {
+          await call('lexiconUpdate', { libraryId: activeLib, sessionId: sessionId || undefined, termId: current, patch })
+          setEditingId(''); setEditDraft(null); setDeleteArmed(''); setArmedBulk('')
+          notifyMemoryWrite('lexicon', activeLib)
+          setNotice(t('lexiconSaveDone'))
+          setError('')
+          await load()
+        })
+      }
+      // 归档 / 恢复（§2.4）：可逆的一击动作，不走审核、不产生 revision。
+      const setLifecycle = (e, action) => {
+        setDeleteArmed(''); setArmedBulk('')
+        return act(async () => {
+          await call(action === 'archive' ? 'lexiconArchive' : 'lexiconRestore', { libraryId: activeLib, termId: e.id })
+          notifyMemoryWrite('lexicon', activeLib)
+          setNotice(action === 'archive' ? t('lexiconArchiveDone') : t('lexiconRestoreDone'))
+          setError('')
+          await load()
+        })
+      }
+      // 删除是永久动作，只走管理面：两段确认由卡片按钮负责，这里只发 RPC。
+      const deleteTerm = (e) => {
+        setDeleteArmed(''); setArmedBulk('')
+        return act(async () => {
+          await call('lexiconDelete', { libraryId: activeLib, termId: e.id })
+          notifyMemoryWrite('lexicon', activeLib)
+          setNotice(t('lexiconDeleted').split('{n}').join('1'))
+          setError('')
+          await load()
+        })
+      }
+      const submitNew = () => {
+        const draft = safeNewDraft
+        if (!String(draft.term || '').trim() || !String(draft.meaning || '').trim()) return
+        return act(async () => {
+          await call('lexiconAdd', {
+            libraryId: activeLib,
+            sessionId: sessionId || undefined,
+            term: draft.term, kind: draft.kind, meaning: draft.meaning, usage: draft.usage,
+            aliases: splitList(draft.aliases, 20), examples: splitExamples(draft.examples),
+          })
+          setCreating(false)
+          setNewDraft({ ...EMPTY_LEXICON_DRAFT, kind: draft.kind })
+          notifyMemoryWrite('lexicon', activeLib)
+          setNotice(t('lexiconAddDone'))
+          setError('')
+          // 新词条总是 active：留在归档页签会看不见刚写入的词，切回使用中。
+          setStatus('active')
+          setPage(1)
+          await load()
+        })
+      }
+      const exitMulti = () => { setMulti(false); resetSelection() }
+      const bulkApply = (action) => {
+        const wanted = action === 'archive' ? 'active' : action === 'restore' ? 'archived' : null
+        const rows = (Array.isArray(data?.items) ? data.items : []).filter((e) => chosenIds().has(e.id) && (!wanted || (e.status || 'active') === wanted))
+        if (!rows.length) return
+        // 与记忆墙的 bulkApply 同一约定：部分成功不能说成全部成功——成功数进 notice，
+        // 失败明细进 error（带 done/total 前缀），两列分开读。
+        return act(async () => {
+          let done = 0
+          const failures = []
+          for (const row of rows) {
+            try {
+              if (action === 'delete') await call('lexiconDelete', { libraryId: activeLib, termId: row.id })
+              else await call(action === 'archive' ? 'lexiconArchive' : 'lexiconRestore', { libraryId: activeLib, termId: row.id })
+              done += 1
+            } catch (failure) { failures.push(`${row.term || row.id}: ${String(failure?.message || failure)}`) }
+          }
+          setArmedBulk(''); setDeleteArmed(''); setSelectedIds(new Set())
+          if (done > 0) {
+            notifyMemoryWrite('lexicon', activeLib)
+            await load()
+            setNotice(action === 'delete'
+              ? t('lexiconDeleted').split('{n}').join(String(done))
+              : action === 'archive'
+                ? t('lexiconArchivedCount').split('{n}').join(String(done))
+                : t('lexiconRestoredCount').split('{n}').join(String(done)))
+          }
+          if (failures.length > 0) setError(`${done}/${rows.length} · ` + failures.slice(0, 3).join('；'))
+        })
+      }
+      const toggleSelect = (id) => setSelectedIds((prev) => {
+        const next = prev instanceof Set ? new Set(prev) : new Set()
+        if (next.has(id)) next.delete(id); else next.add(id)
+        return next
+      })
+
+      const items = Array.isArray(data?.items) ? data.items : []
+      const counts = data?.counts && typeof data.counts === 'object' ? data.counts : {}
+      const statusCounts = data?.statusCounts && typeof data.statusCounts === 'object' ? data.statusCounts : { active: 0, archived: 0 }
+      // The old row reused the generic nav pills (2px gap, 30px high) and sat directly
+      // above the count tags, so the two rows read as one cramped button cluster. Keep
+      // the state switch as its own segmented control and give the counts their own
+      // line; the kind counts are real filter chips, not decoration.
+      const statusTabs = h('div', {
+        role: 'tablist',
+        'aria-label': t('lexiconStatus'),
+        style: {
+          display: 'inline-flex', flexWrap: 'wrap', alignItems: 'stretch', gap: 4,
+          padding: 4, margin: '2px 0 12px', maxWidth: '100%', boxSizing: 'border-box',
+          border: `1px solid ${V.borderSoft}`, borderRadius: V.radius, background: V.surface,
+        },
+      }, Object.entries(LEXICON_TAB_LABELS).map(([value, key]) => {
+        const selected = status === value
+        return h('button', {
+          key: value, type: 'button', role: 'tab', 'aria-selected': selected,
+          className: 'dshm-nav-item',
+          style: {
+            height: 36, minHeight: 36, padding: '0 16px', border: 0, borderRadius: V.radiusSm,
+            background: selected ? V.accentSoft : 'transparent',
+            color: selected ? V.accent : V.textDim,
+            fontWeight: selected ? 650 : 500, fontSize: 12.5, lineHeight: 1.2,
+            cursor: 'pointer', whiteSpace: 'nowrap',
+            transition: 'background .18s ease, color .18s ease, box-shadow .18s ease',
+          },
+          onClick: () => changeStatus(value),
+        }, t(key).split('{n}').join(String(statusCounts[value] ?? 0)))
+      }))
+      const countsRow = h('div', { style: { display: 'flex', flexWrap: 'wrap', alignItems: 'center', gap: 8, margin: '0 0 14px' } },
+        h('span', { style: { ...S.muted, marginRight: 2 } }, t('lexiconTotal').split('{total}').join(String(data?.total ?? 0))),
+        Object.entries(LEXICON_KIND_LABELS).map(([value, key]) => {
+          const selected = kind === value
+          const n = Number(counts[value]) || 0
+          return h('button', {
+            key: value, type: 'button',
+            'aria-pressed': selected,
+            title: `${t(key)} · ${n}`,
+            style: {
+              display: 'inline-flex', alignItems: 'center', gap: 6,
+              minHeight: 30, padding: '0 11px', borderRadius: 999,
+              border: `1px solid ${selected ? V.accent : V.borderSoft}`,
+              background: selected ? V.accentSoft : V.surfaceRaised,
+              color: selected ? V.accent : V.textDim,
+              cursor: 'pointer', fontSize: 11.5, lineHeight: 1, whiteSpace: 'nowrap',
+              transition: 'background .18s ease, border-color .18s ease, color .18s ease',
+            },
+            onClick: () => changeFilter(setKind)(selected ? '' : value),
+          }, t(key), h('b', { style: { fontWeight: 650, color: selected ? V.accent : V.text } }, String(n)))
+        }))
+      const filterRow = h('div', { className: 'dshm-graph-tools', style: { flexWrap: 'wrap', marginTop: 0 } },
+        h('input', {
+          type: 'search', style: S.input, value: safeQueryInput, placeholder: t('lexiconSearch'),
+          'aria-label': t('lexiconSearch'),
+          onChange: (e) => setQueryInput(e.target.value),
+          onKeyDown: (e) => { if (e.key === 'Enter') applySearch() },
+        }),
+        h(Button, { style: S.ghost, onClick: applySearch, disabled: busy }, t('logRefresh')),
+        h(Button, { style: S.ghost, onClick: () => { setCreating((v) => !v); setEditingId(''); setEditDraft(null); setDeleteArmed(''); setArmedBulk('') } }, t('lexiconNew')),
+        activeLib ? h(Button, { style: S.ghost, onClick: () => (multi ? exitMulti() : setMulti(true)), disabled: busy }, t('multiSelect')) : null)
+      const newForm = creating
+        ? h('div', { style: { ...S.item, display: 'block' } },
+          h('div', { style: { display: 'flex', gap: 8, flexWrap: 'wrap' } },
+            h('input', { style: { ...S.input, flex: '1 1 160px' }, value: safeNewDraft.term, placeholder: t('lexiconTerm'), 'aria-label': t('lexiconTerm'), onChange: (e) => setNewDraft({ ...safeNewDraft, term: e.target.value }) }),
+            h('select', { style: S.input, value: safeNewDraft.kind, 'aria-label': t('lexiconKind'), onChange: (e) => setNewDraft({ ...safeNewDraft, kind: e.target.value }) },
+              Object.entries(LEXICON_KIND_LABELS).map(([value, key]) => h('option', { key: value, value }, t(key))))),
+          h('textarea', { style: { ...S.textarea, minHeight: 54, marginTop: 8 }, value: safeNewDraft.meaning, placeholder: t('lexiconMeaning'), 'aria-label': t('lexiconMeaning'), onChange: (e) => setNewDraft({ ...safeNewDraft, meaning: e.target.value }) }),
+          h('input', { style: { ...S.input, marginTop: 8 }, value: safeNewDraft.usage, placeholder: t('lexiconUsage'), 'aria-label': t('lexiconUsage'), onChange: (e) => setNewDraft({ ...safeNewDraft, usage: e.target.value }) }),
+          h('input', { style: { ...S.input, marginTop: 8 }, value: safeNewDraft.aliases, placeholder: t('lexiconAliases'), 'aria-label': t('lexiconAliases'), onChange: (e) => setNewDraft({ ...safeNewDraft, aliases: e.target.value }) }),
+          h('textarea', { style: { ...S.textarea, minHeight: 54, marginTop: 8 }, value: safeNewDraft.examples, placeholder: t('lexiconExamples'), 'aria-label': t('lexiconExamples'), onChange: (e) => setNewDraft({ ...safeNewDraft, examples: e.target.value }) }),
+          h('div', { style: { display: 'flex', gap: 8, marginTop: 8 } },
+            h(Button, { primary: true, disabled: busy || !String(safeNewDraft.term || '').trim() || !String(safeNewDraft.meaning || '').trim(), onClick: () => void submitNew() }, t('lexiconCreate')),
+            h(Button, { style: S.ghost, disabled: busy, onClick: () => setCreating(false) }, t('cancelDelete'))))
+        : null
+      const editForm = (e) => {
+        const draft = editingId === e.id && editDraft && typeof editDraft === 'object' ? editDraft : null
+        if (!draft) return null
+        return h('div', { style: { marginTop: 8, borderTop: `1px solid ${V.borderSoft}`, paddingTop: 8 } },
+          h('textarea', { style: { ...S.textarea, minHeight: 54 }, value: draft.meaning, 'aria-label': t('lexiconMeaning'), onChange: (event) => setEditDraft({ ...draft, meaning: event.target.value }) }),
+          h('input', { style: { ...S.input, marginTop: 8 }, value: draft.usage, 'aria-label': t('lexiconUsage'), onChange: (event) => setEditDraft({ ...draft, usage: event.target.value }) }),
+          h('input', { style: { ...S.input, marginTop: 8 }, value: draft.aliases, 'aria-label': t('lexiconAliases'), onChange: (event) => setEditDraft({ ...draft, aliases: event.target.value }) }),
+          h('textarea', { style: { ...S.textarea, minHeight: 54, marginTop: 8 }, value: draft.examples, 'aria-label': t('lexiconExamples'), onChange: (event) => setEditDraft({ ...draft, examples: event.target.value }) }),
+          h('div', { style: { display: 'flex', gap: 8, marginTop: 8, flexWrap: 'wrap', alignItems: 'center' } },
+            h('select', { style: S.input, value: draft.sensitivity, 'aria-label': t('lexiconSensitivity'), onChange: (event) => setEditDraft({ ...draft, sensitivity: event.target.value }) },
+              h('option', { value: 'normal' }, t('lexiconNormal')),
+              h('option', { value: 'sensitive' }, t('lexiconSensitive'))),
+            h('input', { style: { ...S.input, maxWidth: 90 }, type: 'number', min: 0, max: 1, step: 0.05, value: draft.strength, 'aria-label': t('lexiconStrength'), onChange: (event) => setEditDraft({ ...draft, strength: event.target.value }) }),
+            h(Button, { primary: true, disabled: busy, onClick: () => void saveEdit() }, t('save')),
+            h(Button, { style: S.ghost, disabled: busy, onClick: () => { setEditingId(''); setEditDraft(null) } }, t('cancelDelete'))))
+      }
+      // 卡片流（§2.4）：term 是标题，meaning 是正文（≤120 字），usage/aliases 是次要行；
+      // 命中三计数与 strength 同记忆墙一样不抢标题的位置。
+      const renderCard = (e) => {
+        const editing = editingId === e.id
+        const aliases = Array.isArray(e.aliases) ? e.aliases : []
+        const armed = deleteArmed === e.id
+        const selection = chosenIds()
+        const hits = e.hitCounts && typeof e.hitCounts === 'object' ? e.hitCounts : {}
+        const hitsTitle = t('lexiconHitsDetail')
+          .split('{candidate}').join(String(Number(hits.candidate) || 0))
+          .split('{injection}').join(String(Number(hits.injection) || 0))
+          .split('{query}').join(String(Number(hits.query) || 0))
+        return h('div', {
+          key: e.id,
+          style: { ...S.item, display: 'flex', flexDirection: 'column', gap: 7, minHeight: 150, ...(multi && selection.has(e.id) ? { outline: '2px solid ' + V.accent, outlineOffset: -2 } : {}) },
+        },
+        h('div', { style: { display: 'flex', gap: 7, alignItems: 'center', flexWrap: 'wrap' } },
+          multi ? h('input', { type: 'checkbox', checked: selection.has(e.id), 'aria-label': e.term || e.id, onChange: () => toggleSelect(e.id), style: { margin: 0, accentColor: V.accent, flexShrink: 0 } }) : null,
+          h('strong', { style: { fontSize: 15, fontWeight: 650, lineHeight: 1.3, overflowWrap: 'anywhere', flex: '1 1 120px' } }, e.term || e.id),
+          h(Tag, null, enumText(t, LEXICON_KIND_LABELS, e.kind)),
+          e.sensitivity === 'sensitive' ? h(Tag, { tone: 'warn' }, t('lexiconSensitive')) : null),
+        h('p', { style: { margin: 0, fontSize: 12.5, lineHeight: 1.55, overflowWrap: 'anywhere', display: '-webkit-box', WebkitLineClamp: 3, WebkitBoxOrient: 'vertical', overflow: 'hidden' } },
+          clipText(e.meaning, 120) || '—'),
+        e.usage ? h('div', { style: { ...S.muted, overflowWrap: 'anywhere' } }, `${t('lexiconCardUsage')} · ${clipText(e.usage, 80)}`) : null,
+        aliases.length ? h('div', { style: { ...S.muted, overflowWrap: 'anywhere' } }, `${t('lexiconCardAliases')} · ${aliases.slice(0, 4).join(', ')}`) : null,
+        h('div', { style: { display: 'flex', gap: 8, alignItems: 'center', flexWrap: 'wrap', marginTop: 'auto' } },
+          h('span', { style: S.muted, title: hitsTitle }, `⌁ ${hitsTotal(e)}`),
+          h('div', { style: { display: 'flex', alignItems: 'center', gap: 6, flex: '1 1 90px', minWidth: 70 } },
+            h(Bar, { value: e.strength ?? 0, title: `${t('lexiconStrength')} ${Math.round((Number(e.strength) || 0) * 100)}%` })),
+          e.sourceMemoryId ? h(Button, {
+            style: { ...S.ghost, padding: '1px 7px', flexShrink: 0 },
+            title: t('lexiconSourceMemory'),
+            onClick: () => onFocusMemory?.({ id: e.sourceMemoryId, libraryId: activeLib, title: e.term || e.id, at: Date.now() }),
+          }, t('lexiconSourceMemory')) : null),
+        h('div', { style: { display: 'flex', gap: 6, flexWrap: 'wrap', alignItems: 'center' } },
+          h(Button, { style: { ...S.ghost, padding: '2px 9px' }, disabled: busy, onClick: () => { setDeleteArmed(''); setArmedBulk(''); toggleEdit(e) } }, editing ? t('cancelDelete') : t('lexiconEdit')),
+          // 归档 / 恢复是一击可逆动作；删除才要两段确认。
+          h(Button, { style: { ...S.ghost, padding: '2px 9px' }, disabled: busy, onClick: () => void setLifecycle(e, status === 'archived' ? 'restore' : 'archive') },
+            status === 'archived' ? t('lexiconRestore') : t('lexiconArchive')),
+          armed
+            ? h(React.Fragment, null,
+              h(Button, { style: { ...S.ghost, color: V.danger, borderColor: V.danger, padding: '2px 9px' }, disabled: busy, onClick: () => void deleteTerm(e) }, t('confirmDelete')),
+              h(Button, { style: { ...S.ghost, padding: '2px 9px' }, disabled: busy, onClick: () => setDeleteArmed('') }, t('cancelDelete')))
+            : h(Button, { style: { ...S.ghost, color: V.danger, padding: '2px 9px' }, disabled: busy, title: t('lexiconDeleteHint'), onClick: () => { setArmedBulk(''); setDeleteArmed(e.id) } }, t('lexiconDelete'))),
+        editing ? editForm(e) : null)
+      }
+      const selectedRows = items.filter((e) => chosenIds().has(e.id))
+      const multiBar = multi
+        ? (() => {
+          const action = status === 'archived' ? 'restore' : 'archive'
+          const actionLabel = action === 'archive' ? t('lexiconArchive') : t('lexiconRestore')
+          const actionCount = selectedRows.filter((e) => (e.status || 'active') === (action === 'archive' ? 'active' : 'archived')).length
+          const bulkButton = (value, label, count, danger) => {
+            const armed = armedBulk === value
+            return h(Button, {
+              style: { ...S.ghost, ...(danger ? { color: V.danger } : {}), ...(armed ? { borderColor: danger ? V.danger : V.accent } : {}) },
+              disabled: busy || count === 0,
+              title: value === 'delete' ? t('lexiconDeleteHint') : undefined,
+              onClick: () => {
+                setDeleteArmed('')
+                if (armedBulk !== value) { setArmedBulk(value); return }
+                setArmedBulk('')
+                void bulkApply(value)
+              },
+            }, (armed ? (value === 'delete' ? t('confirmDelete') : t('confirmAction')) : label) + ` (${count})`)
+          }
+          return h('div', { className: 'dshm-graph-tools', role: 'toolbar', 'aria-label': t('multiSelect') },
+            h('span', { style: S.muted }, t('wallSelected').replace('{n}', String(selectedRows.length))),
+            h(Button, { style: S.ghost, disabled: selectedRows.length === items.length, onClick: () => setSelectedIds(new Set(items.map((e) => e.id))) }, t('wallSelectAll')),
+            h(Button, { style: S.ghost, disabled: selectedRows.length === 0, onClick: () => resetSelection() }, t('wallClearSelection')),
+            // 批量归档/恢复/删除都是两段确认：第一次点只是 arm 当前动作。
+            bulkButton(action, actionLabel, actionCount, false),
+            bulkButton('delete', t('lexiconDelete'), selectedRows.length, true),
+            armedBulk ? h(Button, { style: S.ghost, disabled: busy, onClick: () => setArmedBulk('') }, t('cancelDelete')) : null,
+            h(Button, { style: S.ghost, onClick: exitMulti }, t('wallMultiExit')))
+        })()
+        : null
+      const pager = h('div', { style: { display: 'flex', gap: 8, alignItems: 'center', marginTop: 10 } },
+        h(Button, { style: S.ghost, disabled: busy || (data?.page || 1) <= 1, onClick: () => setPage(Math.max(1, (data?.page || 1) - 1)) }, t('lexiconPrev')),
+        h('span', { style: S.muted }, t('lexiconPageOf').split('{page}').join(String(data?.page || 1)).split('{pages}').join(String(data?.pages || 1))),
+        h(Button, { style: S.ghost, disabled: busy || (data?.page || 1) >= (data?.pages || 1), onClick: () => setPage((data?.page || 1) + 1) }, t('lexiconNext')),
+        busy ? h('span', { style: S.muted }, t('loading')) : null)
+
+      return h(React.Fragment, null,
+        h(Section, {
+          title: t('lexiconScope'),
+          desc: t('descLexicon'),
+          icon: GlyphStack,
+          right: h(Button, { style: S.ghost, onClick: () => { setPage(1); resetTransient(); return load() }, disabled: busy }, t('refresh')),
+        },
+        h('div', { style: S.row },
+          h('span', { style: S.label }, t('currentLibrary')),
+          h('select', {
+            style: { ...S.input, flex: 1 }, value: libraryId,
+            title: libraries.find((lib) => lib.id === activeLib)?.scopeKey || t('currentLibrary'),
+            onChange: (e) => changeLibrary(e.target.value),
+          },
+          libraries.length === 0 ? h('option', { value: '' }, t('noLibraries')) : null,
+          libraries.map((lib) => h('option', { key: lib.id, value: lib.id }, libraryOptionLabel(lib, libraries))))),
+        libraries.length === 0
+          ? h(Empty, null, t('lexiconNoLibrary'))
+          : h(React.Fragment, null, statusTabs, countsRow, filterRow, multiBar, newForm,
+            error && typeof error === 'string' ? h('div', { className: 'dshm-error', role: 'alert' }, error) : null,
+            notice && typeof notice === 'string' ? h('div', { style: { ...S.muted, marginTop: 6, color: V.accent } }, notice) : null,
+            items.length === 0
+              ? h(Empty, null, query || kind ? t('lexiconNoMatch')
+                : status === 'archived' ? t('lexiconArchivedEmpty') : t('lexiconEmpty'))
+              : h('div', { style: { display: 'grid', gridTemplateColumns: 'repeat(auto-fill, minmax(min(280px, 100%), 1fr))', gap: 10, marginTop: 10 } }, items.map(renderCard)),
+            pager)))
+    }
+
     function SettingsPage({ ctx, t, embedded, standalone = false }) {
       const PAGE = {
         overview: 0,
@@ -2490,8 +3601,14 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         prompts: 7,
         stats: 8,
         memories: 9,
+        // logs:10 之前缺失：SETTINGS_PAGES 里有 'logs' 但 PAGE 没有对应索引，
+        // 任何"跳到日志页"的入口都会错位到词典。补上，help 才能落在正确的 12。
+        logs: 10,
+        lexicon: 11,
+        help: 12,
       }
       const call = useRpc(ctx)
+      const sessionId = useCurrentSession(ctx)
       const [state, setState] = React.useState(null)
       const [prompts, setPrompts] = React.useState([])
       const [promptsLoaded, setPromptsLoaded] = React.useState(false)
@@ -2505,6 +3622,8 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       const [busy, setBusy] = React.useState(false)
       const [vectorOperation, setVectorOperation] = React.useState('')
       const [vectorError, setVectorError] = React.useState('')
+      // 全局记忆页"查看此记忆"的接力棒：带着 id 切到 MemU 记忆页，墙直接开对应抽屉。
+      const [wallFocus, setWallFocus] = React.useState(null)
       // Success messages need their own slot: reusing `error` would paint a good
       // outcome in red and make the next real failure easy to miss.
       const [notice, setNotice] = React.useState('')
@@ -2739,9 +3858,9 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       const loadReviews = React.useCallback(async () => {
         try {
           const [globalQueue, privateQueue] = await Promise.all([
-            call('listReviews', {}),
+            call('listReviews', sessionId ? { sessionId } : {}),
             browseLibId
-              ? call('listReviews', { libraryId: browseLibId }).catch(() => ({ items: [] }))
+              ? call('listReviews', { libraryId: browseLibId, sessionId: sessionId || undefined }).catch(() => ({ items: [] }))
               : Promise.resolve({ items: [] }),
           ])
           setReviews([...(privateQueue?.items || []), ...(globalQueue?.items || [])])
@@ -2848,13 +3967,13 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       React.useEffect(() => {
         if (page !== PAGE.browser || !browseLibId) return undefined
         let alive = true
-        void call('browseLibrary', { libraryId: browseLibId }).then(result => {
+        void call('browseLibrary', { libraryId: browseLibId, sessionId: sessionId || undefined }).then(result => {
           if (!alive) return
           setBrowseFiles(result.files || [])
           setBrowseSource(result.source || '')
         }).catch(error => { if (alive) setError(String(error.message || error)) })
         return () => { alive = false }
-      }, [call, page, browseLibId, state?.revision, state?.stamp])
+      }, [call, page, browseLibId, sessionId, state?.revision, state?.stamp])
       // Statistics are per library and read the whole index for the scatter, so they
       // load only when that page is open. Every settings refresh (a heartbeat heard a
       // write) re-reads them, which is what keeps the page honest.
@@ -3119,8 +4238,15 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
             payload.pinReason = 'user_explicit_note'
             payload.pinSource = 'user_explicit'
           }
-          await call('addMemory', payload)
+          const created = await call('addMemory', payload)
+          // 事实级去重：几乎相同的重写被拒。表单留着、
+          // 说明给足，否则用户看到的是"点了没反应"。
+          if (created?.deduped === true) {
+            setError(t('dedupedNotice').replace('{id}', created.existingId || '?'))
+            return
+          }
           notifyMemoryWrite('memory', browseLibId)
+          setNotice(t('memorySaved'))
           setNewMem({ title: '', content: '', layer: 'long_term', salientDate: '' })
           await openBrowser(browseLibId)
         } catch (e) { setError(String(e?.message || e)) } finally { setBrowseBusy(false) }
@@ -3132,6 +4258,7 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         try {
           await call('updateMemory', { libraryId: browseLibId, id, patch })
           notifyMemoryWrite('memory', browseLibId)
+          setNotice(t('memorySaved'))
           await openBrowser(browseLibId)
         } catch (e) { setError(String(e?.message || e)) } finally { setBrowseBusy(false) }
       }
@@ -3140,6 +4267,7 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         try {
           await call('archiveMemory', { libraryId: browseLibId, id })
           notifyMemoryWrite('memory', browseLibId)
+          setNotice(t('memoryArchived'))
           await openBrowser(browseLibId)
         } catch (e) { setError(String(e?.message || e)) } finally { setBrowseBusy(false) }
       }
@@ -3148,6 +4276,7 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         try {
           await call('updateMemory', { libraryId: browseLibId, id, patch: { status: 'active' } })
           notifyMemoryWrite('memory', browseLibId)
+          setNotice(t('memoryRestored'))
           await openBrowser(browseLibId)
         } catch (e) { setError(String(e?.message || e)) } finally { setBrowseBusy(false) }
       }
@@ -3157,6 +4286,7 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         try {
           await call('deleteMemory', { libraryId: browseLibId, id })
           notifyMemoryWrite('memory', browseLibId)
+          setNotice(t('memoryDeleted'))
           setDeleteArmed('')
           await openBrowser(browseLibId)
         } catch (e) { setError(String(e?.message || e)) } finally { setBrowseBusy(false) }
@@ -3169,6 +4299,7 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
             action,
             resolution: reviewDrafts[item.id]?.resolution || 'replace',
             reason: reviewDrafts[item.id]?.reason || '',
+            sessionId: sessionId || undefined,
             ...(item.libraryId ? { libraryId: item.libraryId } : {}),
           })
           notifyMemoryWrite('review', item.libraryId || null)
@@ -3178,32 +4309,63 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           if (item.libraryId && browseLibId === item.libraryId) await openBrowser(item.libraryId)
         } catch (e) { setError(String(e?.message || e)) } finally { setBusy(false) }
       }
-      const exportLibraryNow = async (includeAttachments = false) => {
-        if (!browseLibId) return
+      // 撤销集合合并（spec §4.11 undo-absorb / §6.7 UI）：全局元数据动作，不带
+      // libraryId；两段确认由 actionLabel/confirmAction 承担。成功后刷新全局列表。
+      const undoAbsorb = async (id) => {
+        if (!confirmAction('undo-absorb:' + id)) return
+        setBusy(true)
+        try {
+          await call('resolveReview', { id, action: 'undo-absorb', sessionId: sessionId || undefined })
+          setNotice(t('absorbUndone'))
+          const res = await call('listGlobal', {})
+          setGlobalFiles((res.files || []))
+          setGlobalLoaded(true)
+          await loadReviews()
+        } catch (e) { setError(String(e?.message || e)) } finally { setBusy(false) }
+      }
+      const removeGlobalLink = async (link) => {
+        const linkId = String(link?.id || '')
+        if (!linkId || !confirmAction('unlink:' + linkId)) return
+        setBusy(true)
+        try {
+          await call('resolveReview', { linkId, action: 'unlink', sessionId: sessionId || undefined })
+          setNotice(t('linkRemoved'))
+          const res = await call('listGlobal', {})
+          setGlobalFiles(res.files || [])
+          setGlobalLoaded(true)
+          await loadReviews()
+        } catch (e) { setError(String(e?.message || e)) } finally { setBusy(false) }
+      }
+      // 导出契约（spec §6.2）：显式对象参数——libraryId 缺省取当前浏览库，但调用点可以
+      // 传入别的 id（契约保证 payload、回退文件名、成功提示都用**传入**的 id）。
+      const exportLibraryNow = async ({ libraryId = browseLibId, includeAttachments = false } = {}) => {
+        if (!libraryId) return
         setBrowseBusy(true)
         try {
-          const data = await call('exportLibrary', { libraryId: browseLibId, includeAttachments, delivery: includeAttachments ? 'download' : undefined })
+          const data = await call('exportLibrary', { libraryId, sessionId: sessionId || undefined, includeAttachments, delivery: includeAttachments ? 'download' : undefined })
           if (data.downloadUrl) {
             const link = document.createElement('a')
             link.href = data.downloadUrl; link.download = data.filename; link.click()
-            return
+          } else {
+            const blob = data.base64
+              ? new Blob([Uint8Array.from(atob(data.base64), char => char.charCodeAt(0))], { type: 'application/zip' })
+              : new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' })
+            const url = URL.createObjectURL(blob)
+            const a = document.createElement('a')
+            a.href = url
+            a.download = data.filename || `dsh-memu-memory-${libraryId}.json`
+            a.click()
+            URL.revokeObjectURL(url)
           }
-          const blob = data.base64
-            ? new Blob([Uint8Array.from(atob(data.base64), char => char.charCodeAt(0))], { type: 'application/zip' })
-            : new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' })
-          const url = URL.createObjectURL(blob)
-          const a = document.createElement('a')
-          a.href = url
-          a.download = data.filename || `dsh-memu-memory-${browseLibId}.json`
-          a.click()
-          URL.revokeObjectURL(url)
+          setNotice(t('exportStarted').replace('{file}', data.filename || ''))
         } catch (e) { setError(String(e?.message || e)) } finally { setBrowseBusy(false) }
       }
 
       // Import reads the file in the browser and hands the text to the server: the
       // host already owns the state directory, so no path guessing is needed.
-      const importLibraryNow = () => {
-        if (!browseLibId) return
+      // 同一契约：payload 与 ZIP 上传 URL 都用**传入**的 libraryId，成功后回到该库。
+      const importLibraryNow = ({ libraryId = browseLibId } = {}) => {
+        if (!libraryId) return
         const input = document.createElement('input')
         input.type = 'file'
         input.accept = 'application/json,.json,application/zip,.zip'
@@ -3214,10 +4376,11 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           setNotice('')
           setError('')
           try {
-            const payload = { libraryId: browseLibId }
+            const payload = { libraryId, sessionId: sessionId || undefined }
             let res
             if (file.name.toLowerCase().endsWith('.zip')) {
-              const response = await fetch('/dsh-memu-memory/import/' + encodeURIComponent(browseLibId) + '.zip', {
+              const sessionQuery = sessionId ? '?sessionId=' + encodeURIComponent(sessionId) : ''
+              const response = await fetch('/dsh-memu-memory/import/' + encodeURIComponent(libraryId) + '.zip' + sessionQuery, {
                 method: 'POST', credentials: 'same-origin', body: file, headers: { 'content-type': 'application/zip' },
               })
               const result = await response.json()
@@ -3234,8 +4397,8 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
             const adjusted = c.downgraded || 0
             setNotice(`${t('importDone')}: +${res.imported || 0} / −${skipped}${adjusted ? ` · ${t('importAdjusted')}: ${adjusted}` : ''}`)
             if (res.engineWarning) setError(`${t('importEngineWarning')}: ${res.engineWarning}`)
-            notifyMemoryWrite('import', browseLibId)
-            await openBrowser(browseLibId)
+            notifyMemoryWrite('import', libraryId)
+            await openBrowser(libraryId)
             await refresh()
           } catch (e) { setError(String(e?.message || e)) } finally { setBrowseBusy(false) }
         }
@@ -3869,15 +5032,51 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
             ? h(Empty, null, t('noArchived'))
             : h('div', { style: S.list }, (state.archivedLibraries || []).map(renderArchivedItem))))
 
-      const renderGlobalItem = (f) => h('div', { key: f.id, style: S.item },
+      const renderGlobalItem = (f) => {
+        // 集合记忆（spec §6.7 UI）：absorbedFrom → 「集合记忆 · N 条来源」Tag +
+        // 「撤销合并」两段确认按钮（resolveReview action:'undo-absorb'）。links
+        // 只读展示 + 「移除」（resolveReview action:'unlink'），不提供手动全局关联。
+        const absorbed = Array.isArray(f.absorbedFrom) ? f.absorbedFrom : []
+        const links = Array.isArray(f.links) ? f.links : []
+        const titleOf = (id) => (globalFiles.find((item) => item.id === id)?.title) || id
+        return h('div', { key: f.id, style: S.item },
         h('div', { style: { display: 'flex', justifyContent: 'space-between', gap: 8 } },
           h('strong', null, f.title || f.id),
-          h('div', { style: { display: 'flex', gap: 6 } },
+          h('div', { style: { display: 'flex', gap: 6, flexShrink: 0 } },
             h(Tag, null, domainText(t, f.domain)),
-            h(Tag, null, `conf ${f.confidence ?? '?'}`))),
+            h(Tag, null, `conf ${f.confidence ?? '?'}`),
+            links.length ? h(Tag, { tone: 'info' }, t('linkCountTag').replace('{n}', String(links.length))) : null,
+            absorbed.length ? h(Tag, { tone: 'info' }, t('absorbSourcesTag').replace('{n}', String(absorbed.length))) : null,
+            // 撤销合并：两段确认（点一次变为「确认此操作？」，再点才发请求）。
+            absorbed.length
+              ? h(Button, {
+                style: S.ghost,
+                title: t('absorbUndo'),
+                disabled: busy,
+                onClick: () => { void undoAbsorb(f.id) },
+              }, actionLabel('undo-absorb:' + f.id, t('absorbUndo')))
+              : null,
+            // 查看此记忆：切到 MemU 记忆页的全局块并直接打开对应条目的抽屉。
+            h(Button, {
+              style: S.ghost,
+              title: t('viewMemory'),
+              onClick: () => { setWallFocus({ id: f.id, libraryId: null, title: f.title || f.id, at: Date.now() }); setPage(PAGE.memories) },
+            }, t('viewMemory')))),
         h('div', { style: { ...S.muted, marginTop: 4, whiteSpace: 'pre-wrap' } },
-          String(f.content || '').slice(0, 400))
+          String(f.content || '').slice(0, 400)),
+        links.length
+          ? h('div', { style: { ...S.muted, marginTop: 4 } },
+            links.slice(0, 8).map((link) => h('div', { key: link.id || (link.to + ':' + link.kind), style: { display: 'flex', gap: 6, alignItems: 'center', flexWrap: 'wrap' } },
+              h('span', null, `${link.kind || 'related'} · ${titleOf(link.to)}`),
+              h(Button, {
+                style: { ...S.ghost, padding: '1px 6px' },
+                disabled: busy,
+                onClick: () => { void removeGlobalLink(link) },
+              }, actionLabel('unlink:' + (link.id || ''), t('relationRemove'))))),
+            links.length > 8 ? h('div', null, `… +${links.length - 8}`) : null)
+          : null
       )
+      }
 
       const renderSessionChoice = (s) => h('label', {
         key: s.id,
@@ -3893,28 +5092,48 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           h('div', { style: S.muted }, `${s.cwd || '—'} · ${s.agentPreset || 'general'}`))
       )
 
-      const renderReviewItem = (r) => h('div', { key: r.id, style: S.item },
+      const renderReviewItem = (r) => {
+        // 集合吸收提案（spec §6.7 UI）：pendingAbsorb → 「集合吸收 · N 条」Tag +
+        // 来源标题列表（≤6，从 globalFiles 的 id→标题映射）；accept 恒为 replace
+        // （合并稿不能与自己的来源并存，服务端对 coexist 直接抛错），所以隐藏
+        // 复核方式选择器；保留 accept/reject，不做批量接受。
+        const absorbSources = r.pendingAbsorb && Array.isArray(r.pendingAbsorb.sourceIds) ? r.pendingAbsorb.sourceIds : []
+        const titleOf = (id) => {
+          const file = (globalFiles || []).find((item) => item.id === id)
+          return (file && (file.title || file.id)) || id
+        }
+        return h('div', { key: r.id, style: S.item },
         h('div', { style: { display: 'flex', justifyContent: 'space-between', gap: 8, alignItems: 'center' } },
           h('div', { style: { minWidth: 0 } },
             h('strong', null, r.title || r.id),
             h('div', { style: S.row },
               h(Tag, { tone: r.libraryId ? 'info' : undefined }, r.libraryId ? t('reviewScopePrivate') : (r.domain || 'unknown')),
+              r.pendingAbsorb ? h(Tag, { tone: 'info' }, t('absorbTag').replace('{n}', String(absorbSources.length + 1))) : null,
               r.reviewReason ? h(Tag, null, `${t('reviewReason')}: ${r.reviewReason}`) : null,
               typeof r.confidence === 'number' ? h(Tag, null, `conf ${r.confidence}`) : null)),
           h('div', { style: { display: 'flex', gap: 6, flexShrink: 0 } },
             h(Button, { onClick: () => resolveReview(r, 'accept'), disabled: busy, primary: true }, t('accept')),
             h(Button, { onClick: () => resolveReview(r, 'reject'), disabled: busy, style: S.ghost }, t('reject')))),
+        absorbSources.length
+          ? h('div', { style: { ...S.muted, marginTop: 4, lineHeight: 1.6 } },
+            absorbSources.slice(0, 6).map((id) => h('div', { key: id }, `· ${titleOf(id)}`)),
+            absorbSources.length > 6 ? h('div', null, `… +${absorbSources.length - 6}`) : null)
+          : null,
         h('div', { style: { ...S.muted, marginTop: 6, whiteSpace: 'pre-wrap' } }, String(r.content || '').slice(0, 800)),
-        h('div', { className: 'dshm-graph-tools' },
-          h('select', { title: t('reviewResolution'), value: reviewDrafts[r.id]?.resolution || 'replace',
-            onChange: event => setReviewDrafts(previous => ({ ...previous, [r.id]: { ...previous[r.id], resolution: event.target.value } })) },
-            h('option', { value: 'replace' }, t('reviewReplace')), h('option', { value: 'coexist' }, t('reviewCoexist'))),
-          reviewDrafts[r.id]?.resolution === 'coexist' ? h('input', { placeholder: t('reviewConditions'), value: reviewDrafts[r.id]?.reason || '',
-            onChange: event => setReviewDrafts(previous => ({ ...previous, [r.id]: { ...previous[r.id], reason: event.target.value } })) }) : null),
+        // 集合吸收的 accept 固定 replace：不渲染 coexist 选择器。
+        !r.pendingAbsorb
+          ? h('div', { className: 'dshm-graph-tools' },
+            h('select', { title: t('reviewResolution'), value: reviewDrafts[r.id]?.resolution || 'replace',
+              onChange: event => setReviewDrafts(previous => ({ ...previous, [r.id]: { ...previous[r.id], resolution: event.target.value } })) },
+              h('option', { value: 'replace' }, t('reviewReplace')), h('option', { value: 'coexist' }, t('reviewCoexist'))),
+            reviewDrafts[r.id]?.resolution === 'coexist' ? h('input', { placeholder: t('reviewConditions'), value: reviewDrafts[r.id]?.reason || '',
+              onChange: event => setReviewDrafts(previous => ({ ...previous, [r.id]: { ...previous[r.id], reason: event.target.value } })) }) : null)
+          : null,
         (r.evidence || []).length > 0
           ? h('div', { style: { ...S.muted, marginTop: 6, lineHeight: 1.6 } },
             r.evidence.map((e, i) => h('div', { key: `${r.id}-ev-${i}` }, `· ${e.sessionId}：${String(e.quote || '').slice(0, 160)}`)))
           : null)
+      }
 
       const globalBlock = h(React.Fragment, null,
         h(Section, {
@@ -3944,7 +5163,17 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           job ? h('div', { style: { ...S.muted, marginTop: 8 } },
             `${job.status}${job.step ? ` · ${job.step}` : ''}`,
             job.error ? h('div', { style: { color: V.danger } }, job.error) : null) : null
-        )
+        ),
+        // 审核模式（spec §6.1 包 A）：这是设置页的 globalBlock，不是侧栏那个只读块。
+        h(Section, { title: t('curatorReview'), desc: t('descCuratorReview') },
+          h(Field, { label: t('curatorReview') },
+            h('select', {
+              style: S.input,
+              value: settings.curatorReviewMode || 'auto',
+              onChange: (e) => setSetting('curatorReviewMode', e.target.value),
+            },
+            h('option', { value: 'auto' }, t('curatorReviewAuto')),
+            h('option', { value: 'review-all' }, t('curatorReviewAll')))))
       )
 
       const renderPromptItem = (p) => h('div', { key: p.key, style: S.item },
@@ -4189,15 +5418,16 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           right: h('div', { style: { display: 'flex', gap: 8, flexShrink: 0 } },
             h(Button, { onClick: () => importLibraryNow(), disabled: !browseLibId || browseBusy, style: S.ghost, title: t('importHint') }, t('importJson')),
             h(Button, { onClick: () => exportLibraryNow(), disabled: !browseLibId, style: S.ghost }, t('export')),
-            h(Button, { onClick: () => exportLibraryNow(true), disabled: !browseLibId, title: t('exportImages') }, t('exportImages')),
+            h(Button, { onClick: () => exportLibraryNow({ includeAttachments: true }), disabled: !browseLibId, title: t('exportZip') }, t('exportZip')),
             h(Button, { onClick: () => openBrowser(browseLibId), disabled: busy || !browseLibId, primary: true }, t('reload'))),
         },
         h('div', { style: S.row },
           h('span', { style: S.label }, t('currentLibrary')),
           h('select', {
             style: { ...S.input, flex: 1 }, value: browseLibId,
+            title: (state.libraries || []).find((lib) => lib.id === browseLibId)?.scopeKey || t('currentLibrary'),
             onChange: (e) => setBrowseLibId(e.target.value),
-          }, (state.libraries || []).map((l) => h('option', { key: l.id, value: l.id }, `${l.name || l.id} (${l.scopeKey || '—'})`)))),
+          }, (state.libraries || []).map((l) => h('option', { key: l.id, value: l.id }, libraryOptionLabel(l, state.libraries || []))))),
         browseSource === 'index'
           ? h('div', { style: { ...S.muted, marginTop: 6 } }, t('browserIndexOnly'))
           : null,
@@ -4342,8 +5572,9 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           h('select', {
             style: { ...S.input, flex: 1 },
             value: statsLibId,
+            title: (state.libraries || []).find((lib) => lib.id === statsLibId)?.scopeKey || t('currentLibrary'),
             onChange: (e) => setStatsLibId(e.target.value),
-          }, (state.libraries || []).map((l) => h('option', { key: l.id, value: l.id }, `${l.name || l.id} (${l.scopeKey || '—'})`)))),
+          }, (state.libraries || []).map((l) => h('option', { key: l.id, value: l.id }, libraryOptionLabel(l, state.libraries || []))))),
         !statsLibId
           ? h(Empty, null, t('statsNoLibrary'))
           : !statsData
@@ -4455,12 +5686,149 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       ]
       pageDefs.push({ label: t('pageMemories'), overline: 'MEMU', desc: t('descMemories'), icon: GlyphLayers })
       pageDefs.push({ label: t('pageLogs'), overline: 'ACTIVITY', desc: t('descLogs'), icon: GlyphText })
-      const memoriesBlock = h(MemoryWallPanel, { call, libraries: state.libraries || [], revision: state.revision, stamp: state.stamp, t,
-        indexed: localVector.vector?.indexed || null,
-        onOpen: item => {
-          if (item.libraryId) { setBrowseLibId(item.libraryId); setPage(PAGE.browser); void openBrowser(item.libraryId) }
-          else setPage(PAGE.global)
-        } })
+      pageDefs.push({ label: t('pageLexicon'), overline: 'LEXICON', desc: t('descLexicon'), icon: GlyphStack })
+      pageDefs.push({ label: t('pageHelp'), overline: 'GUIDE', desc: t('descHelp'), icon: GlyphQuestion })
+      // 首次安装引导（§6.5 包 E）：只在还没有任何库时出现——有了库，用户已经过了
+      // 这一步，卡片只会碍事。不落 localStorage：关不掉是刻意的，等第一个库建好
+      // 它自然消失；以后要记关闭状态必须走 settings，不许加本地存储。
+      const firstRunCard = (state.libraries || []).length === 0
+        ? h(Section, { title: t('firstRunTitle'), desc: t('firstRunDesc'), icon: GlyphLayers },
+          h('div', { style: { display: 'flex', gap: 8, flexWrap: 'wrap' } },
+            h(Button, { primary: true, onClick: () => setPage(PAGE.libraries) }, t('firstRunGoLibraries')),
+            h(Button, { style: S.ghost, onClick: () => setPage(PAGE.help) }, t('firstRunGuide'))))
+        : null
+      const memoriesBlock = h(React.Fragment, null, firstRunCard,
+        h(MemoryWallPanel, { call, libraries: state.libraries || [], revision: state.revision, stamp: state.stamp, t,
+          indexed: localVector.vector?.indexed || null,
+          focus: wallFocus,
+          initialLibraryId: browseLibId,
+          onNotice: setNotice,
+          onOpen: item => {
+            if (item.libraryId) { setBrowseLibId(item.libraryId); setPage(PAGE.browser); void openBrowser(item.libraryId) }
+            else setPage(PAGE.global)
+          } }))
+      // 词典页：sourceMemoryId →「来源记忆 ↗」复用全局记忆页的 wallFocus 接力棒，
+      // 跳到 MemU 记忆页并直接打开对应条目的抽屉。
+      const lexiconBlock = h(LexiconPanel, {
+        call,
+        libraries: state.libraries || [],
+        t,
+        sessionId,
+        onFocusMemory: (term) => {
+          setWallFocus({ id: term.id, libraryId: term.libraryId || null, title: term.title || term.id, at: Date.now() })
+          setPage(PAGE.memories)
+        },
+      })
+
+      // 帮助页 v2（包 G4）：快速开始 5 步 + 七个详解区 + FAQ 10 条 + 反馈入口。
+      // 所有跳转都走既有 setPage（不新增路由/RPC/localStorage），诊断复制只序列化
+      // getSettingsState 已有快照（复用上方 copyText）；正文全部走 i18n，段落/列表/
+      // 表格只由本地小助手拼装，样式复用 Section/Tag/Button 与 S 里的既有 token。
+      const helpStepTargets = [
+        { key: 'helpStep1', to: PAGE.libraries },
+        { key: 'helpStep2', to: null }, // 绑定发生在会话侧，页面里只能给文案指引
+        { key: 'helpStep3', to: PAGE.settings },
+        { key: 'helpStep4', to: PAGE.memories },
+        { key: 'helpStep5', to: PAGE.lexicon },
+      ]
+      const copyDiagnostics = async () => {
+        try {
+          const snapshot = state || await call('getSettingsState', {})
+          const engine = snapshot.engine || {}
+          const summary = JSON.stringify({
+            version: engine.currentVersion || engine.recommendedVersion || '',
+            engine: { status: engine.status, installed: engine.installed, versions: engine.versions || [] },
+            settings: snapshot.settings || {},
+            libraries: (snapshot.libraries || []).map(lib => ({ id: lib.id, name: lib.name, scopeKey: lib.scopeKey, privateCount: lib.privateCount })),
+          }, null, 2)
+          const ok = await copyText(summary)
+          setNotice(ok ? t('copied') : t('copyFailed'))
+        } catch (failure) { setError(String(failure?.message || failure)) }
+      }
+      // 帮助页的三种小节积木：段落、列表、两列表格。它们只读 i18n 文本，
+      // 不持有状态，也不做交互——帮助页是说明书，不是教程。
+      const helpPara = key => h('p', { style: { ...S.muted, margin: '0 0 6px', fontSize: 12.5, lineHeight: 1.7 } }, t(key))
+      const helpBullets = keys => h('ul', {
+        style: { margin: '0 0 6px', padding: '0 0 0 18px', fontSize: 12.5, lineHeight: 1.7 },
+      }, keys.map(key => h('li', { key, style: { marginBottom: 3 } }, t(key))))
+      const helpCell = { borderBottom: `1px solid ${V.borderSoft}`, padding: '6px 8px', textAlign: 'left', verticalAlign: 'top' }
+      const helpTable = rows => h('table', {
+        'data-help-table': 'labels',
+        style: { width: '100%', borderCollapse: 'collapse', fontSize: 12, lineHeight: 1.6 },
+      },
+      h('thead', null, h('tr', null,
+        h('th', { style: { ...helpCell, fontWeight: 600, whiteSpace: 'nowrap' } }, t('helpLabelColLabel')),
+        h('th', { style: { ...helpCell, fontWeight: 600 } }, t('helpLabelColMeaning')))),
+      h('tbody', null, rows.map(([label, meaning, rowKey]) => h('tr', { key: rowKey, 'data-help-row': rowKey },
+        h('td', { style: { ...helpCell, overflowWrap: 'anywhere', fontFamily: 'var(--dshm-mono)' } }, label),
+        h('td', { style: { ...helpCell, overflowWrap: 'anywhere' } }, meaning)))))
+      const helpLabelRows = [
+        [t('helpLabelSource'), t('helpLabelSourceMeaning'), 'helpLabelSource'],
+        [t('helpLabelLayer'), t('helpLabelLayerMeaning'), 'helpLabelLayer'],
+        [t('helpLabelOpenLoop'), t('helpLabelOpenLoopMeaning'), 'helpLabelOpenLoop'],
+        [t('helpLabelMarginalized'), t('helpLabelMarginalizedMeaning'), 'helpLabelMarginalized'],
+        [t('helpLabelDate'), t('helpLabelDateMeaning'), 'helpLabelDate'],
+        [t('helpLabelAttachment'), t('helpLabelAttachmentMeaning'), 'helpLabelAttachment'],
+        [t('helpLabelVector'), t('helpLabelVectorMeaning'), 'helpLabelVector'],
+        [t('helpLabelReviewRisk'), t('helpLabelReviewRiskMeaning'), 'helpLabelReviewRisk'],
+        [t('helpLabelLexicon'), t('helpLabelLexiconMeaning'), 'helpLabelLexicon'],
+      ]
+      const helpBlock = h(React.Fragment, null,
+        h(Section, { title: t('helpQuickStart'), desc: t('descHelp'), icon: GlyphLayers },
+          helpStepTargets.map((step, index) => h('div', { key: step.key, style: { ...S.row, alignItems: 'flex-start' } },
+            h(Tag, { tone: 'info' }, String(index + 1)),
+            h('span', { style: { flex: '1 1 320px', fontSize: 12.5, lineHeight: 1.6 } }, t(step.key)),
+            step.to !== null
+              ? h(Button, { style: { ...S.ghost, flexShrink: 0 }, onClick: () => setPage(step.to) }, t('helpGoTo'))
+              : null))),
+        h(Section, { title: t('helpScopes'), desc: t('helpScopesDesc'), icon: GlyphFolder },
+          helpPara('helpScopesChain'),
+          h('div', { style: S.row }, ['useLibrary', 'useGlobal', 'effectiveScope'].map(key => h(Tag, { key, tone: 'info' }, key))),
+          helpPara('helpScopesPrivate'),
+          helpPara('helpScopesGlobal'),
+          helpPara('helpScopesWhere'),
+          h('div', { style: { ...S.muted, margin: '8px 0 4px', fontWeight: 600 } }, t('helpScopesPitfallsTitle')),
+          helpBullets(['helpScopesPitfall1', 'helpScopesPitfall2', 'helpScopesPitfall3'])),
+        h(Section, { title: t('helpTitleCards'), icon: GlyphLayers },
+          helpPara('helpTitleCardsBody'),
+          helpPara('helpTitleCardsRecall'),
+          helpPara('helpTitleCardsRule')),
+        h(Section, { title: t('helpArchiveDelete'), icon: GlyphStack },
+          helpBullets(['helpArchiveDeleteArchive', 'helpArchiveDeleteDelete', 'helpArchiveDeleteLexicon',
+            'helpArchiveDeleteAbsorb', 'helpArchiveDeleteSessionGone'])),
+        h(Section, { title: t('helpVector'), icon: GlyphGauge },
+          helpPara('helpVectorSetup'),
+          helpPara('helpVectorCount'),
+          helpPara('helpVectorFallback'),
+          helpPara('helpVectorRebuild')),
+        h(Section, { title: t('helpAutoLink'), icon: GlyphGlobe },
+          helpPara('helpAutoLinkRule'),
+          h('div', { style: S.row }, h(Tag, { tone: 'info' }, 'source=auto'), h(Tag, null, 'memu_private_link_suggest')),
+          helpPara('helpAutoLinkHub'),
+          helpPara('helpAutoLinkWorker'),
+          helpPara('helpAutoLinkSafety')),
+        h(Section, { title: t('helpLabels'), desc: t('helpLabelsDesc'), icon: GlyphText },
+          helpTable(helpLabelRows)),
+        h(Section, { title: t('helpSidebar'), desc: t('helpSidebarDesc'), icon: GlyphSliders },
+          helpBullets(['helpSidebarAlerts', 'helpSidebarReview', 'helpSidebarRunLog',
+            'helpSidebarReviewMode', 'helpSidebarFirstRun', 'helpSidebarFallback', 'helpSidebarScope'])),
+        h(Section, { title: t('helpFaq'), icon: GlyphQuestion },
+          [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(n => h('details', { key: 'helpFaq' + n, style: { margin: '0 0 8px' } },
+            h('summary', { style: { cursor: 'pointer', fontSize: 12.5, fontWeight: 600, lineHeight: 1.5 } }, t('helpFaq' + n)),
+            h('div', { style: { ...S.muted, marginTop: 5, fontSize: 12, lineHeight: 1.7 } }, t('helpFaq' + n + 'A'))))),
+        h(Section, { title: t('helpFeedback'), icon: GlyphGlobe },
+          h('div', { style: { display: 'flex', gap: 8, flexWrap: 'wrap' } },
+            h(Button, {
+              primary: true,
+              title: t('helpOpenIssue'),
+              onClick: () => { try { window.open('https://github.com/Tkingxiao/dsh-memu-memory/issues/new', '_blank') } catch {} },
+            }, t('helpOpenIssue')),
+            h(Button, { style: S.ghost, onClick: () => { void copyDiagnostics() } }, t('helpCopyDiagnostics')),
+            h(Button, {
+              style: S.ghost,
+              title: t('helpDocs'),
+              onClick: () => { try { window.open('https://github.com/Tkingxiao/dsh-memu-memory#readme', '_blank') } catch {} },
+            }, t('helpDocs')))))
 
       const LOG_KIND_LABELS = {
         recall: t('logKindRecall'), write: t('logKindWrite'), consolidate: t('logKindConsolidate'),
@@ -4482,7 +5850,12 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
             h(Button, {
               style: S.ghost,
               onClick: async () => {
-                try { await call('clearActivityLog'); await loadLogs() } catch (error) { setLogNotice(String(error?.message || error)) }
+                try {
+                  await call('clearActivityLog')
+                  // 跨面板即时生效：侧边栏的整理提醒不用等下一个 20s 轮询。
+                  broadcastMemoryWrite('logs-cleared')
+                  await loadLogs()
+                } catch (error) { setLogNotice(String(error?.message || error)) }
               },
             }, t('logClear'))),
         },
@@ -4515,8 +5888,14 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
               h('div', { style: { display: 'flex', gap: 6, alignItems: 'center', minWidth: 0, flexWrap: 'wrap' } },
                 h(Tag, { tone: row.level === 'error' ? 'warn' : undefined }, LOG_KIND_LABELS[row.kind] || row.kind),
                 h('span', { style: S.muted }, new Date(row.at).toLocaleString()),
-                row.sessionId ? h('span', { style: S.muted }, row.sessionId.slice(-10)) : null,
-                row.libraryId ? h('span', { style: S.muted }, row.libraryId) : null),
+                // 整理/提炼日志挂上会话标题与文件夹名，裸 id 只做回退：日志页要回答
+                // "这是哪个对话、哪个库"，光靠 sessionId 后 10 位查不动。
+                row.sessionTitle
+                  ? h('span', { style: { fontSize: 12, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', maxWidth: 260 }, title: row.sessionId || '' }, row.sessionTitle)
+                  : row.sessionId ? h('span', { style: S.muted }, row.sessionId.slice(-10)) : null,
+                row.libraryName
+                  ? h(Tag, null, row.libraryName)
+                  : row.libraryId ? h('span', { style: S.muted }, row.libraryId) : null),
               h('div', { style: { display: 'flex', gap: 6, flexShrink: 0 } },
                 row.libraryId ? h(Button, {
                   style: S.ghost,
@@ -4537,7 +5916,7 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
             row.detail
               ? h('pre', { style: { ...S.muted, margin: '6px 0 0', fontSize: 11, whiteSpace: 'pre-wrap', wordBreak: 'break-all' } }, JSON.stringify(row.detail).slice(0, 600))
               : null)))))
-      const pageBlocks = [engineBlock, connectionBlock, settingsBlock, foldersBlock, librariesBlock, browserBlock, globalBlock, promptsBlock, statsBlock, memoriesBlock, logsBlock]
+      const pageBlocks = [engineBlock, connectionBlock, settingsBlock, foldersBlock, librariesBlock, browserBlock, globalBlock, promptsBlock, statsBlock, memoriesBlock, logsBlock, lexiconBlock, helpBlock]
 
       // Settings uses a left nav with a sliding indicator (the sidebar keeps its
       // top segments). The indicator is one absolutely-positioned element moved by
@@ -4598,6 +5977,65 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       return h(MemoryTab, { ctx, t, sessionId })
     }
 
+    // 整理提醒：跨会话（不按当前对话过滤），放在记忆设置卡之下、整理记录之上。
+    // 默认收起只显示最新一条（有失败优先失败），点头部展开成失败/成功两列（各最新 6 条）。
+    // 失败列带"清除失败记录"：只删 consolidate 且 ok=false 的日志行，成功流水不动。
+    function ConsolidationAlerts({ feed, t, onJump, onClear }) {
+      const [open, setOpen] = React.useState(false)
+      if (!feed) return null
+      const failures = Array.isArray(feed.failures) ? feed.failures : []
+      const successes = Array.isArray(feed.successes) ? feed.successes : []
+      if (failures.length === 0 && successes.length === 0) return null
+      const shortId = (id) => String(id || '').slice(-8)
+      const label = (row) => row.sessionTitle || shortId(row.sessionId)
+      const when = (row) => {
+        try { return new Date(row.at).toLocaleString([], { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' }) } catch { return row.at }
+      }
+      const rowEl = (row, tone) => h('div', { key: row.id, style: { minWidth: 0 } },
+        h('div', { style: { display: 'flex', gap: 6, alignItems: 'center', minWidth: 0 } },
+          h(Tag, { tone: tone === 'fail' ? 'warn' : undefined }, tone === 'fail' ? t('consolidateFailed') : t('consolidateDone')),
+          h('span', { style: { fontSize: 12, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', minWidth: 0, flex: 1 }, title: row.message }, label(row)),
+          h('span', { style: { ...S.muted, flexShrink: 0, fontSize: 11 } }, when(row)),
+          tone === 'fail' ? h(Button, {
+            style: { ...S.ghost, padding: '1px 7px', flexShrink: 0 },
+            title: t('consolidateJumpHint'),
+            onClick: () => onJump(row),
+          }, '↗') : null),
+        tone === 'fail' && row.message
+          ? h('div', { style: { ...S.muted, fontSize: 11, marginTop: 1, overflow: 'hidden', display: '-webkit-box', WebkitLineClamp: 2, WebkitBoxOrient: 'vertical' } }, row.message)
+          : null)
+      const column = (title, rows, tone) => h('div', { style: { minWidth: 0, flex: 1 } },
+        h('div', { style: { display: 'flex', gap: 6, alignItems: 'center', marginBottom: 4 } },
+          h('span', { style: { ...S.muted, fontWeight: 600, color: tone === 'fail' ? V.danger : undefined } }, title),
+          tone === 'fail' && failures.length > 0 ? h(Button, {
+            style: { ...S.ghost, padding: '1px 6px', fontSize: 11, flexShrink: 0 },
+            title: t('consolidateClearHint'),
+            onClick: onClear,
+          }, t('consolidateClear')) : null),
+        rows.length === 0
+          ? h('div', { style: S.muted }, '—')
+          : h('div', { style: { display: 'flex', flexDirection: 'column', gap: 5 } }, rows.map(row => rowEl(row, tone))))
+      const latest = failures.length > 0 ? failures[0] : successes[0]
+      const latestTone = failures.length > 0 ? 'fail' : 'ok'
+      const head = h('button', {
+        type: 'button',
+        'aria-expanded': open,
+        title: open ? t('consolidateCollapse') : t('consolidateExpand'),
+        onClick: () => setOpen(v => !v),
+        style: { display: 'flex', gap: 8, alignItems: 'center', width: '100%', padding: 0, border: 'none', background: 'transparent', cursor: 'pointer', textAlign: 'left', color: 'inherit', font: 'inherit' },
+      },
+      h('span', { style: { fontWeight: 600, fontSize: 12.5 } }, t('consolidateFeedTitle')),
+      failures.length > 0 ? h(Tag, { tone: 'warn' }, t('consolidateFailedCount').replace('{n}', String(failures.length))) : null,
+      h('span', { style: { ...S.muted, marginLeft: 'auto', fontSize: 11 } }, open ? t('consolidateCollapse') : t('consolidateExpand')))
+      return h('div', { style: { ...S.section, padding: '10px 12px', marginTop: 12 }, role: 'status' },
+        head,
+        open
+          ? h('div', { style: { display: 'flex', gap: 14, marginTop: 7 } },
+            column(t('consolidateFailedCol'), failures, 'fail'),
+            column(t('consolidateOkCol'), successes, 'ok'))
+          : h('div', { style: { marginTop: 7 } }, rowEl(latest, latestTone)))
+    }
+
     function MemoryTab({ ctx, t, sessionId }) {
       const call = useRpc(ctx)
       const sessionsState = useSessionList(ctx)
@@ -4668,14 +6106,6 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
       }, [sessionId, tabPage, sessionsLoaded, loaded, loadSidebarSessions])
 
       React.useEffect(() => { void refresh() }, [refresh])
-      // Instant path: another pane of this window wrote a memory (browser add /
-      // save / archive / import, review resolution). Measured in milliseconds,
-      // not in "reopen the tab".
-      React.useEffect(() => {
-        const onWrite = () => { void refresh() }
-        memoryWriteListeners.add(onWrite)
-        return () => { memoryWriteListeners.delete(onWrite) }
-      }, [refresh])
       // Slow path: writes we cannot hear about — the model calling
       // memu_private_remember mid-turn, a curator job, a second window. The shared
       // beat polls the cheap marker and refetches only when it moved; a hidden
@@ -4727,7 +6157,49 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
         return () => clearInterval(timer)
       }, [busy, sessionId, loadRunLog])
 
-      if (!sessionId) return h('div', { style: S.tab }, t('loading'))
+      // 整理提醒（跨会话）：挂载即拉一次，之后慢轮询；手动整理结束/进行中时靠 loadRunLog
+      // 的轮询节拍顺带刷新，不在这里叠加高频轮询。不依赖 sessionId —— 没选中对话也要显示。
+      const [feed, setFeed] = React.useState(null)
+      const loadFeed = React.useCallback(async () => {
+        try { setFeed(await call('getConsolidationFeed', { limit: 6 })) } catch {}
+      }, [call])
+      React.useEffect(() => {
+        void loadFeed()
+        // unref：浏览器里没有这个方法（可选调用跳过），Node 测试环境里别让轮询拖住进程退出。
+        const timer = setInterval(() => { void loadFeed() }, 20000)
+        try { timer.unref?.() } catch {}
+        return () => clearInterval(timer)
+      }, [loadFeed])
+      React.useEffect(() => {
+        if (!busy) return undefined
+        const timer = setInterval(() => { void loadFeed() }, 4000)
+        try { timer.unref?.() } catch {}
+        return () => clearInterval(timer)
+      }, [busy, loadFeed])
+      // Instant path: another pane wrote a memory — or the WebUI cleared the
+      // activity log (kind: 'logs-cleared'): the consolidation feed must empty
+      // the same instant instead of waiting for the next 20s poll.
+      React.useEffect(() => {
+        const onWrite = () => { void refresh(); void loadFeed() }
+        memoryWriteListeners.add(onWrite)
+        return () => { memoryWriteListeners.delete(onWrite) }
+      }, [refresh, loadFeed])
+      const jumpToLibrary = React.useCallback((row) => {
+        // 对应记忆界面 = 这条记忆所在的库；没带 libraryId（全局/旧事件）就落到总览。
+        openWebUiPage(row?.libraryId ? 'browser' : 'memories', { libraryId: row?.libraryId || null })
+      }, [])
+      const clearFailures = React.useCallback(async () => {
+        // 只删 consolidate 且 ok=false 的行；成功流水与其余日志不动。结果直接回填 feed。
+        try {
+          const result = await call('clearConsolidationFailures')
+          if (result?.cleared) setNotice(t('consolidateCleared').replace('{n}', String(result.cleared)))
+          if (result?.feed) setFeed(result.feed)
+        } catch (e) { setError(String(e?.message || e)) }
+      }, [call, t])
+      const alertBlock = h(ConsolidationAlerts, { feed, t, onJump: jumpToLibrary, onClear: clearFailures })
+
+      // （保持单行提前 return：tests/hook-order.test.mjs 以这一行锚定 hook 顺序守卫。）
+      if (!sessionId) return h('div', { style: S.tab }, h('div', { style: { ...S.tab, padding: '12px' } }, t('loading')))
       const binding = state?.binding
       const summary = sessionsState.byId?.[sessionId]
       const scopeKey = String(binding?.scopeKey || '')
@@ -4839,11 +6311,25 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
               .map((d) => h('option', { key: d, value: d }, domainText(t, d))))),
           h('div', { style: { display: 'flex', gap: 8, marginTop: 8, flexWrap: 'wrap' } },
             h(Button, { onClick: organize, disabled: busy, primary: true }, t('organize'))),
+          // 整理提醒在记忆设置卡之下、整理记录之上：跨会话的失败提醒离整理入口最近，
+          // 但不再压住页头。数据不按当前对话过滤，展开后失败/成功两列各看最新 6 条。
+          alertBlock,
           h('div', { style: { marginTop: 12 } },
-            h('div', { style: { ...S.muted, marginBottom: 4, fontWeight: 600 } }, t('runLogTitle')),
+            h('button', {
+              type: 'button',
+              title: t('runLogOpen'),
+              onClick: () => { openWebUiPage('logs') },
+              style: {
+                display: 'flex', alignItems: 'center', gap: 6, width: '100%',
+                marginBottom: 4, padding: 0, border: 0, background: 'transparent',
+                color: 'inherit', font: 'inherit', textAlign: 'left', cursor: 'pointer',
+              },
+            },
+            h('span', { style: { ...S.muted, fontWeight: 600 } }, t('runLogTitle')),
+            h('span', { style: { marginLeft: 'auto', fontSize: 11, fontWeight: 600, color: V.accent } }, t('runLogOpen') + ' ↗')),
             runLog.length === 0
               ? h('div', { style: S.muted }, t('runLogEmpty'))
-              : h('div', { style: S.list }, runLog.slice(0, 8).map(renderRunRow)))),
+              : h('div', { style: S.list }, runLog.slice(0, 5).map(renderRunRow)))),
         // 作用域放在控制卡之后：它是一组低频字段，先让用户看到记忆开关和整理入口。
         h(ContextScope, { binding, sessionId, call, t })
       )
@@ -4952,7 +6438,7 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
             }, p.label)))),
         error ? h('div', { style: { ...S.muted, padding: '8px 12px 0', color: V.danger } }, error) : null,
         notice ? h('div', { style: { ...S.muted, padding: '8px 12px 0' } }, notice) : null,
-        h('div', { style: S.tabBody }, pages[tabPage]?.node || null))
+        h('div', { className: 'dshm-tab-body', style: S.tabBody }, pages[tabPage]?.node || null))
     }
 
     // One card = one pair of switches. The card the user clicks, the binding
@@ -5219,8 +6705,11 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
           // scope was written and the folder policy checked both switches.
           h('label', { style: S.row }, h('input', { type: 'radio', name: 'memu-library', checked: pick === 'folder', onChange: () => setPick('folder') }), t('folderLibrary')),
           h('label', { style: S.row }, h('input', { type: 'radio', name: 'memu-library', checked: pick === 'existing', onChange: () => setPick('existing') }), t('chooseLibrary')),
-          pick === 'existing' ? h('select', { style: { ...S.input, marginLeft: 24 }, value: libraryId, onChange: (e) => setLibraryId(e.target.value) },
-            libraries.map((l) => h('option', { key: l.id, value: l.id }, l.name || l.id))) : null,
+          pick === 'existing' ? h('select', {
+            style: { ...S.input, marginLeft: 24 }, value: libraryId,
+            title: libraries.find((lib) => lib.id === libraryId)?.scopeKey || t('currentLibrary'),
+            onChange: (e) => setLibraryId(e.target.value),
+          }, libraries.map((l) => h('option', { key: l.id, value: l.id }, libraryOptionLabel(l, libraries)))) : null,
           h('label', { style: S.row }, h('input', { type: 'radio', name: 'memu-library', checked: pick === 'new', onChange: () => setPick('new') }), t('createLibrary')),
           pick === 'new' ? h('input', { style: { ...S.input, marginLeft: 24 }, placeholder: t('name'), value: newName, onChange: (e) => setNewName(e.target.value) }) : null)),
       h('label', { style: { ...S.row, marginTop: 12 } }, h('input', { type: 'checkbox', checked: dontShow, onChange: (e) => setDontShow(e.target.checked) }), t('rememberChoice')))
@@ -5238,7 +6727,11 @@ const SOURCE_LABELS = { user_said: 'sourceUserSaid', inferred: 'sourceInferred',
             body: JSON.stringify({ type: 'client-request', rpcId: 'standalone-' + (++sequence), method: endpoint, payload: payload || {} }),
           })
           const envelope = await response.json()
-          if (!envelope.result) throw new Error('Invalid RPC response: ' + response.status)
+          if (!envelope.result) {
+            // 服务端错误信封（如 403 forbidden）带可读 message：透传它而不是
+            // 只报 HTTP 状态码，用户才能看到「为什么」。
+            throw new Error(envelope.error?.message || ('Invalid RPC response: ' + response.status))
+          }
           return envelope.result
         } } },
       }