dsh-recall-plugin 1.7.0 → 2.0.0

package/lib/maintenance.js

@@ -1,145 +1,263 @@
-/**
- * dsh-recall-plugin — 快照维护（ctx 绑定的工厂，无模块级副作用）
- *
- * 职责：磁盘占用治理，两件事——
- * 1. 定期 git gc：全量保留策略下把 loose 对象压 pack + 跨版本 delta，
- *    无损（所有 tag 可达对象一个不丢），通常省一半以上空间；
- * 2. 会话删除联动清理：会话日志已从磁盘消失时，删除该会话全部快照 tag
- *    并重写索引，空间由紧随的同一次 gc --prune=now 真正释放。
- *
- * 触发点在每条用户消息快照之后的同一条串行队列里（见 index.js 的事件
- * 接线），因此 gc/清理与快照天然互斥，不存在 git 锁竞态。
- */
-
-// gc 节流阈值来自 config 域（设置页「插件配置」卡片可实时改写 cfg，
-// 因此这里按调用时取值而不是工厂创建时快照；环境变量
-// DSH_RECALL_GC_SNAPS/GC_HOURS 仍最高优先，见 config.js）：
-// 每 gcSnaps 条快照或距上次 gc gcHours 小时，先到先触发。默认「50 条或
-// 24 小时」——重活（gc）一天至多一次的量级，轻会话用户也不会等太久。
-export function createMaintenance(ctx, rt, snaps, config) {
-  const sessions = ctx.sessions
-  const state = rt.state
-  // 平台选择的脚本模板（gc/purge 两套模板同名导出）
-  const S = rt.scripts
-
-  // 删除一个会话的全部快照：按 root 分组（同一会话可能换过工作目录），
-  // tag 分块删除规避命令行长度上限，索引重写交给 snaps.saveIndex。
-  // best-effort：单块失败只记日志，剩余块继续；tag 残留由下次清理幂等收尾。
-  async function purgeSession(sessionId) {
-    const byRoot = new Map()
-    for (const [id, s] of state.snapshots.entries()) {
-      if (!s || s.sessionId !== sessionId) continue
-      if (!byRoot.has(s.root)) byRoot.set(s.root, [])
-      byRoot.get(s.root).push(id)
-    }
-    let purged = 0
-    for (const [root, ids] of byRoot) {
-      let store = state.stores.get(root)
-      if (!store) {
-        // 冷启动时 store 缓存可能还没建：现场解析一次而不是直接跳过——
-        // 跳过会让该 root 的快照永远清不掉（sweep 每轮都 miss）
-        try { store = await rt.resolveStore(root) } catch (error) { store = null }
-      }
-      if (!store || !state.gitExe) continue
-      try {
-        for (let i = 0; i < ids.length; i += 100) {
-          await rt.runShell(S.purgeTagsScript(store, state.gitExe, ids.slice(i, i + 100).map((id) => 'snap-' + id)), { timeoutMs: 120000, stdoutMaxBytes: 4096 })
-        }
-        for (const id of ids) state.snapshots.delete(id)
-        await snaps.saveIndex(root, sessionId)
-        purged += ids.length
-      } catch (error) {
-        rt.recordError('recall purge session failed: ' + String(error))
-      }
-    }
-    if (purged > 0) console.error('recall purged snapshots of deleted session:', sessionId, purged)
-    return purged
-  }
-
-  // 扫描索引里出现过的全部会话：既不在 sessions 注册表、冷读日志又失败的，
-  // 才认定「已删除」。两个保守闸门：
-  // - sessionQuery 服务不存在时整体跳过——没有冷读能力就无法区分
-  //   「已删除」和「只是冷着」，误删快照不可逆，宁可不清理；
-  // - 归档会话（撤回功能自己归档的）日志仍在磁盘上，readSession 仍成功，
-  //   不会被误清——只有日志真正消失才触发。
-  async function sweepDeletedSessions() {
-    const ids = new Set()
-    for (const s of state.snapshots.values()) {
-      if (s && s.sessionId) ids.add(s.sessionId)
-    }
-    if (!ids.size) return
-    const query = ctx.get('sessionQuery')
-    if (!query || typeof query.readSession !== 'function') 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)
-    }
-  }
-
-  // 维护核心（节流判定 + 清理 + gc）：force 供设置页「立即 gc」手动触发，
-  // 跳过阈值检查但仍走同一条串行队列调用方——与快照天然互斥的约束不变。
-  // 失败也推进 gcLastAt：gc 失败往往是环境性的（磁盘/杀软），不推进时间戳
-  // 会让后续每条消息都重试一次重量级 gc，把队列堵住。
-  async function runGc(sessionId, force) {
-    const root = await rt.resolveRoot(sessionId)
-    if (!root) return false
-    const store = state.stores.get(root)
-    if (!store || !state.gitExe) return false
-    const now = Date.now()
-    const last = state.gcLastAt.get(store.git) || 0
-    const count = (state.gcCount.get(store.git) || 0) + 1
-    state.gcCount.set(store.git, count)
-    if (!force && count < config.gcSnaps && now - last < config.gcHours * 3600000) return false
-    state.gcCount.set(store.git, 0)
-    try {
-      await sweepDeletedSessions()
-      await rt.runShell(S.gcScript(store, state.gitExe), { timeoutMs: 600000, stdoutMaxBytes: 4096 })
-    } catch (error) {
-      rt.recordError('recall maintenance failed: ' + String(error))
-    }
-    state.gcLastAt.set(store.git, Date.now())
-    return true
-  }
-
-  // 全局 gc（设置卡片没有会话上下文）：清理扫描一次 + 逐 store gc。
-  // store 全集取内存缓存（启动预热与历次操作会填齐已知工作区）；逐个
-  // best-effort，单个失败记错误继续。调用方（manage 端点）把它排进同一条
-  // 串行队列，与快照天然互斥，无 git 锁竞态。
-  async function runGcAll() {
-    const stores = Array.from(new Set(Array.from(state.stores.values()).filter(Boolean)))
-    if (!stores.length || !state.gitExe) return false
-    try {
-      await sweepDeletedSessions()
-    } catch (error) {
-      rt.recordError('recall sweep failed: ' + String(error))
-    }
-    let done = 0
-    for (const store of stores) {
-      try {
-        await rt.runShell(S.gcScript(store, state.gitExe), { timeoutMs: 600000, stdoutMaxBytes: 4096 })
-        done++
-      } catch (error) {
-        rt.recordError('recall gc failed for ' + (store && store.git) + ': ' + String(error))
-      }
-      state.gcLastAt.set(store.git, Date.now())
-      state.gcCount.set(store.git, 0)
-    }
-    return true
-  }
-
-  // 每条消息快照后串行调用（见 index.js 事件接线）
-  async function maybeMaintain(sessionId) {
-    await runGc(sessionId, false)
-  }
-
-  // 模块收敛：只导出被装配层消费的入口；sweepDeletedSessions /
-  // purgeSession 是 gc 的内部步骤，不对外暴露面
-  return { maybeMaintain, runGc, runGcAll }
-}
+/**
+ * dsh-recall-plugin — 快照维护（ctx 绑定的工厂，无模块级副作用）
+ *
+ * 职责：磁盘占用治理，两件事——
+ * 1. 定期 git gc：全量保留策略下把 loose 对象压 pack + 跨版本 delta，
+ *    无损（所有 tag 可达对象一个不丢），通常省一半以上空间；
+ * 2. 会话删除联动清理：会话日志已从磁盘消失时，删除该会话全部快照 tag
+ *    并重写索引，空间由紧随的同一次 gc --prune=now 真正释放。
+ *
+ * 触发点在每条用户消息快照之后的同一条串行队列里（见 index.js 的事件
+ * 接线），因此 gc/清理与快照天然互斥，不存在 git 锁竞态。
+ */
+
+// gc 节流阈值来自 config 域（设置页「插件配置」卡片可实时改写 cfg，
+// 因此这里按调用时取值而不是工厂创建时快照；环境变量
+// DSH_RECALL_GC_SNAPS/GC_HOURS 仍最高优先，见 config.js）：
+// 每 gcSnaps 条快照或距上次 gc gcHours 小时，先到先触发。默认「50 条或
+// 24 小时」——重活（gc）一天至多一次的量级，轻会话用户也不会等太久。
+
+// P1-3 纯逻辑：按 root 分组选出超限部分的最旧快照（time 升序，time=0 孤儿
+// 最旧优先），模块级导出供 tests/unit 直接钉边界；工厂内 enforceLimits 复用。
+export function selectOverLimitVictims(snapshots, limit) {
+  if (!limit || limit <= 0) return new Map() // 0 或负值 = 不限制
+  const byRoot = new Map()
+  for (const [id, s] of snapshots.entries()) {
+    if (!s || !s.root) continue
+    if (!byRoot.has(s.root)) byRoot.set(s.root, [])
+    byRoot.get(s.root).push({ id, time: s.time })
+  }
+  const victims = new Map()
+  for (const [root, list] of byRoot) {
+    if (list.length <= limit) continue
+    const excess = list.length - limit
+    // 按时间升序排：time=0 最旧，优先清；同时间保插入序（先入先出）
+    list.sort((a, b) => (a.time || 0) - (b.time || 0))
+    victims.set(root, list.slice(0, excess))
+  }
+  return victims
+}
+
+// S2-3 按时间保留的纯逻辑：retentionDays <= 0 不启用；按 root 分组，
+// 命中「time > 0 且早于 cutoff」的入选（time=0 孤儿视为最旧，一并最先
+// 清——与 selectOverLimitVictims 同构）。模块级导出供单测钉边界。
+export function selectExpiredVictims(snapshots, retentionDays, now) {
+  if (!retentionDays || retentionDays <= 0) return new Map()
+  const cutoff = (typeof now === 'number' ? now : Date.now()) - retentionDays * 86400000
+  const byRoot = new Map()
+  for (const [id, s] of snapshots.entries()) {
+    if (!s || !s.root) continue
+    // time=0 孤儿（rebuildOrphans 重建）无真实时间，视为最旧列入
+    if (s.time > 0 && s.time >= cutoff) continue
+    if (!byRoot.has(s.root)) byRoot.set(s.root, [])
+    byRoot.get(s.root).push({ id, time: s.time })
+  }
+  return byRoot
+}
+
+export function createMaintenance(ctx, rt, snaps, config) {
+  const sessions = ctx.sessions
+  const state = rt.state
+  // 平台选择的脚本模板（gc/purge 两套模板同名导出）
+  const S = rt.scripts
+
+  // 删除一个会话的全部快照：按 root 分组（同一会话可能换过工作目录），
+  // tag 分块删除规避命令行长度上限，索引重写交给 snaps.saveIndex。
+  // best-effort：单块失败只记日志，剩余块继续；tag 残留由下次清理幂等收尾。
+  async function purgeSession(sessionId) {
+    const byRoot = new Map()
+    for (const [id, s] of state.snapshots.entries()) {
+      if (!s || s.sessionId !== sessionId) continue
+      if (!byRoot.has(s.root)) byRoot.set(s.root, [])
+      byRoot.get(s.root).push(id)
+    }
+    let purged = 0
+    for (const [root, ids] of byRoot) {
+      let store = state.stores.get(root)
+      if (!store) {
+        // 冷启动时 store 缓存可能还没建：现场解析一次而不是直接跳过——
+        // 跳过会让该 root 的快照永远清不掉（sweep 每轮都 miss）
+        try { store = await rt.resolveStore(root) } catch (error) { store = null }
+      }
+      if (!store || !state.gitExe) continue
+      try {
+        for (let i = 0; i < ids.length; i += 100) {
+          await rt.runShell(S.purgeTagsScript(store, state.gitExe, ids.slice(i, i + 100).map((id) => 'snap-' + id)), { timeoutMs: 120000, stdoutMaxBytes: 4096 })
+        }
+        for (const id of ids) state.snapshots.delete(id)
+        await snaps.saveIndex(root, sessionId)
+        purged += ids.length
+      } catch (error) {
+        rt.recordError('recall purge session failed: ' + String(error))
+      }
+    }
+    if (purged > 0) console.error('recall purged snapshots of deleted session:', sessionId, purged)
+    return purged
+  }
+
+  // 扫描索引里出现过的全部会话：既不在 sessions 注册表、冷读日志又失败的，
+  // 才认定「已删除」。两个保守闸门：
+  // - sessionQuery 服务不存在时整体跳过——没有冷读能力就无法区分
+  //   「已删除」和「只是冷着」，误删快照不可逆，宁可不清理；
+  // - 归档会话（撤回功能自己归档的）日志仍在磁盘上，readSession 仍成功，
+  //   不会被误清——只有日志真正消失才触发。
+  async function sweepDeletedSessions() {
+    const ids = new Set()
+    for (const s of state.snapshots.values()) {
+      if (s && s.sessionId) ids.add(s.sessionId)
+    }
+    if (!ids.size) return
+    const query = ctx.get('sessionQuery')
+    if (!query || typeof query.readSession !== 'function') 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)
+    }
+  }
+
+  // 存储总量上限（P1-3）：按 root 分组统计，超限按 time 升序删最旧。
+  // 调用点（runGc/runGcAll）都在串行队列里，与快照互斥，无 git 锁竞态。
+  // 删除前 console.error 留痕（静默删历史撤回点必须可追溯，与 purgeSession
+  // 同款）；删除后重写索引。time=0 的孤儿条目（rebuildOrphans 重建）视为
+  // 最旧优先清理——它们没有真实时间，先于有时间的快照被清。
+  // 分组与选中逻辑在模块级 selectOverLimitVictims（单测直接钉边界）。
+  async function enforceLimits() {
+    const victimsMap = selectOverLimitVictims(state.snapshots, config.maxSnapshotsPerWorkspace)
+    if (!victimsMap.size) return 0
+    let dropped = 0
+    for (const [root, victims] of victimsMap) {
+      let store = state.stores.get(root)
+      if (!store) {
+        try { store = await rt.resolveStore(root) } catch (error) { store = null }
+      }
+      if (!store || !state.gitExe) continue
+      try {
+        for (let i = 0; i < victims.length; i += 100) {
+          await rt.runShell(S.purgeTagsScript(store, state.gitExe, victims.slice(i, i + 100).map((v) => 'snap-' + v.id)), { timeoutMs: 120000, stdoutMaxBytes: 4096 })
+        }
+        for (const v of victims) state.snapshots.delete(v.id)
+        await snaps.saveIndex(root, null)
+        dropped += victims.length
+        console.error('recall enforceLimits dropped ' + victims.length + ' oldest snapshots for: ' + root + ' (max ' + config.maxSnapshotsPerWorkspace + ')')
+      } catch (error) {
+        rt.recordError('recall enforceLimits failed for ' + root + ': ' + String(error))
+      }
+    }
+    return dropped
+  }
+
+  // 按时间保留（S2-3）：对每个 root 清掉早于保留窗口的快照。结构与
+  // enforceLimits 同款（tag 分块删除 + saveIndex + 留痕），与条数上限
+  // 各自独立触发，在同一轮 gc 周期里先后执行。时间维度的删除同样
+  // 静默丢历史撤回点，故 console.error 留痕与 enforceLimits 一致。
+  async function enforceRetention() {
+    const victimsMap = selectExpiredVictims(state.snapshots, config.retentionDays, Date.now())
+    if (!victimsMap.size) return 0
+    let dropped = 0
+    for (const [root, victims] of victimsMap) {
+      let store = state.stores.get(root)
+      if (!store) {
+        try { store = await rt.resolveStore(root) } catch (error) { store = null }
+      }
+      if (!store || !state.gitExe) continue
+      try {
+        for (let i = 0; i < victims.length; i += 100) {
+          await rt.runShell(S.purgeTagsScript(store, state.gitExe, victims.slice(i, i + 100).map((v) => 'snap-' + v.id)), { timeoutMs: 120000, stdoutMaxBytes: 4096 })
+        }
+        for (const v of victims) state.snapshots.delete(v.id)
+        await snaps.saveIndex(root, null)
+        dropped += victims.length
+        console.error('recall enforceRetention dropped ' + victims.length + ' expired snapshots for: ' + root + ' (retention ' + config.retentionDays + 'd)')
+      } catch (error) {
+        rt.recordError('recall enforceRetention failed for ' + root + ': ' + String(error))
+      }
+    }
+    return dropped
+  }
+
+  // 维护核心（节流判定 + 清理 + gc）：force 供设置页「立即 gc」手动触发，
+  // 跳过阈值检查但仍走同一条串行队列调用方——与快照天然互斥的约束不变。
+  // 失败也推进 gcLastAt：gc 失败往往是环境性的（磁盘/杀软），不推进时间戳
+  // 会让后续每条消息都重试一次重量级 gc，把队列堵住。
+  async function runGc(sessionId, force) {
+    const root = await rt.resolveRoot(sessionId)
+    if (!root) return false
+    const store = state.stores.get(root)
+    if (!store || !state.gitExe) return false
+    const now = Date.now()
+    const last = state.gcLastAt.get(store.git) || 0
+    const count = (state.gcCount.get(store.git) || 0) + 1
+    state.gcCount.set(store.git, count)
+    if (!force && count < config.gcSnaps && now - last < config.gcHours * 3600000) return false
+    state.gcCount.set(store.git, 0)
+    try {
+      await sweepDeletedSessions()
+      // P1-3：总量上限清理（sweep 之后、gc 之前）——与快照在同一条串行
+      // 队列里，删除 tag 与 gc 互斥，无 git 锁竞态；best-effort，
+      // 自身失败不进 catch 的主错误路径（enforceLimits 内部已兜）。
+      await enforceLimits()
+      // S2-3：按时间保留清理（与条数上限维度各自独立，同条串行队列）
+      await enforceRetention()
+      await rt.runShell(S.gcScript(store, state.gitExe), { timeoutMs: 600000, stdoutMaxBytes: 4096 })
+    } catch (error) {
+      rt.recordError('recall maintenance failed: ' + String(error))
+    }
+    state.gcLastAt.set(store.git, Date.now())
+    return true
+  }
+
+  // 全局 gc（设置卡片没有会话上下文）：清理扫描一次 + 逐 store gc。
+  // store 全集取内存缓存（启动预热与历次操作会填齐已知工作区）；逐个
+  // best-effort，单个失败记错误继续。调用方（manage 端点）把它排进同一条
+  // 串行队列，与快照天然互斥，无 git 锁竞态。
+  async function runGcAll() {
+    const stores = Array.from(new Set(Array.from(state.stores.values()).filter(Boolean)))
+    if (!stores.length || !state.gitExe) return false
+    try {
+      await sweepDeletedSessions()
+    } catch (error) {
+      rt.recordError('recall sweep failed: ' + String(error))
+    }
+    try {
+      // P1-3：全局清理一次（runGcAll 无会话上下文，enforceLimits 自身按
+      // root 遍历内存快照，天然覆盖全部已知工作区）
+      await enforceLimits()
+    } catch (error) {
+      rt.recordError('recall enforceLimits failed: ' + String(error))
+    }
+    try {
+      // S2-3：按时间保留全局清理一次
+      await enforceRetention()
+    } catch (error) {
+      rt.recordError('recall enforceRetention failed: ' + String(error))
+    }
+    let done = 0
+    for (const store of stores) {
+      try {
+        await rt.runShell(S.gcScript(store, state.gitExe), { timeoutMs: 600000, stdoutMaxBytes: 4096 })
+        done++
+      } catch (error) {
+        rt.recordError('recall gc failed for ' + (store && store.git) + ': ' + String(error))
+      }
+      state.gcLastAt.set(store.git, Date.now())
+      state.gcCount.set(store.git, 0)
+    }
+    return true
+  }
+
+  // 每条消息快照后串行调用（见 index.js 事件接线）
+  async function maybeMaintain(sessionId) {
+    await runGc(sessionId, false)
+  }
+
+  // 模块收敛：runGc/runGcAll 之外的内部步骤不对外暴露面；enforceLimits
+  // 保留导出供单测以工厂形态驱动（注入假 rt/ctx 钉执行链路）
+  return { maybeMaintain, runGc, runGcAll, enforceLimits, enforceRetention }
+}

package/lib/snapshots.js

@@ -7,6 +7,58 @@
  * 来自 rt.scripts（按平台选择的 scripts.pwsh.js / scripts.posix.js）。
  */
 
+// ---- 纯逻辑（模块级导出，供 tests/unit 直接钉住；工厂内沿用同一实现）----
+
+// 脚本侧 fail-open 跳过的路径（--ignore-errors 下无法索引的目录，如无
+// 提交的嵌入式仓库）以「SNAP_SKIP <path>」行回传：这些路径不进快照，
+// 撤回时既不恢复也不会被删，用户应当知道快照少了什么。
+export function parseSkipped(out) {
+  const skipped = []
+  for (const line of String(out || '').split(/\r?\n/)) {
+    if (line.indexOf('SNAP_SKIP ') === 0) skipped.push(line.slice('SNAP_SKIP '.length))
+  }
+  return skipped
+}
+
+// POSIX 侧 diff 输出是 TSV「kind<TAB>path」逐行（bash 模板不拼 JSON，
+// 避免 jq 依赖与转义坑）；win32 侧是 ConvertTo-Json。这里按平台分叉解析。
+export function parseChanges(text, isWin) {
+  if (isWin) {
+    const parsed = JSON.parse(text)
+    if (Array.isArray(parsed)) return parsed
+    if (parsed && typeof parsed === 'object') return [parsed]
+    return []
+  }
+  const out = []
+  for (const line of text.split(/\r?\n/)) {
+    if (!line) continue
+    const tab = line.indexOf('\t')
+    if (tab < 0) continue
+    out.push({ kind: line.slice(0, tab), rel: line.slice(tab + 1) })
+  }
+  return out
+}
+
+// 在事件序列里找“该消息之前最近一次 turn/end 的 seq”。
+export function scanCutSeq(events, messageId) {
+  let anchor = -1
+  for (let i = 0; i < events.length; i++) {
+    const e = events[i]
+    if (e && e.type === 'user/message' && e.data && String(e.data.id) === String(messageId)) {
+      anchor = i
+      break
+    }
+  }
+  if (anchor < 0) return null
+  for (let i = anchor - 1; i >= 0; i--) {
+    const e = events[i]
+    if (e && e.type === 'turn/end' && typeof e.seq === 'number') return e.seq
+  }
+  return null
+}
+
+// ---- 配置工厂 ----
+
 export function createSnapshots(ctx, rt, config) {
   const sessions = ctx.sessions
   const state = rt.state
@@ -39,9 +91,18 @@ export function createSnapshots(ctx, rt, config) {
     // 是 root 的单向哈希、反解不了——index.json 是唯一能持久「哈希↔工作区
     // 路径」对应关系的地方。loadIndex 忽略 entry.root（以参数为准），
     // 旧版本插件读新索引也只取已知字段，双向兼容。
+    // feedback 落盘（P1-2）：只对「需要解释」的消息写 feedback 字段（失败/
+    // 有跳过），正常快照不带——省空间；重启后 snapshot-info 仍能解释
+    // 「这条消息为什么没有/缺了快照」。与 root 字段当年的兼容策略一致：
+    // 老版本插件读新索引忽略未知字段。
     const entries = Array.from(state.snapshots.entries())
       .filter(([, s]) => s.root === root)
-      .map(([id, s]) => ({ id, time: s.time, root: s.root, sessionId: s.sessionId }))
+      .map(([id, s]) => {
+        const rec = { id, time: s.time, root: s.root, sessionId: s.sessionId }
+        const fb = state.snapFeedback.get(id)
+        if (fb && (fb.failed || (Array.isArray(fb.skipped) && fb.skipped.length))) rec.feedback = fb
+        return rec
+      })
     try {
       await rt.writeTextViaShell(store.dir + (rt.isWin ? '\\' : '/') + 'index.json', JSON.stringify(entries))
     } catch (error) {
@@ -65,6 +126,16 @@ export function createSnapshots(ctx, rt, config) {
           time: typeof entry.time === 'number' ? entry.time : Date.now(),
           sessionId: entry.sessionId || sessionId
         })
+        // feedback 回填（P1-2）：重启后仍能解释「这条消息为什么没有/缺了
+        // 快照」。复用 setFeedback 落内存（保持 FIFO 上限），只回填「需要
+        // 解释」的记录；旧版索引无 feedback 字段时天然跳过。
+        const fb = entry.feedback
+        if (fb && typeof fb === 'object') {
+          const rec = {}
+          if (fb.failed) { rec.failed = true; if (typeof fb.error === 'string') rec.error = fb.error }
+          if (Array.isArray(fb.skipped)) rec.skipped = fb.skipped.filter((p) => typeof p === 'string')
+          if (rec.failed || (Array.isArray(rec.skipped) && rec.skipped.length)) setFeedback(entry.id, rec)
+        }
       }
       // 只在读取链路全部走通后才标记已载入：若在 try 前抢先标记，
       // runShell 失败（shell 未就绪等）被吞后该 root 本次进程内被永久
@@ -137,17 +208,6 @@ export function createSnapshots(ctx, rt, config) {
     }
   }
 
-  // 脚本侧 fail-open 跳过的路径（--ignore-errors 下无法索引的目录，如无
-  // 提交的嵌入式仓库）以「SNAP_SKIP <path>」行回传：这些路径不进快照，
-  // 撤回时既不恢复也不会被删，用户应当知道快照少了什么。
-  function parseSkipped(out) {
-    const skipped = []
-    for (const line of String(out || '').split(/\r?\n/)) {
-      if (line.indexOf('SNAP_SKIP ') === 0) skipped.push(line.slice('SNAP_SKIP '.length))
-    }
-    return skipped
-  }
-
   // 逐消息反馈写入（issue #7 失败可见性）：成功无跳过 → 清除（重试成功
   // 自愈）；失败/有跳过 → 记录。上限防泄漏：交替成功失败的长会话可以无限
   // 积累，Map 保插入序做 FIFO 淘汰。
@@ -202,25 +262,6 @@ export function createSnapshots(ctx, rt, config) {
     snapFailures.set(root, f)
   }
 
-  // POSIX 侧 diff 输出是 TSV「kind<TAB>path」逐行（bash 模板不拼 JSON，
-  // 避免 jq 依赖与转义坑）；win32 侧是 ConvertTo-Json。这里按平台分叉解析。
-  function parseChanges(text) {
-    if (rt.isWin) {
-      const parsed = JSON.parse(text)
-      if (Array.isArray(parsed)) return parsed
-      if (parsed && typeof parsed === 'object') return [parsed]
-      return []
-    }
-    const out = []
-    for (const line of text.split(/\r?\n/)) {
-      if (!line) continue
-      const tab = line.indexOf('\t')
-      if (tab < 0) continue
-      out.push({ kind: line.slice(0, tab), rel: line.slice(tab + 1) })
-    }
-    return out
-  }
-
   // 变更清单截断上限：防止超大工作区（几千个文件）把 DOM 与 JSON
   // 双双撑爆。清单对用户的价值集中在前若干条，其余以 truncated 计数
   // 汇总展示；total 保留完整计数让面板文案仍准确。
@@ -236,7 +277,7 @@ export function createSnapshots(ctx, rt, config) {
     const text = S.stripBom(await rt.runShell(S.diffScript(snap.root, store, state.gitExe, 'snap-' + messageId, BASE()), { timeoutMs: 600000, stdoutMaxBytes: 8388608 }))
     const trimmed = text.trim()
     if (!trimmed) return { changes: [], total: 0, truncated: false }
-    const all = parseChanges(trimmed)
+    const all = parseChanges(trimmed, rt.isWin)
     return { changes: all.slice(0, MAX_CHANGES), total: all.length, truncated: all.length > MAX_CHANGES }
   }
 
@@ -252,24 +293,6 @@ export function createSnapshots(ctx, rt, config) {
     return { ok: true, count: (Number.isNaN(deleted) ? 0 : deleted) + (Number.isNaN(restored) ? 0 : restored) }
   }
 
-  // 在事件序列里找“该消息之前最近一次 turn/end 的 seq”。
-  function scanCutSeq(events, messageId) {
-    let anchor = -1
-    for (let i = 0; i < events.length; i++) {
-      const e = events[i]
-      if (e && e.type === 'user/message' && e.data && String(e.data.id) === String(messageId)) {
-        anchor = i
-        break
-      }
-    }
-    if (anchor < 0) return null
-    for (let i = anchor - 1; i >= 0; i--) {
-      const e = events[i]
-      if (e && e.type === 'turn/end' && typeof e.seq === 'number') return e.seq
-    }
-    return null
-  }
-
   // 解析“整段回退”的会话切点：优先读 live 会话的内存事件（零 IO、毫秒级），
   // 冷会话回退到 sessionQuery.readSession；结果按 (会话, 消息) 缓存——
   // 消息一旦入日志，其之前的 turn/end 永不变化，缓存终身有效。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-recall-plugin",
-  "version": "1.7.0",
+  "version": "2.0.0",
   "description": "DSH 消息撤回插件：在用户消息气泡旁加「撤回」按钮，把项目文件（独立影子 git 仓库快照）与对话历史（官方 fork）一并回退到该消息发送之前。",
   "type": "module",
   "repository": {
@@ -27,6 +27,10 @@
   "engines": {
     "node": ">=20"
   },
+  "scripts": {
+    "test": "vitest run tests/unit",
+    "test:probe": "vitest run tests/probe"
+  },
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
@@ -40,15 +44,18 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
-    "@deepseek-ai/schemastery": "^3.18.1",
-    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-shell": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-web-react": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.1-rc.2",
     "@deepseek-ai/dsh-sandbox-policy": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
     "@deepseek-ai/dsh-session-query": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-web-react": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-shell": "^0.1.1-rc.2",
+    "@deepseek-ai/schemastery": "^3.18.1",
     "react": "^18.2.0"
   },
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "vitest": "^4.1.11"
+  }
 }