dsh-recall-plugin 1.4.0 → 1.5.1

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 本文件格式遵循 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，版本号遵循语义化版本。
 
+## [1.5.1] - 2026-08-18
+
+### 修复
+
+- 设置页冷启动优化：`exclude-get` 首次遍历工作区、逐文件 shell 读改为并行 + 30s 结果缓存（保存后失效），二次打开设置页不再重复付出首访代价。
+- 冷会话标题/消息文本补齐引入通用并发限制器（`runLimited`，同时最多 4 个）：首次大量冷数据时 `readSession` 整日志解压不再全量并发压垮磁盘/CPU。
+- 启动预热叠加 `sessionQuery.listSessions()` 冷元数据：冷启动时 `ctx.sessions.list()` 常为空（惰性载入），此前设置页首次打开仍要现场建 store，现开机即预热全部历史工作区。
+- Client 侧 `usage`/`status` 补数据延后到 `list` 返回后异步执行：首屏先渲染树形内容，磁盘占用与错误日志随后补齐；`list` 失败时仍尝试补这两个数据，避免整卡全空。
+
+### 变更
+
+- Client 侧 `titles` 请求的 sessionIds 去重（`Set` 去重 + 过滤空值）。
+
+## [1.5.0] - 2026-08-18
+
+### 新增
+
+- 快照管理改为**树形结构**展示：第一级工作区（文件夹名）→ 第二级会话（会话标题）→ 第三级快照（消息 ID/消息内容摘要）；工作区与会话支持展开/折叠。
+- 树形每级右侧提供删除按钮：工作区删除该工作区全部快照，会话删除该工作区内该会话全部快照，叶子单条删除；均带行内二次确认。
+- 快照叶子显示**对应消息内容摘要**（取 `user/message` 事件的 text 块），悬停显示完整内容；冷会话消息文本经新增 `manage/messages` 端点按会话分组异步补齐，避免为每条消息重复解压日志。
+- Host `manage/delete` 扩展 `scope=workspace/session` 批量删除：内存 + 磁盘全量收集匹配快照，按 root 分组进串行队列，tag 分块（每 100 个）规避 Windows 命令行上限；单个 root 失败 best-effort 继续并进入错误缓冲。
+
+### 变更
+
+- `manage list` 同 id 去重由“首次命中即丢弃”改为字段补全（root/sessionId/time/标题/消息文本），避免磁盘先占位、内存后补全时树形节点落入「未知工作区」。
+- 删除操作成功提示改为显示实际删除条数（`已删除 N 条快照`）。
+
+### 兼容性
+
+- 全部改动保持纯 JS 零构建；未改存储格式与脚本模板接口，旧索引/旧快照无需迁移。
+
 ## [1.4.0] - 2026-08-17
 
 ### 新增

package/README.md

@@ -25,9 +25,8 @@
 
 - 设置页 · 排除项快速编辑（设置 → 插件 → 撤回设置）
 
-| 设置界面 | 设置界面 |
-| --- | --- |
-| ![设置页·编辑中](docs/screenshots/settings-exclude-1.png) | ![设置页·已保存](docs/screenshots/settings-exclude-2.png) |
+ ![设置页](docs/screenshots/settings-exclude-2.png) 
+
 
 ## 功能亮点
 
@@ -38,6 +37,7 @@
 - **先看清单再动手**：点撤回先弹出将变更的文件清单（修改 / 恢复 / 删除），确认后才执行，不会稀里糊涂覆盖。
 - **磁盘友好**：快照走 git delta 压缩，是增量不是整目录拷贝；超过 100MB 的大文件自动跳过。
 - **自动瘦身**：定期 `git gc` 把 loose 对象压 pack（无损，快照一个不丢）；会话删除后其快照自动清理；构建产物可经 `exclude.txt` 全局排除（见下）。
+- **树形快照管理**：设置页「快照管理」按 **工作区 → 会话 → 快照** 三级树形展示，支持展开/折叠；每级右侧都有删除按钮，可一次清掉整个工作区或某个会话的全部快照，叶子显示该快照对应的消息内容摘要，方便定位“这条消息当时改了什么”。
 
 ## 已知限制
 
@@ -92,6 +92,7 @@ pm2 restart <你的dsh进程名>   # 若用 pm2 托管
   ```
 
   对所有项目生效（home 不可写而降级到项目内存储时，该工作区有独立的排除配置，设置页会分卡片列出）。新增排除只影响之后的快照；**回退到更早的快照时，当时尚未排除的文件仍会被恢复**（回到当时的状态，这正是回退语义）。想彻底清掉已进快照的目录，可手动删除 home 下 `dsh-recall-snapshots/` 里对应项目的哈希目录。设置页标签依赖 DSH 自带设置页（0.1.0-rc.x 均含）；极旧版本看不到该标签时，直接编辑文件等效。
+- **树形快照管理**：打开「**设置 → 插件 → 撤回设置 → 快照管理**」可看到树形列表——第一级工作区（文件夹名）、第二级会话（会话标题）、第三级快照（时间 + 消息内容摘要，悬停看完整内容）。工作区和会话节点可展开/折叠；每一级右侧都有删除按钮，删除前会二次确认。删除工作区 = 清掉该工作区全部快照；删除会话 = 清掉该工作区内该会话的全部快照；删除叶子 = 只删那一条快照。
 
 ## 工作原理
 

package/lib/client.js

@@ -74,12 +74,19 @@ window.__ModuleLoader__.load({
           '.dsh-recall-ex-chip:hover{color:var(--dsw-alias-label-primary)}',
           '.dsh-recall-ex-status{margin-right:auto;font-size:12px;line-height:20px;color:var(--dsw-alias-label-tertiary)}',
           '.dsh-recall-ex-status-error{color:var(--dsw-alias-state-error-primary)}',
-          '.dsh-recall-snap{display:flex;flex-direction:column;gap:2px;padding:4px 0;border-bottom:1px solid var(--dsw-alias-border-l1)}',
-          '.dsh-recall-snap:last-child{border-bottom:none}',
-          '.dsh-recall-snap-main{display:flex;gap:8px;align-items:baseline;font-size:12px;line-height:20px}',
-          '.dsh-recall-snap-meta{display:flex;gap:8px;align-items:baseline;font-size:11px;line-height:18px;color:var(--dsw-alias-label-tertiary)}',
-          '.dsh-recall-snap-ws{flex:none;font-weight:600;color:var(--dsw-alias-label-secondary)}',
-          '.dsh-recall-snap-confirm{display:flex;gap:8px;align-items:center;font-size:12px;line-height:20px;color:var(--dsw-alias-label-secondary)}'
+          '.dsh-recall-tree{display:flex;flex-direction:column;gap:2px;padding:4px 0}',
+          '.dsh-recall-tree-node{display:flex;flex-direction:column;gap:1px}',
+          '.dsh-recall-tree-row{display:flex;gap:6px;align-items:center;min-width:0;padding:2px 4px;border-radius:6px;cursor:default}',
+          '.dsh-recall-tree-row:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+          '.dsh-recall-tree-toggle{flex:none;width:18px;height:18px;display:inline-flex;align-items:center;justify-content:center;color:var(--dsw-alias-label-tertiary);cursor:pointer;border-radius:4px;font-size:11px;line-height:18px;user-select:none}',
+          '.dsh-recall-tree-toggle:hover{color:var(--dsw-alias-label-primary);background:var(--dsw-alias-interactive-bg-hover)}',
+          '.dsh-recall-tree-toggle-placeholder{flex:none;width:18px;height:18px}',
+          '.dsh-recall-tree-label{flex:1;min-width:0;display:flex;gap:8px;align-items:baseline;font-size:12px;line-height:20px;overflow:hidden}',
+          '.dsh-recall-tree-name{flex:none;font-weight:600;color:var(--dsw-alias-label-secondary)}',
+          '.dsh-recall-tree-title{min-width:0;color:var(--dsw-alias-label-primary);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}',
+          '.dsh-recall-tree-meta{flex:none;font-size:11px;line-height:18px;color:var(--dsw-alias-label-tertiary);white-space:nowrap}',
+          '.dsh-recall-tree-children{display:flex;flex-direction:column;gap:1px;margin-left:16px;border-left:1px solid var(--dsw-alias-border-l1);padding-left:8px}',
+          '.dsh-recall-tree-confirm{display:flex;gap:8px;align-items:center;font-size:12px;line-height:20px;color:var(--dsw-alias-label-secondary)}'
         ].join('')
         // 静态 bundle 的 ctx 可能不提供 styles 服务，降级为直接注入 <style>
         const stylesSvc = ctx.get('styles')
@@ -605,21 +612,55 @@ window.__ModuleLoader__.load({
             }).catch(() => setTitlesPending(false))
           }
 
+          // 消息文本补齐：只请求 live 拿不到文本的快照；同一会话多条消息
+          // 在 Host 端共享一次 readSession，避免为每条消息重复解压大日志。
+          function fetchMessages(list) {
+            const requests = (list || [])
+              // 只补「还没拿到结论」的快照：live 没命中时不带 messageText 字段，
+              // 冷查补齐后字段存在（字符串或 null），null 表示确实无文本不再请求。
+              .filter((it) => it.sessionId && it.id && !Object.prototype.hasOwnProperty.call(it, 'messageText'))
+              .map((it) => ({ sessionId: it.sessionId, messageId: it.id }))
+              .slice(0, 200)
+            if (!requests.length) return
+            api('manage', { op: 'messages', requests }).then((res) => {
+              const map = res && res.ok ? res.messageTexts : null
+              if (map) {
+                setItems((prev) => (prev || []).map((it) => (
+                  it.id && Object.prototype.hasOwnProperty.call(map, it.id) ? Object.assign({}, it, { messageText: map[it.id] }) : it
+                )))
+              }
+            }).catch(() => {})
+          }
+
           function refresh() {
             api('manage', { op: 'list' }).then((res) => {
               if (res && res.ok) {
                 setItems(res.items || [])
                 fetchTitles(res.items || [])
+                fetchMessages(res.items || [])
               }
-            }).catch(() => {})
-            if (sessionId) {
-              api('manage', { op: 'usage', sessionId }).then((res) => {
-                if (res && res.ok) setUsage(res.bytes || 0)
+              // 列表返回后再补 usage/status：首次冷启动时磁盘占用和错误日志
+              // 都各要一条 shell，和 list 并发会抢资源拖慢首屏；延后到列表
+              // 渲染后，用户先看到树形内容，占用再异步补上。
+              if (sessionId) {
+                api('manage', { op: 'usage', sessionId }).then((res) => {
+                  if (res && res.ok) setUsage(res.bytes || 0)
+                }).catch(() => {})
+              }
+              api('status', {}).then((res) => {
+                if (res && res.ok) setErrors(res.errors || [])
               }).catch(() => {})
-            }
-            api('status', {}).then((res) => {
-              if (res && res.ok) setErrors(res.errors || [])
-            }).catch(() => {})
+            }).catch(() => {
+              // list 失败时仍尝试补 usage/status，避免整卡全空
+              if (sessionId) {
+                api('manage', { op: 'usage', sessionId }).then((res) => {
+                  if (res && res.ok) setUsage(res.bytes || 0)
+                }).catch(() => {})
+              }
+              api('status', {}).then((res) => {
+                if (res && res.ok) setErrors(res.errors || [])
+              }).catch(() => {})
+            })
           }
 
           React.useEffect(() => { refresh() }, [sessionId])
@@ -629,7 +670,7 @@ window.__ModuleLoader__.load({
             setState({ busy: true, message: '执行中…', error: false })
             api('manage', Object.assign({ op, sessionId }, extra || {})).then((res) => {
               if (res && res.ok) {
-                setState({ busy: false, message: doneText, error: false })
+                setState({ busy: false, message: typeof res.deleted === 'number' ? '已删除 ' + res.deleted + ' 条快照' : doneText, error: false })
                 refresh()
               } else {
                 setState({ busy: false, message: (res && (res.message || res.error)) || '操作失败', error: true })
@@ -637,39 +678,145 @@ window.__ModuleLoader__.load({
             }).catch((e) => setState({ busy: false, message: String(e), error: true }))
           }
 
-          // 列表行：第一行工作区名 + 会话标题（已删除会话标灰）+ 时间 +
-          // 截断 ID；第二行删除按钮。完整 ID 仍走行 title 悬停。
-          // 删除走行内二次确认（confirmingId 记录正在确认的行）：
-          // 点「删除」先换成「确认删除？是/否」，避免误点直接清 tag。
-          const [confirmingId, setConfirmingId] = React.useState(null)
-          const rows = (items || []).slice(0, 50).map((it) => {
-            const confirming = confirmingId === it.id
-            return React.createElement('div', { className: 'dsh-recall-snap', key: it.id, title: it.id },
-              React.createElement('div', { className: 'dsh-recall-snap-main' },
-                React.createElement('span', { className: 'dsh-recall-snap-ws' }, it.workspace || '未知工作区'),
-                React.createElement('span', { className: 'dsh-recall-rel' }, it.sessionTitle || (titlesPending && it.sessionId ? '…' : '（已删除会话）')),
-                React.createElement('span', { className: 'dsh-recall-snap-meta' }, clockText(it.time) + '  ' + it.id.slice(0, 12) + '…')
+          // 树形管理：工作区 → 会话 → 快照三级。折叠状态用 Set<key> 记录，
+          // 工作区 key 用 root 路径（可能含特殊字符，但 Set 按字符串精确匹配）；
+          // 会话 key 用 sessionId；叶子无子节点。删除走行内二次确认：
+          // confirming 存 { kind, key, extra, text }，行内原地展开确认。
+          const [expanded, setExpanded] = React.useState(() => new Set())
+          const [confirming, setConfirming] = React.useState(null)
+          function toggle(key) {
+            setExpanded((prev) => {
+              const next = new Set(prev)
+              if (next.has(key)) next.delete(key)
+              else next.add(key)
+              return next
+            })
+          }
+          // 把扁平列表组装成树。同一快照只属于一个工作区/会话，root 或
+          // sessionId 缺失时归入「未知」节点，避免行凭空消失。
+          function buildTree(list) {
+            const workspaces = new Map()
+            for (const it of list || []) {
+              const rootKey = it.root || 'unknown-root'
+              if (!workspaces.has(rootKey)) workspaces.set(rootKey, { root: it.root || null, name: it.workspace || '未知工作区', sessions: new Map() })
+              const ws = workspaces.get(rootKey)
+              const sidKey = it.sessionId || 'unknown-session'
+              if (!ws.sessions.has(sidKey)) ws.sessions.set(sidKey, { root: ws.root, sessionId: it.sessionId || null, title: it.sessionTitle || null, items: [] })
+              ws.sessions.get(sidKey).items.push(it)
+            }
+            const wsList = Array.from(workspaces.values())
+            wsList.sort((a, b) => (a.name || '').localeCompare(b.name || ''))
+            for (const ws of wsList) {
+              ws.sessions = Array.from(ws.sessions.values())
+              ws.sessions.sort((a, b) => (a.title || '').localeCompare(b.title || ''))
+              for (const s of ws.sessions) s.items.sort((a, b) => (b.time || 0) - (a.time || 0))
+            }
+            return wsList
+          }
+          const tree = buildTree(items)
+          // 每个节点的删除按钮统一走 run()；workspace/session 用新端点 scope
+          // 批量删，叶子沿用原单条删除。二次确认文案按节点层级区分。
+          function confirmDelete(kind, key, extra, text) {
+            setConfirming({ kind, key, extra, text })
+          }
+          function renderConfirm(kind, key, extra, text) {
+            if (!confirming || confirming.kind !== kind || confirming.key !== key) return null
+            return React.createElement('div', { className: 'dsh-recall-tree-confirm' },
+              text,
+              React.createElement('button', {
+                type: 'button',
+                className: 'dsh-recall-ex-chip',
+                onClick: () => {
+                  const c = confirming
+                  setConfirming(null)
+                  run('delete', c.extra, '已删除')
+                }
+              }, '确认'),
+              React.createElement('button', { type: 'button', className: 'dsh-recall-ex-chip', onClick: () => setConfirming(null) }, '取消')
+            )
+          }
+          // 叶子节点：展开箭头占位 + 时间 + 消息内容摘要 + 截断 ID。
+          // 悬停 title 显示完整消息内容（优先）或完整 ID（无内容时）。
+          // 消息文本来自 Host live 事件或冷日志异步补齐；取到前/确实没有时
+          // 退化为显示 ID，避免假“加载中”占位。
+          function renderLeaf(it) {
+            const key = 'snap-' + it.id
+            const text = it.messageText
+            const title = text || it.id
+            const label = text
+              ? clockText(it.time) + '  ' + text
+              : clockText(it.time) + '  ' + it.id.slice(0, 12) + '…'
+            return React.createElement('div', { className: 'dsh-recall-tree-node', key: key },
+              React.createElement('div', { className: 'dsh-recall-tree-row', title: title },
+                React.createElement('span', { className: 'dsh-recall-tree-toggle-placeholder' }),
+                React.createElement('span', { className: 'dsh-recall-tree-label' },
+                  React.createElement('span', { className: 'dsh-recall-tree-title' }, label)
+                ),
+                React.createElement('button', {
+                  type: 'button',
+                  className: 'dsh-recall-ex-chip',
+                  title: '删除该快照（tag 与索引条目）',
+                  onClick: () => confirmDelete('snapshot', key, { messageId: it.id, root: it.root || null }, '确认删除该快照？此操作不可恢复。')
+                }, '删除')
               ),
-              confirming
-                ? React.createElement('div', { className: 'dsh-recall-snap-confirm' },
-                    '确认删除该快照？此操作不可恢复。',
-                    React.createElement('button', {
-                      type: 'button',
-                      className: 'dsh-recall-ex-chip',
-                      onClick: () => { setConfirmingId(null); run('delete', { messageId: it.id, root: it.root || null }, '已删除') }
-                    }, '确认'),
-                    React.createElement('button', { type: 'button', className: 'dsh-recall-ex-chip', onClick: () => setConfirmingId(null) }, '取消')
-                  )
-                : React.createElement('div', null,
-                    React.createElement('button', {
-                      type: 'button',
-                      className: 'dsh-recall-ex-chip',
-                      title: '删除该快照（tag 与索引条目）',
-                      onClick: () => setConfirmingId(it.id)
-                    }, '删除')
-                  )
+              renderConfirm('snapshot', key, { messageId: it.id, root: it.root || null }, '确认删除该快照？此操作不可恢复。')
             )
-          })
+          }
+          // 会话节点：折叠按钮 + 标题 + 快照数 + 删除按钮；子节点为叶子。
+          function renderSession(s) {
+            const key = 'session-' + (s.root || '') + '-' + s.sessionId
+            const open = expanded.has(key)
+            const label = s.title || (titlesPending && s.sessionId ? '…' : '（已删除会话）')
+            return React.createElement('div', { className: 'dsh-recall-tree-node', key: key },
+              React.createElement('div', { className: 'dsh-recall-tree-row' },
+                React.createElement('span', {
+                  className: 'dsh-recall-tree-toggle',
+                  onClick: () => toggle(key)
+                }, open ? '▾' : '▸'),
+                React.createElement('span', { className: 'dsh-recall-tree-label', title: s.sessionId || '' },
+                  React.createElement('span', { className: 'dsh-recall-tree-title' }, label),
+                  React.createElement('span', { className: 'dsh-recall-tree-meta' }, s.items.length + ' 条')
+                ),
+                s.sessionId ? React.createElement('button', {
+                  type: 'button',
+                  className: 'dsh-recall-ex-chip',
+                  title: '删除该会话全部快照',
+                  onClick: () => confirmDelete('session', key, { scope: 'session', sessionId: s.sessionId, root: s.root || null }, '确认删除该会话全部快照？此操作不可恢复。')
+                }, '删除') : null
+              ),
+              open ? React.createElement('div', { className: 'dsh-recall-tree-children' }, ...s.items.map(renderLeaf)) : null,
+              s.sessionId ? renderConfirm('session', key, { scope: 'session', sessionId: s.sessionId, root: s.root || null }, '确认删除该会话全部快照？此操作不可恢复。') : null
+            )
+          }
+          // 工作区节点：折叠按钮 + 文件夹名 + 会话数/快照数 + 删除按钮；
+          // 子节点为会话。叶子不展开箭头。
+          function renderWorkspace(ws) {
+            const key = 'ws-' + ws.root
+            const open = expanded.has(key)
+            const sessionCount = ws.sessions.length
+            const snapCount = ws.sessions.reduce((n, s) => n + s.items.length, 0)
+            return React.createElement('div', { className: 'dsh-recall-tree-node', key: key },
+              React.createElement('div', { className: 'dsh-recall-tree-row' },
+                React.createElement('span', {
+                  className: 'dsh-recall-tree-toggle',
+                  onClick: () => toggle(key)
+                }, open ? '▾' : '▸'),
+                React.createElement('span', { className: 'dsh-recall-tree-label', title: ws.root || '' },
+                  React.createElement('span', { className: 'dsh-recall-tree-name' }, ws.name),
+                  React.createElement('span', { className: 'dsh-recall-tree-meta' }, sessionCount + ' 会话 / ' + snapCount + ' 快照')
+                ),
+                ws.root ? React.createElement('button', {
+                  type: 'button',
+                  className: 'dsh-recall-ex-chip',
+                  title: '删除该工作区全部快照',
+                  onClick: () => confirmDelete('workspace', key, { scope: 'workspace', root: ws.root }, '确认删除该工作区全部快照？此操作不可恢复。')
+                }, '删除') : null
+              ),
+              open ? React.createElement('div', { className: 'dsh-recall-tree-children' }, ...ws.sessions.map(renderSession)) : null,
+              ws.root ? renderConfirm('workspace', key, { scope: 'workspace', root: ws.root }, '确认删除该工作区全部快照？此操作不可恢复。') : null
+            )
+          }
+          const treeNodes = tree.map(renderWorkspace)
 
           return React.createElement('div', { className: 'dsh-recall-ex-card' },
             React.createElement('div', { className: 'dsh-recall-ex-title' }, '快照管理'),
@@ -678,7 +825,7 @@ window.__ModuleLoader__.load({
                 ? '共 ' + (items ? items.length : '…') + ' 条快照。'
                 : '共 ' + (items ? items.length : '…') + ' 条快照，当前工作区快照存储占用 ' + sizeText(usage) + '。'
             ),
-            rows.length > 0 ? React.createElement('div', { className: 'dsh-recall-list' }, ...rows) : null,
+            treeNodes.length > 0 ? React.createElement('div', { className: 'dsh-recall-tree' }, ...treeNodes) : null,
             React.createElement('div', { className: 'dsh-recall-panel-actions' },
               state.message ? React.createElement('span', { className: 'dsh-recall-ex-status' + (state.error ? ' dsh-recall-ex-status-error' : '') }, state.message) : null,
               React.createElement('button', { type: 'button', className: 'dsh-recall-btn', disabled: state.busy, onClick: refresh }, '刷新'),

package/lib/index.js

@@ -51,6 +51,9 @@ export function apply(ctx, config) {
   // 也不是零成本（1 条 shell + 若干日志解压）。设置页打开、删除后刷新
   // 都会重拉，30s 缓存让二次打开即时；delete 与新快照落地时失效。
   let listCache = { at: 0, payload: null }
+  // 排除配置枚举缓存（30s）：exclude-get 首次要遍历工作区、逐文件 shell 读，
+  // 设置页反复打开时不该每次重算；exclude-set 成功写入后立即失效。
+  let excludeCache = { at: 0, payload: null }
 
   // 会话标题缓存（apply 级跨请求共享）：冷会话标题要 readSession 整日志
   // 解压 + 重放校验（大日志 10 秒级），绝不能挡列表首屏——list 只查
@@ -65,6 +68,36 @@ export function apply(ctx, config) {
     }
     return null
   }
+  // 消息文本缓存（apply 级跨请求共享）：冷会话 readSession 整日志解压很贵，
+  // 与标题同款两段式——live 秒回，冷会话由 Client 异步调 titles 端点补齐。
+  // 值为 null 表示「查过、确实没有」，同样命中缓存。
+  const messageTexts = new Map()
+  function messageTextFromEvents(events, messageId) {
+    if (!Array.isArray(events) || !messageId) return null
+    for (const e of events) {
+      if (e && e.type === 'user/message' && e.data && String(e.data.id) === String(messageId)) {
+        const blocks = Array.isArray(e.data.content) ? e.data.content : []
+        const text = blocks
+          .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
+          .map((b) => b.text)
+          .join('')
+        return text || null
+      }
+    }
+    return null
+  }
+  function liveMessageTextFast(sessionId, messageId) {
+    if (!sessionId || !messageId) return null
+    const key = String(sessionId) + '\u0000' + String(messageId)
+    if (messageTexts.has(key)) return messageTexts.get(key)
+    let text = null
+    try {
+      const live = ctx.sessions.get(sessionId)
+      if (live) text = messageTextFromEvents(live.events, messageId)
+    } catch (error) { text = null }
+    if (text !== null) messageTexts.set(key, text)
+    return text
+  }
   function liveTitleFast(sessionId) {
     if (!sessionId) return null
     if (sessionTitles.has(sessionId)) return sessionTitles.get(sessionId)
@@ -108,7 +141,9 @@ export function apply(ctx, config) {
       if (cwd) roots.add(cwd)
     }
     const byFile = new Map()
-    for (const root of roots) {
+    // 并行解析全部 root：冷启动时每个 root 首次 resolveStore 可能触发 shell
+    // 建目录/写 root.txt，串行会随工作区数量线性变慢；Promise.all 让它们并发。
+    await Promise.all(Array.from(roots).map(async (root) => {
       try {
         const store = await rt.resolveStore(root)
         if (store && !byFile.has(store.excludeFile)) byFile.set(store.excludeFile, { store, roots: [] })
@@ -116,7 +151,7 @@ export function apply(ctx, config) {
       } catch (error) {
         /* 单个根解析失败只影响它自己，不拖垮整个列表 */
       }
-    }
+    }))
     // 磁盘兜底：冷启动时会话注册表为空（惰性载入），但 home 容器目录可能
     // 早已存在（历史快照）。容器在 ⇒ 共享 exclude.txt 可编辑（哪怕从未
     // 写过、内容为空）；容器不在 ⇒ 全新安装，让设置页显示引导文案。
@@ -248,6 +283,112 @@ export function apply(ctx, config) {
     return run
   }
 
+  // 通用并发限制器：冷会话标题/消息文本补齐会 readSession 整日志解压，
+  // 首次大量冷数据时全量 Promise.all 会同时压垮磁盘/CPU。限制同时最多
+  // CONCURRENCY 个任务，剩余排队执行；这是纯内存调度，不依赖额外依赖。
+  async function runLimited(tasks, concurrency) {
+    const limit = concurrency > 0 ? concurrency : 4
+    let index = 0
+    const workers = Array.from({ length: Math.min(limit, tasks.length) }, async () => {
+      while (index < tasks.length) {
+        const task = tasks[index++]
+        await task()
+      }
+    })
+    await Promise.all(workers)
+  }
+
+  // 收集全量快照记录（内存 + 磁盘 dump 并集），供树形管理的按工作区/
+  // 会话批量删除使用。返回 Map<消息ID, {id, root, sessionId, time}>；
+  // 磁盘条目缺 root 时按 store 的 root.txt/内存映射补全（与 manage list
+  // 同一条解析链）。去重只按 id——同一消息 ID 全局唯一。
+  async function collectAllSnapshotRecords() {
+    const records = new Map()
+    function add(id, root, sessionId, time) {
+      if (!id || typeof id !== 'string') return
+      const old = records.get(id)
+      if (!old) {
+        records.set(id, {
+          id,
+          root: root || null,
+          sessionId: sessionId || null,
+          time: typeof time === 'number' ? time : 0
+        })
+        return
+      }
+      // 同一消息 ID 可能出现磁盘先占位、内存后补全的情况：用更全的
+      // root/sessionId/time 覆盖旧值，避免树形节点归到「未知」导致批量
+      // 删除按工作区/会话匹配不到。
+      if (!old.root && root) old.root = root
+      if (!old.sessionId && sessionId) old.sessionId = sessionId
+      if (!old.time && time) old.time = time
+    }
+    // 内存视图：当前会话/预热过的 store 已载入，秒回
+    for (const [id, s] of state.snapshots.entries()) {
+      if (s) add(id, s.root, s.sessionId, s.time)
+    }
+    // 磁盘全量：冷启动/非活跃工作区的快照也在这里
+    const dump = await dumpStores()
+    const hints = new Map()
+    for (const [root, st] of state.stores.entries()) {
+      if (st && st.dir) hints.set(st.dir, root)
+    }
+    for (const [dir, info] of dump) {
+      const baseRoot = info.root || hints.get(dir) || null
+      for (const e of info.entries || []) {
+        if (!e || typeof e.id !== 'string') continue
+        add(e.id, (typeof e.root === 'string' && e.root) || baseRoot, e.sessionId, e.time)
+      }
+    }
+    return records
+  }
+
+  // 按过滤条件批量删除快照（工作区/会话两个树节点共用）：先收集匹配
+  // id 并按 root 分组，再整体进串行队列——与快照/gc 互斥，避免 git 锁
+  // 竞态。每个 root 先 purge tag 再补载索引后重写 index.json，防止冷启动
+  // 时用残缺内存覆盖同 store 其余磁盘快照。
+  async function deleteSnapshotsByFilter(match, sessionId) {
+    const records = await collectAllSnapshotRecords()
+    const byRoot = new Map()
+    for (const rec of records.values()) {
+      if (!match(rec) || !rec.root) continue
+      if (!byRoot.has(rec.root)) byRoot.set(rec.root, [])
+      byRoot.get(rec.root).push(rec.id)
+    }
+    let deleted = 0
+    await enqueue(async () => {
+      for (const [root, rootIds] of byRoot) {
+        let store = state.stores.get(root)
+        if (!store) {
+          try { store = await rt.resolveStore(root) } catch (error) { store = null }
+        }
+        if (!store) continue
+        try {
+          if (state.gitExe) {
+            // tag 分块删除：win32 命令行有 32767 字符上限，整批传大量 tag 会
+            // 在长历史工作区上爆掉；与 maintenance.purgeSession 同款 100 个/块。
+            const tags = rootIds.map((id) => 'snap-' + id)
+            for (let i = 0; i < tags.length; i += 100) {
+              await rt.runShell(rt.scripts.purgeTagsScript(store, state.gitExe, tags.slice(i, i + 100)), { timeoutMs: 120000, stdoutMaxBytes: 4096 })
+            }
+          }
+          if (!state.indexLoaded.has(root)) {
+            try { await snaps.loadIndex(root, sessionId) } catch (error) { /* 载入失败照常重写，退化为旧行为 */ }
+          }
+          for (const id of rootIds) state.snapshots.delete(id)
+          await snaps.saveIndex(root, sessionId)
+          deleted += rootIds.length
+        } catch (error) {
+          // 单个 root 失败不阻断其他 root：与 maintenance.purgeSession 同款
+          // best-effort，错误进状态页可见的错误缓冲，剩余 root 继续清理。
+          rt.recordError('recall batch delete failed for ' + root + ': ' + String(error))
+        }
+      }
+      listCache.payload = null
+    })
+    return deleted
+  }
+
   const endpoints = {
     'init': async (args) => {
       if (!supported) {
@@ -322,14 +463,19 @@ export function apply(ctx, config) {
       // 设置页「撤回设置」标签的配置读取。不支持平台照常短路：Client
       // 显示不可用提示而不是空白表单，与 init 的 notice 语义对齐。
       if (!supported) return { ok: false, unsupported: true }
+      // 30s 结果缓存：首次进入要并行 resolveStore + 逐文件 shell 读，
+      // 二次打开/切标签不应重复付出这份代价；exclude-set 写入后失效。
+      if (excludeCache.payload && Date.now() - excludeCache.at < 30000) return excludeCache.payload
       const byFile = await listExcludeFiles()
-      const files = []
-      for (const [path, info] of byFile) {
+      // 并行读取各 exclude 文件内容：每个文件一条 shell，串行会放大延迟
+      const files = await Promise.all(Array.from(byFile.entries()).map(async ([path, info]) => {
         let content = ''
         try { content = await snaps.readExclude(info.store) } catch (error) { content = '' }
-        files.push({ path, home: Boolean(info.store.home), roots: info.roots, content })
-      }
-      return { ok: true, files }
+        return { path, home: Boolean(info.store.home), roots: info.roots, content }
+      }))
+      const payload = { ok: true, files }
+      excludeCache = { at: Date.now(), payload }
+      return payload
     },
 
     'exclude-set': async (args) => {
@@ -342,6 +488,8 @@ export function apply(ctx, config) {
       const info = byFile.get(path)
       if (!info) return { ok: false, code: 'UNKNOWN_PATH', message: '未知的排除文件路径' }
       await snaps.writeExclude(info.store, content)
+      // 写入后立即失效：设置页保存后刷新必须看到最新内容
+      excludeCache.payload = null
       return { ok: true }
     },
 
@@ -355,7 +503,6 @@ export function apply(ctx, config) {
         // 结果缓存（30s + 删除/新快照失效）：设置页反复打开、删除后刷新
         // 都会重拉列表，缓存让二次打开零 shell。
         if (listCache.payload && Date.now() - listCache.at < 30000) return listCache.payload
-        const seen = new Set()
         const allItems = []
 
         // 磁盘全量：一条 shell dump（dumpStores 见其注释——旧实现每目录
@@ -371,17 +518,34 @@ export function apply(ctx, config) {
         }
         // 去重只用 id（消息 ID 全局唯一）：带 root 进 key 会让同一快照
         // 因「磁盘来源 root 缺失 / 内存来源 root 齐全」出现两条重复行
+        const byId = new Map()
         function push(id, time, root, sessionId) {
-          if (!id || typeof id !== 'string' || seen.has(id)) return
-          seen.add(id)
-          allItems.push({
-            id,
-            time: typeof time === 'number' ? time : 0,
-            root: root || null,
-            workspace: root ? root.replace(/[\\/]+$/, '').split(/[\\/]/).pop() : null,
-            sessionId: sessionId || null,
-            sessionTitle: liveTitleFast(sessionId)
-          })
+          if (!id || typeof id !== 'string') return
+          const old = byId.get(id)
+          if (!old) {
+            const rec = {
+              id,
+              time: typeof time === 'number' ? time : 0,
+              root: root || null,
+              workspace: root ? root.replace(/[\\/]+$/, '').split(/[\\/]/).pop() : null,
+              sessionId: sessionId || null,
+              sessionTitle: liveTitleFast(sessionId)
+            }
+            // 消息文本只放已确认值：live 命中字符串则带，否则不设字段。
+            // 客户端据此判断「还没请求冷日志」；messages 端点补齐后字符串
+            // 或 null 都会写入，null 表示确实无文本，避免每次刷新重复请求。
+            const liveText = liveMessageTextFast(sessionId, id)
+            if (liveText) rec.messageText = liveText
+            byId.set(id, rec)
+            allItems.push(rec)
+            return
+          }
+          // 与 collectAllSnapshotRecords 同款补全：磁盘先占位、内存后补全
+          // root 时，若按「首次命中即丢弃」会让树形一级节点落进未知工作区。
+          if (!old.root && root) { old.root = root; old.workspace = root.replace(/[\\/]+$/, '').split(/[\\/]/).pop() || null }
+          if (!old.sessionId && sessionId) { old.sessionId = sessionId; old.sessionTitle = liveTitleFast(sessionId) }
+          if (!old.messageText && id) { old.messageText = liveMessageTextFast(sessionId, id) }
+          if (!old.time && time) old.time = time
         }
         for (const [dir, info] of dump) {
           const baseRoot = info.root || hints.get(dir) || null
@@ -405,10 +569,14 @@ export function apply(ctx, config) {
         // 重放校验，大日志 10 秒级——独立于列表让首屏即时。并发交给
         // sessionQuery 自带的 inspect 并发闸，这里全量并行发车。
         if (!supported) return { ok: false, unsupported: true }
-        const ids = Array.isArray(args && args.sessionIds) ? args.sessionIds.map(String).slice(0, 100) : []
+        const ids = Array.from(new Set(
+          (Array.isArray(args && args.sessionIds) ? args.sessionIds.map(String) : []).filter(Boolean)
+        )).slice(0, 100)
         const out = {}
-        await Promise.all(ids.map(async (sid) => {
-          if (!sid || out[sid] !== undefined) return
+        // 并发限 4：冷标题 readSession 是重 IO，全量并发会把首次设置页
+        // 的 shell/日志解压都挤在一起；限制后列表本身不受影响，标题渐进补齐。
+        await runLimited(ids.map((sid) => async () => {
+          if (out[sid] !== undefined) return
           let title = liveTitleFast(sid)
           if (title === null) {
             const query = ctx.get('sessionQuery')
@@ -421,9 +589,55 @@ export function apply(ctx, config) {
           }
           sessionTitles.set(sid, title)
           out[sid] = title
-        }))
+        }), 4)
         return { ok: true, titles: out }
       }
+      if (op === 'messages') {
+        // 冷会话消息文本补齐：与 titles 同款两段式，独立端点避免和标题
+        // 请求的 sessionIds/messageIds 对应关系纠缠。输入 [{sessionId, messageId}]，
+        // 缺 live 文本的消息才需要补；同一会话多个消息共享一次 readSession。
+        if (!supported) return { ok: false, unsupported: true }
+        const reqs = Array.isArray(args && args.requests) ? args.requests.slice(0, 200) : []
+        const bySession = new Map()
+        for (const r of reqs) {
+          const sid = r && r.sessionId ? String(r.sessionId) : null
+          const mid = r && r.messageId ? String(r.messageId) : null
+          if (!sid || !mid) continue
+          if (!bySession.has(sid)) bySession.set(sid, [])
+          bySession.get(sid).push(mid)
+        }
+        const texts = {}
+        await runLimited(Array.from(bySession.entries()).map(([sid, mids]) => async () => {
+          // 该会话所有消息都已缓存（含 null）时，不必 readSession 冷读
+          const allCached = mids.every((mid) => messageTexts.has(String(sid) + '\u0000' + String(mid)))
+          let log = null
+          if (!allCached) {
+            const query = ctx.get('sessionQuery')
+            if (query && typeof query.readSession === 'function') {
+              try {
+                log = await query.readSession(sid)
+              } catch (error) { log = null }
+            }
+          }
+          for (const mid of mids) {
+            const key = String(sid) + '\u0000' + String(mid)
+            // 缓存命中（含 null）直接复用，避免已确认无文本的消息反复冷读
+            if (messageTexts.has(key)) {
+              texts[mid] = messageTexts.get(key)
+              continue
+            }
+            let text = liveMessageTextFast(sid, mid)
+            if (text === null && log && Array.isArray(log.events)) {
+              text = messageTextFromEvents(log.events, mid)
+            }
+            // 与 sessionTitles 同款缓存策略：null 也缓存，避免冷会话反复
+            // readSession 查同一个查不到文本的消息。
+            messageTexts.set(key, text)
+            texts[mid] = text
+          }
+        }), 4)
+        return { ok: true, messageTexts: texts }
+      }
       if (op === 'usage') {
         const root = await rt.resolveRoot(sessionId)
         if (!root) return { ok: false, code: 'NO_ROOT', message: '无法解析当前工作区' }
@@ -434,25 +648,46 @@ export function apply(ctx, config) {
         return { ok: true, bytes }
       }
       if (op === 'delete') {
+        // 统一删除入口：scope=workspace 删除整个工作区全部快照；
+        // scope=session 删除某会话全部快照；scope=snapshot（缺省）单条删除。
+        // 树形管理每级右侧都有删除按钮，三种粒度共用此端点。
+        const scope = args && args.scope ? String(args.scope) : 'snapshot'
+        const root = args && args.root ? String(args.root) : null
+        const targetSessionId = args && args.sessionId ? String(args.sessionId) : null
         const id = args && args.messageId ? String(args.messageId) : ''
+        if (scope === 'workspace') {
+          if (!root) return { ok: false, code: 'NO_ROOT', message: '缺少工作区路径' }
+          const deleted = await deleteSnapshotsByFilter((rec) => rec.root === root, sessionId)
+          return { ok: true, deleted }
+        }
+        if (scope === 'session') {
+          if (!targetSessionId) return { ok: false, code: 'NO_SESSION', message: '缺少会话 ID' }
+          // 树形中会话挂在具体工作区下，客户端会传 root 限定范围；不传则
+          // 保持旧语义（删该会话全部工作区的快照），兼容老调用方。
+          const deleted = await deleteSnapshotsByFilter(
+            (rec) => rec.sessionId === targetSessionId && (!root || rec.root === root),
+            sessionId
+          )
+          return { ok: true, deleted }
+        }
         // 管理列表来自磁盘（跨工作区全量），而内存 state.snapshots 只含
         // 当前工作区 + 预热过的——冷启动或别的会话先点开列表时，列表里有、
         // 内存里没有，只查内存会把可删的快照误报「不存在」。解析链：
         // 内存命中 → Client 透传的条目 root → 磁盘 index 反查归属 store。
         let snap = state.snapshots.get(id) || null
-        let root = snap ? snap.root : (args && args.root ? String(args.root) : null)
+        let snapRoot = snap ? snap.root : root
         let store = null
-        if (root) {
-          try { store = await rt.resolveStore(root) } catch (error) { store = null }
+        if (snapRoot) {
+          try { store = await rt.resolveStore(snapRoot) } catch (error) { store = null }
         }
         if (!store) {
           // 兜底：扫 home 容器与降级目录的 index.json，找到含该 id 的 store
           const found = await locateSnapshotOnDisk(id)
-          if (found) { store = found.store; root = found.root }
+          if (found) { store = found.store; snapRoot = found.root }
         }
         if (!store) return { ok: false, code: 'NO_SNAPSHOT', message: '该快照不存在' }
         const finalStore = store
-        const finalRoot = root
+        const finalRoot = snapRoot
         await enqueue(async () => {
           if (state.gitExe) {
             await rt.runShell(rt.scripts.purgeTagsScript(finalStore, state.gitExe, ['snap-' + id]), { timeoutMs: 120000, stdoutMaxBytes: 4096 })
@@ -526,16 +761,33 @@ export function apply(ctx, config) {
   // 启动预热：所有已存在工作区解析存储、重建索引与孤儿快照，
   // 并清理旧版项目内 blobs 目录（home 可用时）。
   // 不触发维护（gc/清理）：开机预热应尽量轻，重活等第一条消息再按节流来。
-  for (const session of ctx.sessions.list()) {
-    const cwd = session && session.header && session.header.cwd
-    if (!cwd) continue
-    const sessionId = session.id
-    Promise.resolve(rt.resolveStore(cwd))
-      .then(() => rt.tryUpgradeToHome(cwd))
-      .then((store) => rt.ensureGit(cwd, store))
-      .then(() => snaps.loadIndex(cwd, sessionId))
-      .then(() => snaps.rebuildOrphans(cwd, sessionId))
-      .then(() => rt.cleanupLegacy(cwd))
-      .catch(() => {})
-  }
+  // 冷启动时 ctx.sessions.list() 常为空（惰性载入），必须叠加
+  // sessionQuery.listSessions() 冷元数据，否则设置页首次打开仍要现场建 store。
+  // apply 不是 async，这里用 IIFE 把冷元数据扫描包成异步任务。
+  ;(async () => {
+    const warmupRoots = new Map()
+    for (const session of ctx.sessions.list()) {
+      const cwd = session && session.header && session.header.cwd
+      if (cwd && !warmupRoots.has(cwd)) warmupRoots.set(cwd, session.id)
+    }
+    const querySvc = ctx.get('sessionQuery')
+    if (querySvc && typeof querySvc.listSessions === 'function') {
+      try {
+        const records = await querySvc.listSessions()
+        for (const record of records || []) {
+          const cwd = record && record.header && record.header.cwd
+          if (cwd && !warmupRoots.has(cwd)) warmupRoots.set(cwd, record.id || null)
+        }
+      } catch (error) { /* 冷元数据不可用则退回 live 注册表 */ }
+    }
+    for (const [cwd, sessionId] of warmupRoots) {
+      Promise.resolve(rt.resolveStore(cwd))
+        .then(() => rt.tryUpgradeToHome(cwd))
+        .then((store) => rt.ensureGit(cwd, store))
+        .then(() => snaps.loadIndex(cwd, sessionId))
+        .then(() => snaps.rebuildOrphans(cwd, sessionId))
+        .then(() => rt.cleanupLegacy(cwd))
+        .catch(() => {})
+    }
+  })()
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-recall-plugin",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "DSH 消息撤回插件：在用户消息气泡旁加「撤回」按钮，把项目文件（独立影子 git 仓库快照）与对话历史（官方 fork）一并回退到该消息发送之前。",
   "type": "module",
   "repository": {
@@ -40,12 +40,12 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-shell": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-sandbox-policy": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-session-query": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-web-react": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-shell": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-sandbox-policy": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-session-query": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-client-web-react": "^0.1.0-rc.8",
     "react": "^18.2.0"
   },
   "license": "MIT"