dsh-recall-plugin 1.6.1 → 1.6.2

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 本文件格式遵循 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.1.0/)，版本号遵循语义化版本。
 
+## [1.6.2] - 2026-08-25
+
+### 修复
+
+- 用户消息图片显示空白且刷新无效（[#8](https://github.com/limbo947/dsh-recall-plugin/issues/8)）：会话回放时最早的图片消息先于会话 binding 就绪渲染，`loadImage` 以 unknown session 拒绝后被静默 `catch` 吞掉，图片永久空白。图片加载改为 400ms/1.5s/4s 三次退避自动重试（暂态失败自愈），耗尽后显示「图片加载失败，点击重试」失败态（对齐官方 MessageImage 语义）；顺带修复 attachment 切换时短暂残留上一张图的问题。
+- 快照连续失败无限累积磁盘残骸（[#7](https://github.com/limbo947/dsh-recall-plugin/issues/7) 评论实测一个下午 127GB dangling 对象）：失败重试的每次 `git add` 都会写入无 tag 可达的残骸对象。两道防线——
+  - **失败清理**：每次快照失败后执行 `git prune`（以 refs + 暂存 index 为根做可达性删除），只清当次残骸、不碰任何 tag 快照，已暂存对象保留以维持下次增量。
+  - **熔断退避**：连续 3 次失败后按 5min 起步指数翻倍、60min 封顶的退避跳过快照，冷却期满自动重试，成功一次即全部复位；进入熔断只在跳变沿记一条最近错误。
+
 ## [1.6.1] - 2026-08-23
 
 ### 新增

package/README.md

@@ -12,8 +12,11 @@
 
 ---
 **在任意一条你发过的消息下方**，**点「↶ 撤回」**，**工作区文件和对话历史一起回到那条消息发出之前的状态**。
+---
 
+[更新日志](CHANGELOG.md)
 ## 界面预览
+
 - 撤回按钮位置
 
 ![悬停出现撤回按钮](docs/screenshots/recall-button.png)
@@ -23,7 +26,7 @@
 | --- | --- |
 | ![确认面板 · 变更文件清单](docs/screenshots/confirm-panel-1.png) | ![确认面板](docs/screenshots/confirm-panel-2.png) |
 
-- 撤回后自动把消息文本回填到输入框，方便修改后重发（可在设置卡片关闭）
+- 撤回后自动把消息文本回填到输入框，方便修改后重发（可在设置卡片关闭）
 - 设置页 · 插件配置卡片（阈值 / 排除表 / 快照管理，保存即热生效）
 
  ![设置页](docs/screenshots/settings-exclude-2.png) 
@@ -126,6 +129,4 @@ Copy-Item -Recurse -Force $pkg "$profile\node_modules\dsh-recall-plugin"
 
 MIT
 
----
 
-[更新日志](CHANGELOG.md)

package/lib/client.js

@@ -39,6 +39,8 @@ window.__ModuleLoader__.load({
           '.dsh-recall-stack{flex-direction:column;align-items:flex-end;gap:8px;min-width:0;max-width:min(525px,82%);display:flex}',
           '.dsh-recall-bubble{background:var(--dsw-specific-bubble);max-width:100%;color:var(--dsw-alias-label-primary);border-radius:22px;padding:10px 16px;font-size:16px;line-height:24px;white-space:pre-wrap;word-break:break-word}',
           '.dsh-recall-img{max-width:100%;max-height:320px;border-radius:12px;object-fit:contain}',
+          '.dsh-recall-img-failed{border:1px dashed var(--dsw-alias-border-l2);border-radius:12px;padding:8px 14px;font-size:13px;line-height:20px;color:var(--dsw-alias-label-tertiary);cursor:pointer;background:0 0}',
+          '.dsh-recall-img-failed:hover{color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-label-dimmed)}',
           '.dsh-recall-json{margin:0;max-width:100%;font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary);white-space:pre-wrap;word-break:break-word;border:1px solid var(--dsw-alias-border-l1);border-radius:10px;padding:8px 10px;background:var(--dsw-alias-markdown-code-block)}',
           '.dsh-recall-actions{align-items:center;gap:10px;height:28px;display:flex}',
           '.dsh-recall-time{color:var(--dsw-alias-label-tertiary);white-space:nowrap;padding-right:12px;font-size:14px;line-height:24px}',
@@ -247,23 +249,50 @@ window.__ModuleLoader__.load({
           )
         }
 
+        // 图片加载失败的暂态判定（issue #8）：会话回放时最早的图片消息先于
+        // 会话 binding 就绪渲染，loadImage 以 unknown session 拒绝——这类
+        // 失败靠短退避自动重试即可自愈；此前 `.catch(() => {})` 把失败静默
+        // 吞掉且 src 恒为 null，图片永久空白且刷新无法恢复。自动重试耗尽
+        // 后置 failed，由 ImageBox 提供「点击重试」（对齐官方 MessageImage
+        // 的失败态语义），attempt 仅被手动重试递增以复用整条加载链。
+        const IMAGE_RETRY_DELAYS = [400, 1500, 4000]
+
         function useImageSrc(attachment, loadImage) {
           const [src, setSrc] = React.useState(null)
+          const [failed, setFailed] = React.useState(false)
+          const [attempt, setAttempt] = React.useState(0)
           React.useEffect(() => {
             let alive = true
+            let timer = null
             if (!attachment || typeof loadImage !== 'function') return undefined
-            Promise.resolve(loadImage(attachment)).then((url) => {
-              if (alive && url) setSrc(String(url))
-            }).catch(() => {})
-            return () => { alive = false }
-          }, [attachment, loadImage])
-          return src
+            // 复位旧状态：attachment 变化或手动重试时清掉上一轮的 src/failed，
+            // 避免加载期间短暂显示上一张图或残留的失败态
+            setSrc(null)
+            setFailed(false)
+            const tryLoad = (retried) => {
+              Promise.resolve(loadImage(attachment)).then((url) => {
+                if (!alive) return
+                if (url) setSrc(String(url))
+                else if (retried < IMAGE_RETRY_DELAYS.length) timer = setTimeout(() => tryLoad(retried + 1), IMAGE_RETRY_DELAYS[retried])
+                else setFailed(true)
+              }).catch(() => {
+                if (!alive) return
+                if (retried < IMAGE_RETRY_DELAYS.length) timer = setTimeout(() => tryLoad(retried + 1), IMAGE_RETRY_DELAYS[retried])
+                else setFailed(true)
+              })
+            }
+            tryLoad(0)
+            return () => { alive = false; if (timer) clearTimeout(timer) }
+          }, [attachment, loadImage, attempt])
+          return { src, failed, retry: () => setAttempt(attempt + 1) }
         }
 
         function ImageBox(props) {
-          const src = useImageSrc(props.attachment, props.loadImage)
-          if (!src) return null
-          return React.createElement('img', { className: 'dsh-recall-img', src, alt: '' })
+          const { src, failed, retry } = useImageSrc(props.attachment, props.loadImage)
+          if (src) return React.createElement('img', { className: 'dsh-recall-img', src, alt: '' })
+          // 加载中保持原零占位语义（不撑气泡）；只在确定失败后渲染可重试入口
+          if (failed) return React.createElement('button', { type: 'button', className: 'dsh-recall-img-failed', onClick: retry }, '图片加载失败，点击重试')
+          return null
         }
 
         // kind 语义单表承载（文案/徽章类名/汇总顺序）：新增 kind 时只改

package/lib/maintenance.js

@@ -1,145 +1,145 @@
-/**
- * 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）一天至多一次的量级，轻会话用户也不会等太久。
+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 }
+}

package/lib/scripts.posix.js

@@ -279,6 +279,18 @@ export function gcScript(store, gitExe) {
   ].join('\n')
 }
 
+// 快照失败后的残骸清理（语义同 pwsh 版，动机详见其注释）：prune 以
+// refs + 暂存 index 为根删无引用对象，只清失败 add 的残骸、不碰 tag 快照
+export function pruneScript(store, gitExe) {
+  return [
+    'set -e',
+    'git=' + psq(gitExe),
+    'g=' + psq(store.git),
+    '"$git" --git-dir="$g" prune',
+    'echo PRUNE_OK'
+  ].join('\n')
+}
+
 // 删除指定快照 tag（会话已删联动清理用）：tag -d 对不存在 tag 非零退出，
 // || true 吞掉——best-effort，残留 tag 由下次清理幂等收尾（同 pwsh 版）
 export function purgeTagsScript(store, gitExe, tags) {

package/lib/scripts.pwsh.js

@@ -314,6 +314,22 @@ export function gcScript(store, gitExe) {
   ].join('\n')
 }
 
+// 快照失败后的残骸清理（issue #7 实测：失败重试一个下午可积累 127GB
+// dangling 对象）。失败的 add 已把部分 blob 写进对象库，但 write-tree/
+// commit/tag 未发生——这些对象无引用可达；git prune 以 refs + 暂存 index
+// 为根做可达性删除，正好只清掉这批无主对象，不碰任何 tag 快照。不做 gc：
+// gc 是全量 repack 重活，失败重试场景下对象库往往已被残骸撑大，代价过高。
+// 调用点在 captureSnapshot 的 catch 里，与快照同走一条串行队列，无锁竞态。
+export function pruneScript(store, gitExe) {
+  return [
+    "$ErrorActionPreference = 'Stop'",
+    '$git = ' + psq(gitExe),
+    '$g = ' + psq(store.git),
+    '& $git --git-dir=$g prune',
+    "Write-Output 'PRUNE_OK'"
+  ].join('\n')
+}
+
 // 删除指定快照 tag（会话已删联动清理用）。best-effort：个别 tag 已不存在时
 // git 非零退出，但其余 tag 已被删除——所以显式 exit 0 吞掉退出码，
 // 残留的由下一次清理幂等地收尾；JS 侧无论脚本结果都会同步索引。

package/lib/snapshots.js

@@ -1,216 +1,258 @@
-/**
- * dsh-recall-plugin — 快照域（ctx 绑定的工厂，无模块级副作用）
- *
- * 职责：快照捕获（captureSnapshot）、索引落盘/载入/孤儿重建、
- * diff 清单（diffFor）、回退执行（rollbackFor）、会话切点解析
- * （resolveCutSeq）。依赖 store.js 的执行与存储层，脚本文本全部
- * 来自 rt.scripts（按平台选择的 scripts.pwsh.js / scripts.posix.js）。
- */
-
-export function createSnapshots(ctx, rt, config) {
-  const sessions = ctx.sessions
-  const state = rt.state
-  // 平台选择的脚本模板（rt.scripts = scripts.pwsh.js / scripts.posix.js）：
-  // 两套导出同名接口但实现分属 pwsh/bash，所有调用统一走 S.*
-  const S = rt.scripts
-  // 基础排除表随调用透传给脚本模板（用户 config 可调，即时生效）
-  // 运行时读取而非创建时快照：设置卡片热更新 baseExcludes 后，
-  // 下一次快照/diff/回退立即按新排除表执行
-  const BASE = () => config.baseExcludes
-
-  // 索引落盘：任意长度文本统一走 rt.writeTextViaShell（win32 base64
-  // 分块 / POSIX stdin，实现见 store.js）——saveIndex 与 writeExclude
-  // 曾逐字重复这套平台分叉，改一处漏一处的风险随合并消失。
-  async function saveIndex(root, sessionId) {
-    const store = state.stores.get(root)
-    if (!store) return
-    // 每条带 root：设置页「快照管理」要跨工作区展示列表，而 store 目录名
-    // 是 root 的单向哈希、反解不了——index.json 是唯一能持久「哈希↔工作区
-    // 路径」对应关系的地方。loadIndex 忽略 entry.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 }))
-    try {
-      await rt.writeTextViaShell(store.dir + (rt.isWin ? '\\' : '/') + 'index.json', JSON.stringify(entries))
-    } catch (error) {
-      rt.recordError('recall saveIndex failed: ' + String(error))
-    }
-  }
-
-  async function loadIndex(root, sessionId) {
-    if (state.indexLoaded.has(root)) return
-    const store = state.stores.get(root)
-    if (!store) return
-    try {
-      const raw = S.stripBom(await rt.runShell(S.indexReadCmd(store.dir), { stdoutMaxBytes: 4194304 })).trim()
-      if (!raw) { state.indexLoaded.add(root); return }
-      const entries = JSON.parse(raw)
-      if (!Array.isArray(entries)) { state.indexLoaded.add(root); return }
-      for (const entry of entries) {
-        if (!entry || typeof entry.id !== 'string') continue
-        state.snapshots.set(entry.id, {
-          root,
-          time: typeof entry.time === 'number' ? entry.time : Date.now(),
-          sessionId: entry.sessionId || sessionId
-        })
-      }
-      // 只在读取链路全部走通后才标记已载入：若在 try 前抢先标记，
-      // runShell 失败（shell 未就绪等）被吞后该 root 本次进程内被永久
-      // 视为「已载入」，索引永远为空、撤回按钮消失直到重启 DSH。
-      state.indexLoaded.add(root)
-    } catch (error) {
-      /* 索引缺失或损坏时按空历史处理；不标记已载入，下次自然重试 */
-    }
-  }
-
-  // exclude.txt 原文读取（设置页编辑用）：stripBom 剥掉 PS 5.1 Set-Content
-  // 写入的 UTF-8 BOM，避免设置页首行出现不可见的 \uFEFF；两套模板对缺失
-  // 文件都输出空串，这里不用区分「没配过」和「配了空」。
-  async function readExclude(store) {
-    return S.stripBom(await rt.runShell(S.excludeReadCmd(store.excludeFile), { stdoutMaxBytes: 1048576 }))
-  }
-
-  // exclude.txt 原文写入（设置页保存）：先 mkdir 父目录兜底（home 根目录
-  // /降级 store 目录被用户手滑删掉时，保存不该因此失败），写本体统一走
-  // rt.writeTextViaShell，与 saveIndex 共用同一套平台分叉原语。
-  async function writeExclude(store, text) {
-    const body = String(text == null ? '' : text)
-    const sep = rt.isWin ? '\\' : '/'
-    const parent = store.excludeFile.slice(0, store.excludeFile.lastIndexOf(sep))
-    await rt.runShell(S.mkdirScript(parent), { stdoutMaxBytes: 4096 })
-    await rt.writeTextViaShell(store.excludeFile, body)
-  }
-
-  // 索引丢失时从仓库 tag 重建：tag 名 snap-<messageId> 本身就是快照主键
-  async function rebuildOrphans(root, sessionId) {
-    const store = state.stores.get(root)
-    const gitExe = await rt.resolveGit()
-    if (!store || !gitExe) return
-    try {
-      const listing = S.stripBom(await rt.runShell(S.listTagsScript(store, gitExe), { stdoutMaxBytes: 4194304 })).trim()
-      if (!listing) return
-      for (const name of listing.split(/\r?\n/)) {
-        const id = name.trim().replace(/^snap-/, '')
-        if (!id || state.snapshots.has(id)) continue
-        state.snapshots.set(id, { root, time: 0, sessionId })
-      }
-      await saveIndex(root, sessionId)
-    } catch (error) {
-      rt.recordError('recall rebuildOrphans failed: ' + String(error))
-    }
-  }
-
-  async function captureSnapshot(sessionId, messageId, time) {
-    const root = await rt.resolveRoot(sessionId)
-    if (!root) return
-    let store = await rt.resolveStore(root)
-    store = await rt.tryUpgradeToHome(root)
-    const ok = await rt.ensureGit(root, store)
-    if (!ok) return
-    await loadIndex(root, sessionId)
-    try {
-      await rt.runShell(S.snapshotScript(root, store, state.gitExe, messageId, BASE()), { timeoutMs: 600000, stdoutMaxBytes: 65536 })
-      state.snapshots.set(String(messageId), { root, time: time || Date.now(), sessionId })
-      await saveIndex(root, sessionId)
-    } catch (error) {
-      rt.recordError('recall snapshot failed: ' + String(error))
-    }
-  }
-
-  // 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 保留完整计数让面板文案仍准确。
-  const MAX_CHANGES = 500
-
-  async function diffFor(messageId) {
-    const snap = state.snapshots.get(String(messageId))
-    if (!snap) return null
-    const store = state.stores.get(snap.root)
-    if (!store) return null
-    // 8MB 上限：按平均每条 60 字节估算可容纳十余万条，正常项目远够；
-    // 真超限时报错文案与「JSON 半截解析失败」的真实原因脱节，需显式检测
-    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)
-    return { changes: all.slice(0, MAX_CHANGES), total: all.length, truncated: all.length > MAX_CHANGES }
-  }
-
-  async function rollbackFor(messageId) {
-    const snap = state.snapshots.get(String(messageId))
-    if (!snap) return { ok: false, error: '该消息没有可用的项目快照' }
-    const store = state.stores.get(snap.root)
-    if (!store) return { ok: false, error: '快照存储不可用' }
-    const text = S.stripBom(await rt.runShell(S.rollbackScript(snap.root, store, state.gitExe, 'snap-' + messageId, BASE()), { timeoutMs: 600000, stdoutMaxBytes: 65536 }))
-    const m = text.trim().match(/^ROLLBACK_OK\s+(\d+)\s+(\d+)/)
-    const deleted = m ? parseInt(m[1], 10) : 0
-    const restored = m ? parseInt(m[2], 10) : 0
-    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 永不变化，缓存终身有效。
-  async function resolveCutSeq(sessionId, messageId) {
-    if (!sessionId || !messageId) return null
-    const cacheKey = String(sessionId) + '\u0000' + String(messageId)
-    if (state.cutSeqCache.has(cacheKey)) return state.cutSeqCache.get(cacheKey)
-    let result = null
-    const live = sessions.get(sessionId)
-    if (live && Array.isArray(live.events)) {
-      result = scanCutSeq(live.events, messageId)
-    } else {
-      const query = ctx.get('sessionQuery')
-      if (query) {
-        try {
-          const log = await query.readSession(sessionId)
-          result = scanCutSeq(Array.isArray(log && log.events) ? log.events : [], messageId)
-        } catch (error) {
-          result = null
-        }
-      }
-    }
-    state.cutSeqCache.set(cacheKey, result)
-    return result
-  }
-
-  return { saveIndex, loadIndex, readExclude, writeExclude, rebuildOrphans, captureSnapshot, diffFor, rollbackFor, resolveCutSeq }
-}
+/**
+ * dsh-recall-plugin — 快照域（ctx 绑定的工厂，无模块级副作用）
+ *
+ * 职责：快照捕获（captureSnapshot）、索引落盘/载入/孤儿重建、
+ * diff 清单（diffFor）、回退执行（rollbackFor）、会话切点解析
+ * （resolveCutSeq）。依赖 store.js 的执行与存储层，脚本文本全部
+ * 来自 rt.scripts（按平台选择的 scripts.pwsh.js / scripts.posix.js）。
+ */
+
+export function createSnapshots(ctx, rt, config) {
+  const sessions = ctx.sessions
+  const state = rt.state
+  // 平台选择的脚本模板（rt.scripts = scripts.pwsh.js / scripts.posix.js）：
+  // 两套导出同名接口但实现分属 pwsh/bash，所有调用统一走 S.*
+  const S = rt.scripts
+  // 基础排除表随调用透传给脚本模板（用户 config 可调，即时生效）
+  // 运行时读取而非创建时快照：设置卡片热更新 baseExcludes 后，
+  // 下一次快照/diff/回退立即按新排除表执行
+  const BASE = () => config.baseExcludes
+
+  // 连续失败熔断（issue #7）：失败快照的重试既无谓地全量扫描工作区，
+  // 又持续写入无 tag 可达的残骸对象（实测一个下午 127GB）。连续
+  // FUSE_AFTER 次失败后按 BASE 起步、指数翻倍、CAP 封顶的退避跳过
+  // 快照——冷却期内的消息不产生快照点，换来磁盘与 CPU 止血；冷却期满
+  // 自动重试，成功一次即全部复位，用户修好环境（如补排除配置）后
+  // 无需任何手动干预。
+  const FUSE_AFTER = 3
+  const FUSE_BACKOFF_BASE_MS = 5 * 60 * 1000
+  const FUSE_BACKOFF_CAP_MS = 60 * 60 * 1000
+  const snapFailures = new Map()
+
+  // 索引落盘：任意长度文本统一走 rt.writeTextViaShell（win32 base64
+  // 分块 / POSIX stdin，实现见 store.js）——saveIndex 与 writeExclude
+  // 曾逐字重复这套平台分叉，改一处漏一处的风险随合并消失。
+  async function saveIndex(root, sessionId) {
+    const store = state.stores.get(root)
+    if (!store) return
+    // 每条带 root：设置页「快照管理」要跨工作区展示列表，而 store 目录名
+    // 是 root 的单向哈希、反解不了——index.json 是唯一能持久「哈希↔工作区
+    // 路径」对应关系的地方。loadIndex 忽略 entry.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 }))
+    try {
+      await rt.writeTextViaShell(store.dir + (rt.isWin ? '\\' : '/') + 'index.json', JSON.stringify(entries))
+    } catch (error) {
+      rt.recordError('recall saveIndex failed: ' + String(error))
+    }
+  }
+
+  async function loadIndex(root, sessionId) {
+    if (state.indexLoaded.has(root)) return
+    const store = state.stores.get(root)
+    if (!store) return
+    try {
+      const raw = S.stripBom(await rt.runShell(S.indexReadCmd(store.dir), { stdoutMaxBytes: 4194304 })).trim()
+      if (!raw) { state.indexLoaded.add(root); return }
+      const entries = JSON.parse(raw)
+      if (!Array.isArray(entries)) { state.indexLoaded.add(root); return }
+      for (const entry of entries) {
+        if (!entry || typeof entry.id !== 'string') continue
+        state.snapshots.set(entry.id, {
+          root,
+          time: typeof entry.time === 'number' ? entry.time : Date.now(),
+          sessionId: entry.sessionId || sessionId
+        })
+      }
+      // 只在读取链路全部走通后才标记已载入：若在 try 前抢先标记，
+      // runShell 失败（shell 未就绪等）被吞后该 root 本次进程内被永久
+      // 视为「已载入」，索引永远为空、撤回按钮消失直到重启 DSH。
+      state.indexLoaded.add(root)
+    } catch (error) {
+      /* 索引缺失或损坏时按空历史处理；不标记已载入，下次自然重试 */
+    }
+  }
+
+  // exclude.txt 原文读取（设置页编辑用）：stripBom 剥掉 PS 5.1 Set-Content
+  // 写入的 UTF-8 BOM，避免设置页首行出现不可见的 \uFEFF；两套模板对缺失
+  // 文件都输出空串，这里不用区分「没配过」和「配了空」。
+  async function readExclude(store) {
+    return S.stripBom(await rt.runShell(S.excludeReadCmd(store.excludeFile), { stdoutMaxBytes: 1048576 }))
+  }
+
+  // exclude.txt 原文写入（设置页保存）：先 mkdir 父目录兜底（home 根目录
+  // /降级 store 目录被用户手滑删掉时，保存不该因此失败），写本体统一走
+  // rt.writeTextViaShell，与 saveIndex 共用同一套平台分叉原语。
+  async function writeExclude(store, text) {
+    const body = String(text == null ? '' : text)
+    const sep = rt.isWin ? '\\' : '/'
+    const parent = store.excludeFile.slice(0, store.excludeFile.lastIndexOf(sep))
+    await rt.runShell(S.mkdirScript(parent), { stdoutMaxBytes: 4096 })
+    await rt.writeTextViaShell(store.excludeFile, body)
+  }
+
+  // 索引丢失时从仓库 tag 重建：tag 名 snap-<messageId> 本身就是快照主键
+  async function rebuildOrphans(root, sessionId) {
+    const store = state.stores.get(root)
+    const gitExe = await rt.resolveGit()
+    if (!store || !gitExe) return
+    try {
+      const listing = S.stripBom(await rt.runShell(S.listTagsScript(store, gitExe), { stdoutMaxBytes: 4194304 })).trim()
+      if (!listing) return
+      for (const name of listing.split(/\r?\n/)) {
+        const id = name.trim().replace(/^snap-/, '')
+        if (!id || state.snapshots.has(id)) continue
+        state.snapshots.set(id, { root, time: 0, sessionId })
+      }
+      await saveIndex(root, sessionId)
+    } catch (error) {
+      rt.recordError('recall rebuildOrphans failed: ' + String(error))
+    }
+  }
+
+  async function captureSnapshot(sessionId, messageId, time) {
+    const root = await rt.resolveRoot(sessionId)
+    if (!root) return
+    // 熔断检查要在任何解析/建仓动作之前：冷却期内连 resolveStore 都
+    // 不必跑，把失败重试的开销也一并止住
+    const fused = snapFailures.get(root)
+    if (fused && Date.now() < fused.skipUntil) return
+    let store = await rt.resolveStore(root)
+    store = await rt.tryUpgradeToHome(root)
+    const ok = await rt.ensureGit(root, store)
+    if (!ok) return
+    await loadIndex(root, sessionId)
+    try {
+      await rt.runShell(S.snapshotScript(root, store, state.gitExe, messageId, BASE()), { timeoutMs: 600000, stdoutMaxBytes: 65536 })
+      snapFailures.delete(root)
+      state.snapshots.set(String(messageId), { root, time: time || Date.now(), sessionId })
+      await saveIndex(root, sessionId)
+    } catch (error) {
+      rt.recordError('recall snapshot failed: ' + String(error))
+      await handleSnapshotFailure(root, store)
+    }
+  }
+
+  // 失败善后 = 清残骸 + 推进熔断。captureSnapshot 的调用方就是串行队列
+  // （见 index.js 事件接线），这两个动作留在 catch 里顺势排队执行，
+  // 与下一次快照天然互斥，无 git 锁竞态；自身整体 best-effort，
+  // 清理失败不该让队列任务以异常收场。
+  async function handleSnapshotFailure(root, store) {
+    if (store && state.gitExe) {
+      try {
+        await rt.runShell(S.pruneScript(store, state.gitExe), { timeoutMs: 600000, stdoutMaxBytes: 4096 })
+      } catch (error) {
+        rt.recordError('recall prune after snapshot failure failed: ' + String(error))
+      }
+    }
+    const f = snapFailures.get(root) || { count: 0, skipUntil: 0 }
+    f.count++
+    if (f.count >= FUSE_AFTER) {
+      const backoff = Math.min(FUSE_BACKOFF_BASE_MS * 2 ** (f.count - FUSE_AFTER), FUSE_BACKOFF_CAP_MS)
+      const wasFused = Date.now() < f.skipUntil
+      f.skipUntil = Date.now() + backoff
+      // 只在「未熔断→熔断」的跳变沿记录：熔断期间每条消息都会走上面的
+      // 静默跳过分支，逐条记录会把最近错误环形缓冲刷成同一条目
+      if (!wasFused) rt.recordError('recall snapshot fused after ' + f.count + ' consecutive failures, backoff ' + Math.round(backoff / 60000) + 'min for: ' + root)
+    }
+    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 保留完整计数让面板文案仍准确。
+  const MAX_CHANGES = 500
+
+  async function diffFor(messageId) {
+    const snap = state.snapshots.get(String(messageId))
+    if (!snap) return null
+    const store = state.stores.get(snap.root)
+    if (!store) return null
+    // 8MB 上限：按平均每条 60 字节估算可容纳十余万条，正常项目远够；
+    // 真超限时报错文案与「JSON 半截解析失败」的真实原因脱节，需显式检测
+    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)
+    return { changes: all.slice(0, MAX_CHANGES), total: all.length, truncated: all.length > MAX_CHANGES }
+  }
+
+  async function rollbackFor(messageId) {
+    const snap = state.snapshots.get(String(messageId))
+    if (!snap) return { ok: false, error: '该消息没有可用的项目快照' }
+    const store = state.stores.get(snap.root)
+    if (!store) return { ok: false, error: '快照存储不可用' }
+    const text = S.stripBom(await rt.runShell(S.rollbackScript(snap.root, store, state.gitExe, 'snap-' + messageId, BASE()), { timeoutMs: 600000, stdoutMaxBytes: 65536 }))
+    const m = text.trim().match(/^ROLLBACK_OK\s+(\d+)\s+(\d+)/)
+    const deleted = m ? parseInt(m[1], 10) : 0
+    const restored = m ? parseInt(m[2], 10) : 0
+    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 永不变化，缓存终身有效。
+  async function resolveCutSeq(sessionId, messageId) {
+    if (!sessionId || !messageId) return null
+    const cacheKey = String(sessionId) + '\u0000' + String(messageId)
+    if (state.cutSeqCache.has(cacheKey)) return state.cutSeqCache.get(cacheKey)
+    let result = null
+    const live = sessions.get(sessionId)
+    if (live && Array.isArray(live.events)) {
+      result = scanCutSeq(live.events, messageId)
+    } else {
+      const query = ctx.get('sessionQuery')
+      if (query) {
+        try {
+          const log = await query.readSession(sessionId)
+          result = scanCutSeq(Array.isArray(log && log.events) ? log.events : [], messageId)
+        } catch (error) {
+          result = null
+        }
+      }
+    }
+    state.cutSeqCache.set(cacheKey, result)
+    return result
+  }
+
+  return { saveIndex, loadIndex, readExclude, writeExclude, rebuildOrphans, captureSnapshot, diffFor, rollbackFor, resolveCutSeq }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-recall-plugin",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "DSH 消息撤回插件：在用户消息气泡旁加「撤回」按钮，把项目文件（独立影子 git 仓库快照）与对话历史（官方 fork）一并回退到该消息发送之前。",
   "type": "module",
   "repository": {