dsh-recall-plugin 2.1.0 → 2.2.0

package/lib/maintenance.js

@@ -95,12 +95,21 @@ export function createMaintenance(ctx, rt, snaps, config) {
     return purged
   }
 
-  // 扫描索引里出现过的全部会话：既不在 sessions 注册表、冷读日志又失败的，
-  // 才认定「已删除」。两个保守闸门：
-  // - sessionQuery 服务不存在时整体跳过——没有冷读能力就无法区分
-  //   「已删除」和「只是冷着」，误删快照不可逆，宁可不清理；
-  // - 归档会话（撤回功能自己归档的）日志仍在磁盘上，readSession 仍成功，
-  //   不会被误清——只有日志真正消失才触发。
+  // 扫描索引里出现过的全部会话：不在 sessions 注册表、也不在磁盘会话目录
+  // 里的，才认定「已删除」。
+  // PF-7：一次 listSessions 建 id 集合替代逐会话 readSession 冷读——后者
+  // 对每个非 live 会话解压全量日志且跑在串行队列里，会话多的老工作区 gc
+  // 一到就把后续快照/撤回全堵在队尾；listSessions 是「目录级 header 枚举、
+  // 不触碰全量日志」（I8：记录 id 在 header.id），一次调用即得全部磁盘
+  // 会话 id 集。判定语义与旧「readSession 成败」等价且更保守：归档会话
+  // 日志仍在磁盘（集合中保留，不被误清——旧路径同样靠这一点）、日志损坏
+  // 但文件在的也保留（purge 不可逆，宁可少清）。
+  // 保守闸门保持：sessionQuery 服务（或 listSessions）不存在、枚举抛异常
+  // 时整体跳过——无法枚举就无法区分「已删除」和「只是冷着」，误删快照
+  // 不可逆，宁可不清理。
+  // titles 半项（PF-7 原案）：探针（tests/probe/api-surface.test.js）确认
+  // SessionHeader 无 title 字段（标题住在事件日志里）→ 冷标题无法走
+  // listSessions，titles 冷读维持 readSession 现状。
   async function sweepDeletedSessions() {
     const ids = new Set()
     for (const s of state.snapshots.values()) {
@@ -108,17 +117,19 @@ export function createMaintenance(ctx, rt, snaps, config) {
     }
     if (!ids.size) return
     const query = ctx.get('sessionQuery')
-    if (!query || typeof query.readSession !== 'function') return
+    if (!query || typeof query.listSessions !== 'function') return
+    let diskIds
+    try {
+      diskIds = new Set(((await query.listSessions()) || [])
+        .map((r) => r && r.header && r.header.id)
+        .filter(Boolean))
+    } catch (error) {
+      return
+    }
     for (const id of ids) {
       if (sessions.get(id)) continue
-      let alive = false
-      try {
-        const log = await query.readSession(id)
-        alive = Boolean(log)
-      } catch (error) {
-        alive = false
-      }
-      if (!alive) await purgeSession(id)
+      if (diskIds.has(id)) continue
+      await purgeSession(id)
     }
   }
 
@@ -257,7 +268,8 @@ export function createMaintenance(ctx, rt, snaps, config) {
     await runGc(sessionId, false)
   }
 
-  // 模块收敛：runGc/runGcAll 之外的内部步骤不对外暴露面；enforceLimits
-  // 保留导出供单测以工厂形态驱动（注入假 rt/ctx 钉执行链路）
-  return { maybeMaintain, runGc, runGcAll, enforceLimits, enforceRetention }
+  // 模块收敛：runGc/runGcAll 之外的内部步骤不对外暴露面；enforceLimits /
+  // sweepDeletedSessions 保留导出供单测以工厂形态驱动（注入假 rt/ctx 钉
+  // 执行链路；PF-7 sweep 判定矩阵依赖导出）。
+  return { maybeMaintain, runGc, runGcAll, enforceLimits, enforceRetention, sweepDeletedSessions }
 }

package/lib/routes-core.js

@@ -8,6 +8,7 @@
  */
 
 import { ENV_HINTS } from './diagnostics.js'
+import { parseTreeId } from './snapshots.js'
 
 export function createRoutesCore(deps) {
   // ctx 不解构（A4）：本域所有服务访问都已由 rt/snaps 封装，直接摸 ctx 会
@@ -64,7 +65,11 @@ export function createRoutesCore(deps) {
       if (result === null) return { ok: false, code: E.RECALL_NO_SNAPSHOT, message: '该消息没有可用的项目快照' }
       const snap2 = state.snapshots.get(id)
       const cutSeq = await snaps.resolveCutSeq(sessionId, id)
-      return { ok: true, changes: result.changes, total: result.total, truncated: result.truncated, time: snap2 ? snap2.time : null, root: snap2 ? snap2.root : null, cutSeq }
+      // PF-1：treeId 是 preview 时 add -A 后的 index 树指纹，Client 确认时
+      // 透传回 execute——Host 与安全快照指纹比对即可判定「预览后文件是否
+      // 变化」，省掉 execute 侧整条重复 diff。旧版 Client 不认识该字段，
+      // 无值时 execute 退回 previewTotal 校验（向后兼容）。
+      return { ok: true, changes: result.changes, total: result.total, truncated: result.truncated, treeId: result.treeId || null, time: snap2 ? snap2.time : null, root: snap2 ? snap2.root : null, cutSeq }
     },
 
     'execute': async (args) => {
@@ -78,11 +83,15 @@ export function createRoutesCore(deps) {
         // P0-1：队列内第一步——执行前再查一次 agent 状态。检查放在互斥
         // 队列内，检查后紧接执行，中间不可能插进别的操作，窗口为零。
         if (agentBusy(sessionId, snap.root)) return { ok: false, code: E.RECALL_AGENT_BUSY, message: 'Agent 正在运行中，请先停止后再撤回' }
-        // P0-3：preview→execute 失效校验。只由带 previewTotal 的新版
-        // Client 触发（老版本/直调 API 不带则跳过，向后兼容）。校验失败
-        // 连安全快照都不打——省一次全量 add。同数不同文件的边缘情形由
-        // 下方 pre-rollback 安全快照兜底。
-        if (args && typeof args.previewTotal === 'number') {
+        // P0-3 / PF-1：preview→execute 失效校验，两代并存——
+        // - 新版 Client 透传 previewTreeId（preview 时 add -A 后的 index 树
+        //   指纹）：与下方安全快照输出的指纹比对，内容级一致判定，且免掉
+        //   一整条重复 diff 进程（一次撤回 4 条重进程 → 3 条）。
+        // - 旧版 Client 只带 previewTotal：退回条目总数校验（多付一次 diff，
+        //   同数不同文件的边缘情形由安全快照兜底）。
+        // - 都不带（直调 API）：不校验，与 P0-3 同款可选语义。
+        const previewTreeId = args && typeof args.previewTreeId === 'string' && args.previewTreeId ? args.previewTreeId : null
+        if (!previewTreeId && args && typeof args.previewTotal === 'number') {
           const fresh = await snaps.diffFor(id)
           if (!fresh || fresh.total !== args.previewTotal) {
             return { ok: false, code: E.RECALL_STALE, message: '预览后项目文件发生了变化，请重新预览确认' }
@@ -95,15 +104,24 @@ export function createRoutesCore(deps) {
         // 用户可让插件从该 tag 恢复，堵住唯一的不可逆操作缺口。
         // 失败时 safetyOk 置 false：后续回退若也失败将无救援点（H1），
         // 行为退化为现状（fail-loud），不更差。
+        // PF-1：安全快照输出的树指纹就是「执行时刻的工作区状态」——与
+        // previewTreeId 不一致 → STALE（此时安全快照已打下，isSafetySnapshotId
+        // 让它不进索引，反而是额外的救援点）。安全快照失败时无指纹可比对，
+        // 跳过指纹校验继续回退（不阻断主流程的既有语义）。
         const safetyId = 'pre-rollback-' + Date.now()
         let safetyOk = false
+        let safetyTreeId = null
         try {
-          await rt.runShell(rt.scripts.snapshotScript(snap.root, store, state.gitExe, safetyId, cfg.baseExcludes), { timeoutMs: 600000, stdoutMaxBytes: 65536 })
+          const out = await rt.runShell(rt.scripts.snapshotScript(snap.root, store, state.gitExe, safetyId, cfg.baseExcludes), { timeoutMs: 600000, stdoutMaxBytes: 65536 })
           safetyOk = true
+          safetyTreeId = parseTreeId(out)
         } catch (error) {
           // 安全快照失败不阻断回退本身：用户已确认覆盖，记录后照原计划执行
           rt.recordError('recall safety snapshot failed: ' + String(error))
         }
+        if (previewTreeId && safetyTreeId && safetyTreeId !== previewTreeId) {
+          return { ok: false, code: E.RECALL_STALE, message: '预览后项目文件发生了变化，请重新预览确认' }
+        }
         const rolled = await snaps.rollbackFor(id)
         if (rolled.ok) return rolled
         // 回退失败（rollbackFor 返回 partial，工作区可能半回退）：用安全快照

package/lib/routes-manage.js

@@ -8,22 +8,113 @@
  */
 
 import { isSafetySnapshotId } from './snapshots.js'
+import { parseExcludeDump } from './dump-parse.js'
 
 export function createRoutesManage(deps) {
   const {
     ctx, rt, snaps, maint, state, cfg, supported, enqueue, runLimited,
     listExcludeFiles, dumpStores, locateSnapshotOnDisk, collectAllSnapshotRecords,
-    listCache, excludeCache, sessionInfo, titleFromEvents, messageTextFromEvents,
+    listCache, excludeCache, usageCache, sessionInfo, titleFromEvents, messageTextFromEvents,
     applyResolvedConfig, readSettings, DEFAULTS, E,
   } = deps
   const { sessionTitles, messageTexts, liveTitleFast, liveMessageTextFast } = sessionInfo
 
+  // PF-6：list items 构建（磁盘 dump + 内存并集 + 排序）从 list 分支抽出——
+  // 同步路径与 stale 后台刷新共用同一实现（改一处漏一处的风险随合并消失）。
+  async function buildListItems() {
+    const allItems = []
+
+    // 磁盘全量：一条 shell dump。标题只查 live/缓存（liveTitleFast，同步
+    // 瞬时）——冷会话标题由 Client 拿到列表后异步调 titles 补齐。
+    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)
+    }
+    // 去重只用 id（消息 ID 全局唯一）：带 root 进 key 会让同一快照因
+    // 「磁盘来源 root 缺失 / 内存来源 root 齐全」出现两条重复行
+    const byId = new Map()
+    function push(id, time, root, sessionId) {
+      if (!id || typeof id !== 'string') return
+      // F-G1 防御性展示过滤：修复前 rebuildOrphans 曾把 safety tag
+      // （pre-rollback-<ts>）strip 前缀后写进 index.json——存量污染条目
+      // 不做迁移清理（一次性数据，代价收益不划算），这里挡住可见性：
+      // 安全快照不是消息快照，本就不该出现在管理列表/树里。
+      if (isSafetySnapshotId(id)) 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 命中字符串则带，否则不设字段。
+        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
+      for (const e of info.entries || []) {
+        if (!e || typeof e.id !== 'string') continue
+        push(e.id, e.time, (typeof e.root === 'string' && e.root) || baseRoot, e.sessionId)
+      }
+    }
+    // 内存兜底（刚拍未落盘的保险，正常已被磁盘 dump 覆盖）
+    for (const [id, s] of state.snapshots.entries()) {
+      push(id, s.time, s.root, s.sessionId)
+    }
+    allItems.sort((a, b) => (b.time || 0) - (a.time || 0))
+    return allItems
+  }
+
+  // PF-6：stale 时的后台缓存刷新（in-flight 去重）——stale 期间重复 list
+  // 复用同一进行中的 dump，不重复起进程（否则进程数反而放大）。完成后清
+  // stale 标记；失败静默（下次 stale 触发自然重试）。
+  function refreshListCacheInBackground() {
+    if (listCache.refreshing) return listCache.refreshing
+    listCache.refreshing = buildListItems()
+      .then((allItems) => {
+        listCache.items = allItems
+        listCache.at = Date.now()
+        listCache.stale = false
+      })
+      // 冒烟实证：这里的静默吞错曾让 stale 卡死近半小时无任何观测点——
+      // 失败必须留痕（console），否则只能靠行为异常反推
+      .catch((error) => { console.error('recall list refresh failed:', String(error && error.stack || error)) })
+      .finally(() => { listCache.refreshing = null })
+    return listCache.refreshing
+  }
+
   // 按过滤条件批量删除快照（工作区/会话两个树节点共用）：先收集匹配
   // id 并按 root 分组，再整体进串行队列——与快照/gc 互斥，避免 git 锁
   // 竞态。每个 root 先 purge tag 再补载索引后重写 index.json，防止冷启动
   // 时用残缺内存覆盖同 store 其余磁盘快照。
+  // PF-6：缓存非空（含 stale）时直接由缓存 items 构造 records，省一次
+  // 全量 dumpStores——删除以「用户当前所见」为准（stale 说明有新快照未
+  // 入列表，用户没看到的也不在删除预期内）；缓存为空才全量收集。
   async function deleteSnapshotsByFilter(match, sessionId) {
-    const records = await collectAllSnapshotRecords()
+    let records
+    if (Array.isArray(listCache.items) && listCache.items.length) {
+      records = new Map()
+      for (const it of listCache.items) {
+        if (!it || typeof it.id !== 'string') continue
+        records.set(it.id, { id: it.id, root: it.root || null, sessionId: it.sessionId || null, time: typeof it.time === 'number' ? it.time : 0 })
+      }
+    } else {
+      records = await collectAllSnapshotRecords()
+    }
     const byRoot = new Map()
     for (const rec of records.values()) {
       if (!match(rec) || !rec.root) continue
@@ -60,6 +151,7 @@ export function createRoutesManage(deps) {
         }
       }
       listCache.items = null
+      usageCache.payload = null
     })
     return deleted
   }
@@ -136,6 +228,7 @@ export function createRoutesManage(deps) {
       // list 既合并内存也 dump 磁盘；无论完全/部分完成都必须失效，才能让
       // 成功删除的 store 立即从树上消失，而失败 store 仍保留供用户重试。
       listCache.items = null
+      usageCache.payload = null
       return { deleted, stores: clearedStores, failed }
     })
   }
@@ -145,17 +238,28 @@ export function createRoutesManage(deps) {
       // 设置页「撤回设置」标签的配置读取。不支持平台照常短路：Client
       // 显示不可用提示而不是空白表单，与 init 的 notice 语义对齐。
       if (!supported) return { ok: false, unsupported: true }
-      // 30s 结果缓存：首次进入要并行 resolveStore + 逐文件 shell 读，
-      // 二次打开/切标签不应重复付出这份代价；exclude-set 写入后失效。
+      // 30s 结果缓存：首次进入要 resolveStore 链 + 读取，二次打开/切标签
+      // 不应重复付出这份代价；exclude-set 写入后失效。
       if (excludeCache.payload && Date.now() - excludeCache.at < 30000) return excludeCache.payload
       const byFile = await listExcludeFiles()
-      // 并行读取各 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 = '' }
-        return { path, home: Boolean(info.store.home), roots: info.roots, content }
-      }))
-      const payload = { ok: true, files }
+      // PF-8：一条脚本 base64 读全部 exclude 文件——原每文件一条 Get-Content/
+      // cat 进程是首开 4-6 条链路里的大头；内容走 base64 对任意用户文本
+      // 免疫（定界不会被内容行打乱），parse 失败/文件缺失按空内容处理
+      // （与原 readExclude 对不存在文件输出空串的语义一致）。
+      let contents = new Map()
+      try {
+        const text = rt.scripts.stripBom(await rt.runShell(rt.scripts.excludeDumpScript(Array.from(byFile.keys())), { stdoutMaxBytes: 1048576 }))
+        contents = parseExcludeDump(text)
+      } catch (error) { /* dump 失败退回空内容列表（读失败的原语义） */ }
+      const payload = {
+        ok: true,
+        files: Array.from(byFile.entries()).map(([path, info]) => ({
+          path,
+          home: Boolean(info.store.home),
+          roots: info.roots,
+          content: contents.get(path) || ''
+        }))
+      }
       excludeCache.at = Date.now()
       excludeCache.payload = payload
       return payload
@@ -263,66 +367,19 @@ export function createRoutesManage(deps) {
       if (op === 'list') {
         const limitRaw = args && args.limit !== undefined ? Number(args.limit) : 200
         const safeLimit = Math.min(Math.max(Number.isFinite(limitRaw) ? Math.trunc(limitRaw) : 200, 1), 2000)
-        if (listCache.items && Date.now() - listCache.at < 30000) {
-          return { ok: true, items: listCache.items.slice(0, safeLimit), total: listCache.items.length }
-        }
-        const allItems = []
-
-        // 磁盘全量：一条 shell dump。标题只查 live/缓存（liveTitleFast，同步
-        // 瞬时）——冷会话标题由 Client 拿到列表后异步调 titles 补齐。
-        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)
-        }
-        // 去重只用 id（消息 ID 全局唯一）：带 root 进 key 会让同一快照因
-        // 「磁盘来源 root 缺失 / 内存来源 root 齐全」出现两条重复行
-        const byId = new Map()
-        function push(id, time, root, sessionId) {
-          if (!id || typeof id !== 'string') return
-          // F-G1 防御性展示过滤：修复前 rebuildOrphans 曾把 safety tag
-          // （pre-rollback-<ts>）strip 前缀后写进 index.json——存量污染条目
-          // 不做迁移清理（一次性数据，代价收益不划算），这里挡住可见性：
-          // 安全快照不是消息快照，本就不该出现在管理列表/树里。
-          if (isSafetySnapshotId(id)) 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 命中字符串则带，否则不设字段。
-            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
+        // PF-6：缓存非空且（fresh 或 stale）→ 立即用旧 items 应答，对话中
+        // 打开快照管理不再等全量 dump（30s TTL 曾被每条消息的清空形同虚设）。
+        // stale 时后台刷新（in-flight 去重），Client 凭 stale 标记静默再拉
+        // 一次渐进补新。缓存为空 → 同步 dump（首开现状）。
+        if (listCache.items && (Date.now() - listCache.at < 30000 || listCache.stale)) {
+          const stale = Boolean(listCache.stale)
+          if (stale) refreshListCacheInBackground()
+          return { ok: true, items: listCache.items.slice(0, safeLimit), total: listCache.items.length, stale }
         }
-        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
-            push(e.id, e.time, (typeof e.root === 'string' && e.root) || baseRoot, e.sessionId)
-          }
-        }
-        // 内存兜底（刚拍未落盘的保险，正常已被磁盘 dump 覆盖）
-        for (const [id, s] of state.snapshots.entries()) {
-          push(id, s.time, s.root, s.sessionId)
-        }
-
-        allItems.sort((a, b) => (b.time || 0) - (a.time || 0))
+        const allItems = await buildListItems()
         listCache.at = Date.now()
         listCache.items = allItems
+        listCache.stale = false
         return { ok: true, items: allItems.slice(0, safeLimit), total: allItems.length }
       }
       if (op === 'titles') {
@@ -391,6 +448,13 @@ export function createRoutesManage(deps) {
         return { ok: true, messageTexts: texts }
       }
       if (op === 'usage') {
+        // PF-3 顺带：全量 usage 结果 30s TTL（与 listCache 同款，删除/gc 后
+        // 由调用点失效）——ManageCard 每次 refresh 都重算的话，枚举再快
+        // 也是白付。仅缓存无 sessionId 的全量分支（client 唯一调用形态；
+        // 单工作区分支无调用方，不值得引入 key 维度）。
+        if (!sessionId && usageCache.payload && Date.now() - usageCache.at < 30000) {
+          return usageCache.payload
+        }
         let bytes = 0
         let homeStores = 0
         let fallbackStores = 0
@@ -404,17 +468,29 @@ export function createRoutesManage(deps) {
           const out = await rt.runShell(rt.scripts.diskUsageScript(store.dir), { stdoutMaxBytes: 4096 })
           bytes = parseInt(rt.scripts.stripBom(out).trim(), 10) || 0
         } else {
-          for (const store of state.stores.values()) {
-            if (!store || !store.dir) continue
-            if (store.home) homeStores++
-            else fallbackStores++
+          // PF-3 顺带：多 store 并行——读操作不碰 index.lock，但为防极端
+          // 磁盘争抢仍走 runLimited（并发 4）而不是裸 Promise.all；单 store
+          // 失败跳过的既有语义不变。
+          const knownStores = Array.from(state.stores.values()).filter((s) => s && s.dir)
+          const perStore = new Map()
+          await runLimited(knownStores.map((store) => async () => {
             try {
               const out = await rt.runShell(rt.scripts.diskUsageScript(store.dir), { stdoutMaxBytes: 4096 })
-              bytes += parseInt(rt.scripts.stripBom(out).trim(), 10) || 0
+              perStore.set(store.dir, parseInt(rt.scripts.stripBom(out).trim(), 10) || 0)
             } catch (error) { /* 单 store 失败跳过 */ }
+          }), 4)
+          for (const store of knownStores) {
+            if (store.home) homeStores++
+            else fallbackStores++
+            bytes += perStore.get(store.dir) || 0
           }
         }
-        return { ok: true, bytes, gitAvailable: state.gitExe !== '', homeStores, fallbackStores }
+        const payload = { ok: true, bytes, gitAvailable: state.gitExe !== '', homeStores, fallbackStores }
+        if (!sessionId) {
+          usageCache.at = Date.now()
+          usageCache.payload = payload
+        }
+        return payload
       }
       if (op === 'delete') {
         const scope = args && args.scope ? String(args.scope) : 'snapshot'
@@ -467,6 +543,7 @@ export function createRoutesManage(deps) {
           await snaps.saveIndex(finalRoot, sessionId)
           // 列表缓存失效：Client 删除后会立刻 refresh，必须看到最新状态
           listCache.items = null
+          usageCache.payload = null
         })
         return { ok: true }
       }
@@ -488,26 +565,27 @@ export function createRoutesManage(deps) {
         const done = sessionId
           ? await enqueue(() => maint.runGc(sessionId, true))
           : await enqueue(() => maint.runGcAll())
+        // gc 后占用显著下降：立即失效占用缓存，设置页 refresh 必须看到新值
+        usageCache.payload = null
         return { ok: true, gc: Boolean(done) }
       }
       if (op === 'lineage') {
-        // F1：返回全部已知工作区的 fork lineage（childId ↔ parentId 撤回链），
-        // 供快照管理树聚族。root 全集 = 内存 store + 磁盘 dump 的 root.txt。
-        const roots = new Set(state.stores.keys())
-        try {
-          const dump = await dumpStores()
-          for (const [dir, info] of dump) {
-            if (info && info.root) roots.add(info.root)
-          }
-        } catch (error) { /* 磁盘枚举失败退回内存 */ }
+        // F1 / PF-4：返回全部已知工作区的 fork lineage（childId ↔ parentId
+        // 撤回链），供快照管理树聚族。原实现对每个 root 串行 loadLineage
+        // （每 root 一条进程，20 工作区 ≈ 10s，版本家族标记最后才亮）——
+        // LINEAGE 段并入 storesDump 后一次 dump 全拿，零新增进程。dump 的
+        // ==DIR 就是磁盘 store 目录（比 roots 全集更全，还免去对未知 root
+        // resolveStore 建目录的副作用）；无 LINEAGE 段的旧输出按空 lineage
+        // 处理（parseStoresDump 容错）。
+        const hints = new Map()
+        for (const [root, st] of state.stores.entries()) {
+          if (st && st.dir) hints.set(st.dir, root)
+        }
+        let dump
+        try { dump = await dumpStores() } catch (error) { dump = new Map() }
         const out = []
-        for (const root of roots) {
-          let store = state.stores.get(root)
-          if (!store) {
-            try { store = await rt.resolveStore(root) } catch (error) { store = null }
-          }
-          if (!store) continue
-          for (const e of await snaps.loadLineage(root)) out.push(e)
+        for (const info of dump.values()) {
+          for (const e of info.lineage || []) out.push(e)
         }
         return { ok: true, lineage: out }
       }