dsh-recall-plugin 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-recall-plugin contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+# dsh-recall-plugin
+
+> 撤回一条消息，项目文件也一起回去。
+
+![License](https://img.shields.io/badge/license-MIT-blue)
+![Platform](https://img.shields.io/badge/platform-Windows-blue)
+![DSH](https://img.shields.io/badge/DSH-0.1.0--rc-blue)
+![Build](https://img.shields.io/badge/%E7%BA%AFJS-%E9%9B%B6%E6%9E%84%E5%BB%BA-green)
+
+---
+
+- 在任意一条你发过的消息下方，点「↶ 撤回」，**工作区文件和对话历史一起回到那条消息发出之前的状态**。
+- 注：安装本插件前的消息无法撤回
+
+## 界面预览
+- 撤回按钮位置
+
+![悬停出现撤回按钮](docs/screenshots/recall-button.png)
+
+---
+| 确认面板 · 变更文件清单| |
+| --- | --- |
+| ![确认面板 · 变更文件清单](docs/screenshots/confirm-panel-1.png) | ![确认面板](docs/screenshots/confirm-panel-2.png) |
+
+## 功能亮点
+
+- **文件 + 对话，整段回退**：撤回的不只是聊天记录，agent 改过的文件也一并回到原样。
+- **不碰你项目自己的 git**：快照存在独立的影子 git 仓库里，你的分支、暂存区、未提交改动统统不受影响；`.git`、`node_modules` 自动排除。
+- **项目目录保持干净**：快照默认存在 `$DSH_HOME` 下，不会往项目里塞任何东西；受限会话写不了 home 时才临时降级到项目内 `.dsh-recall-snapshots`，权限为 Full access 时自动迁走、清理干净。
+- **可以反复后悔**：快照全量保留、永不修剪。撤回一次后还能再撤到更早；撤回时被覆盖的文件也一直找得回来。
+- **先看清单再动手**：点撤回先弹出将变更的文件清单（修改 / 恢复 / 删除），确认后才执行，不会稀里糊涂覆盖。
+- **磁盘友好**：快照走 git delta 压缩，是增量不是整目录拷贝；超过 100MB 的大文件自动跳过。
+
+## 安装
+
+前置：Windows + git CLI（未装 git 时插件静默降级，不显示撤回按钮，不影响 DSH 运行）；PowerShell 5.1 / 7 均可；DSH 0.1.0-rc.x（依赖版本见 `peerDependencies`）。
+
+```powershell
+# DSH 官方插件命令：安装并自动挂载进 web profile
+dsh plugin --profile web add dsh-recall-plugin@<version>
+# 未发布时也可从 git 安装（纯 JS 无构建，免 prepare/allowBuilds）：
+# dsh plugin --profile web add github:<user>/dsh-recall-plugin
+
+# 重启 DSH 进程（按你的启动方式，任选其一）
+dsh web                      # 前台直接启动
+pm2 restart <你的dsh进程名>   # 若用 pm2 托管
+```
+
+**验证**：重启后硬刷新页面（Ctrl+Shift+R），悬停任意一条插件启用后发送的用户消息——复制按钮旁出现「↶」即生效。没有按钮？九成是没重启 DSH 进程，或 git CLI 不在 PATH 里。
+
+**卸载**：`dsh plugin --profile web remove dsh-recall-plugin`（同时移除依赖与挂载层），快照数据保留在 `$DSH_HOME/dsh-recall-snapshots/`，想彻底清除手动删掉该目录即可。
+
+## 使用
+
+1. 鼠标悬停任意**插件启用后发送**的用户消息，复制按钮左侧出现「↶ 撤回」。
+2. 点击 → 确认面板展示将变更的文件清单（修改 / 恢复 / 删除）。
+3. 点「确认回退」→ 文件恢复到该消息发送前的状态；视图切到新会话（该消息及之后的对话移除），原会话归档、随时可找回。
+
+## 工作原理
+
+每条用户消息发送时（agent 动文件之前），工作区被快照进一个独立的影子 git 仓库；撤回时用 `git archive` 恢复文件、通过 DSH 官方 `sessions.fork` 机制把会话切到该消息之前。二进制安全，全程不触碰项目自身的 git 状态。
+
+- 快照存储：`$DSH_HOME/dsh-recall-snapshots/<SHA256(项目绝对路径)>/`，内含影子 git 仓库（`git/`，tag 名为 `snap-<消息ID>`）与索引文件 `index.json`（消息 ID → 快照时间 / 会话）。
+- 想直接翻历史快照：
+
+  ```powershell
+  git --git-dir="<store>\git\.git" tag -l
+  git --git-dir="<store>\git\.git" ls-tree -r --name-only snap-<消息ID>
+  ```
+
+## 已知限制
+
+- 快照在**消息发送时**创建，插件启用前的历史消息没有快照，不显示撤回按钮。
+- 会话第一条用户消息无法回退对话（仅文件回退），因为 fork 需要更早的 turn 边界。
+- 仅支持 Windows（脚本用 PowerShell + git CLI）；Linux/macOS 下插件不报错，但快照不工作、不显示撤回按钮。
+- 工作区内嵌套的其他 git 仓库（子目录自带 `.git`）不进快照，其内容不参与回退。
+
+## 本地开发（无需发布）
+
+```powershell
+# 把包目录放进 web profile 的 node_modules，并登记到 bundles
+$pkg = '<你的仓库克隆路径>\dsh-recall-plugin'
+$profile = "$env:USERPROFILE\.dsh\profiles\web"
+Copy-Item -Recurse -Force $pkg "$profile\node_modules\dsh-recall-plugin"
+# 手动编辑 $profile\package.json：
+#   dependencies 加 "dsh-recall-plugin": "1.0.0"
+#   dsh.profile.bundles 加 "dsh-recall-plugin"
+# 然后重启 DSH 并硬刷新页面
+```
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,11 @@
+# dsh-recall-plugin bundle patch
+#
+# 持久插件挂载层（dsh.bundle.patch）：安装后由 DSH CLI 的 bundle 协调
+# 自动把本包加进 profile 的 dsh.profile.bundles，启动时合并这一个
+# insert 行——无需手动编辑任何 profile 文件。
+#
+# 安装（发布到 npm 后）：
+#   dsh plugin --profile web add dsh-recall-plugin@<version>
+- insert:
+    - id: recall
+      name: 'dsh-recall-plugin'

package/lib/client.js

@@ -0,0 +1,400 @@
+/**
+ * dsh-recall-plugin — Client 半（持久插件形态，浏览器 bundle）
+ *
+ * 职责：注册 conversation.chat.node 的 user 渲染器，重绘用户消息气泡
+ * （文本/图片/JSON 块），在复制按钮旁加「撤回」按钮；二次确认面板展示
+ * 文件变更清单，确认后经 /api/recall/* 调用 Host 回退文件，并用官方
+ * sessions.fork 把对话一并回退（新会话打开、原会话归档）。
+ *
+ * 这是 dsh.client bundle（exports["./client"]），由 client-modules 打包成
+ * /plugins/<pkg>/client.js 注入页面；factory 内 require("react") 由平台
+ * 模块表提供。零构建依赖：纯 JS + React.createElement。
+ */
+window.__ModuleLoader__.load({
+  id: "dsh-recall-plugin",
+  factory: (require) => {
+    const React = require("react")
+
+    return {
+      name: "dsh-recall-plugin",
+      apply(ctx) {
+        const slots = ctx.get('slots')
+        if (!slots) return
+        // 官方会话服务：fork 到已完成 turn 前缀 + open 切到新会话；
+        // workspaces 的归档只是从列表隐藏、可恢复，用来收走回退前的原会话。
+        const sessionsSvc = ctx.get('sessions')
+        const workspacesSvc = ctx.get('workspaces')
+
+        // Host HTTP API（动态插件的 harness RPC 在此换成 fetch 调用）
+        function api(name, args) {
+          return fetch('/api/recall/' + name, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(args || {})
+          }).then((r) => r.json())
+        }
+
+        const css = [
+          '.dsh-recall-row{flex-direction:column;align-items:flex-end;gap:6px;display:flex}',
+          '.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-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}',
+          '.dsh-recall-action{width:28px;height:28px;color:var(--dsw-alias-label-tertiary);cursor:pointer;background:0 0;border:none;border-radius:28px;justify-content:center;align-items:center;padding:6px;display:inline-flex}',
+          '.dsh-recall-action:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-secondary)}',
+          '@media (hover:hover){[data-time-hover-root] .dsh-recall-time{opacity:0;transition:opacity 80ms}[data-time-hover-root]:hover .dsh-recall-time,[data-time-hover-root]:focus-within .dsh-recall-time{opacity:1}}',
+          '.dsh-recall-panel{width:min(480px,100%);box-sizing:border-box;background:var(--dsw-alias-bg-base);border:1px solid var(--dsw-alias-border-l1);border-radius:12px;padding:12px 14px;display:flex;flex-direction:column;gap:8px;text-align:left;box-shadow:0 8px 28px rgba(0,0,0,.22)}',
+          '.dsh-recall-panel-title{color:var(--dsw-alias-label-primary);font-size:14px;font-weight:600;line-height:22px}',
+          '.dsh-recall-panel-note{color:var(--dsw-alias-label-secondary);font-size:13px;line-height:20px;word-break:break-word}',
+          '.dsh-recall-list{max-height:220px;overflow:auto;display:flex;flex-direction:column;gap:2px;padding:4px 0}',
+          '.dsh-recall-file{display:flex;gap:8px;align-items:baseline;font-size:12px;line-height:20px}',
+          '.dsh-recall-badge{flex:none;font-size:11px;line-height:18px;padding:0 6px;border-radius:6px}',
+          '.dsh-recall-badge-modified{color:var(--dsw-alias-state-error-primary);background:var(--dsw-alias-interactive-bg-hover)}',
+          '.dsh-recall-badge-restored{color:var(--dsw-alias-label-secondary);background:var(--dsw-alias-interactive-bg-hover)}',
+          '.dsh-recall-badge-added{color:var(--dsw-alias-label-tertiary);background:var(--dsw-alias-interactive-bg-hover)}',
+          '.dsh-recall-rel{min-width:0;color:var(--dsw-alias-label-primary);word-break:break-all;font-family:var(--dsw-font-code, ui-monospace, SFMono-Regular, Consolas, monospace)}',
+          '.dsh-recall-panel-actions{display:flex;gap:8px;justify-content:flex-end;margin-top:2px}',
+          '.dsh-recall-btn{border:none;border-radius:8px;padding:5px 14px;font-size:13px;line-height:20px;cursor:pointer;color:var(--dsw-alias-label-secondary);background:var(--dsw-alias-interactive-bg-hover)}',
+          '.dsh-recall-btn:hover{color:var(--dsw-alias-label-primary)}',
+          '.dsh-recall-btn-danger{background:var(--dsw-alias-state-error-primary);color:#fff}',
+          '.dsh-recall-btn-danger:hover{color:#fff;filter:brightness(1.08)}'
+        ].join('')
+        // 静态 bundle 的 ctx 可能不提供 styles 服务，降级为直接注入 <style>
+        const stylesSvc = ctx.get('styles')
+        if (stylesSvc && typeof stylesSvc.insert === 'function') {
+          stylesSvc.insert(css)
+        } else if (typeof document !== 'undefined') {
+          const tag = document.createElement('style')
+          tag.setAttribute('data-plugin', 'dsh-recall-plugin')
+          tag.textContent = css
+          document.head.appendChild(tag)
+        }
+
+        let initedSessionId = null
+        let initDone = Promise.resolve()
+
+        // 每个会话只向 Host 注册一次（预热其根目录解析缓存）。
+        // 返回 init 的 promise：Host 端 init 要跑数条 PowerShell（建仓/loadIndex），
+        // snapshot-info 必须等它完成后再查，否则冷启动时索引尚未载入会误判
+        // has:false 且不再重试，撤回按钮将永不出现。
+        function ensureInit(sessionId) {
+          if (!sessionId || initedSessionId === sessionId) return initDone
+          initedSessionId = sessionId
+          initDone = api('init', { sessionId }).catch(() => {})
+          return initDone
+        }
+
+        // 消息时间：当天只显示时分，跨天显示月/日 时分
+        function clockText(ms) {
+          try {
+            const d = new Date(ms)
+            const now = new Date()
+            const sameDay = d.getFullYear() === now.getFullYear() && d.getMonth() === now.getMonth() && d.getDate() === now.getDate()
+            const hh = String(d.getHours()).padStart(2, '0')
+            const mm = String(d.getMinutes()).padStart(2, '0')
+            return sameDay ? hh + ':' + mm : (d.getMonth() + 1) + '/' + d.getDate() + ' ' + hh + ':' + mm
+          } catch (e) {
+            return ''
+          }
+        }
+
+        // 复制按钮走浏览器剪贴板；无 primitives 依赖，直接调用并带降级
+        function writeClipboard(text) {
+          try {
+            if (navigator && navigator.clipboard && typeof navigator.clipboard.writeText === 'function') {
+              return navigator.clipboard.writeText(text).then(() => true, () => false)
+            }
+          } catch (e) { /* fall through */ }
+          try {
+            if (typeof document !== 'undefined' && typeof document.execCommand === 'function') {
+              const el = document.createElement('textarea')
+              el.value = text
+              el.setAttribute('readonly', '')
+              el.style.position = 'fixed'
+              el.style.left = '-9999px'
+              document.body.appendChild(el)
+              el.select()
+              try {
+                return Promise.resolve(document.execCommand('copy'))
+              } finally {
+                el.remove()
+              }
+            }
+          } catch (e) { /* ignore */ }
+          return Promise.resolve(false)
+        }
+
+        function CopyIcon() {
+          return React.createElement('svg', { width: 16, height: 16, viewBox: '0 0 16 16', fill: 'none', stroke: 'currentColor', strokeWidth: 1.4, 'aria-hidden': true },
+            React.createElement('rect', { x: 5.5, y: 5.5, width: 8, height: 8, rx: 1.5 }),
+            React.createElement('path', { d: 'M10.5 5.5V4a1.5 1.5 0 0 0-1.5-1.5H4A1.5 1.5 0 0 0 2.5 4v5A1.5 1.5 0 0 0 4 10.5h1.5' })
+          )
+        }
+
+        function CheckIcon() {
+          return React.createElement('svg', { width: 16, height: 16, viewBox: '0 0 16 16', fill: 'none', stroke: 'currentColor', strokeWidth: 1.6, strokeLinecap: 'round', strokeLinejoin: 'round', 'aria-hidden': true },
+            React.createElement('path', { d: 'm3 8.5 3.2 3.2L13 5' })
+          )
+        }
+
+        function UndoIcon() {
+          return React.createElement('svg', { width: 16, height: 16, viewBox: '0 0 16 16', fill: 'none', stroke: 'currentColor', strokeWidth: 1.4, strokeLinecap: 'round', strokeLinejoin: 'round', 'aria-hidden': true },
+            React.createElement('path', { d: 'M7.5 3.5 3.5 7.5l4 4' }),
+            React.createElement('path', { d: 'M4.5 7.5h5a3 3 0 0 1 0 6H8' })
+          )
+        }
+
+        function useImageSrc(attachment, loadImage) {
+          const [src, setSrc] = React.useState(null)
+          React.useEffect(() => {
+            let alive = true
+            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
+        }
+
+        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 KIND_LABEL = { modified: '修改', restored: '恢复', added: '删除' }
+
+        function summaryText(counts) {
+          const parts = []
+          if (counts.modified > 0) parts.push('修改 ' + counts.modified)
+          if (counts.restored > 0) parts.push('恢复 ' + counts.restored)
+          if (counts.added > 0) parts.push('删除 ' + counts.added)
+          return parts.join(' · ')
+        }
+
+        function recallPanel(recall, closePanel, executeRecall) {
+          if (recall.stage === 'loading') {
+            return React.createElement('div', { className: 'dsh-recall-panel' },
+              React.createElement('div', { className: 'dsh-recall-panel-title' }, '正在计算变更…')
+            )
+          }
+          if (recall.stage === 'error') {
+            return React.createElement('div', { className: 'dsh-recall-panel' },
+              React.createElement('div', { className: 'dsh-recall-panel-title' }, '无法回退'),
+              React.createElement('div', { className: 'dsh-recall-panel-note' }, recall.message || ''),
+              React.createElement('div', { className: 'dsh-recall-panel-actions' },
+                React.createElement('button', { type: 'button', className: 'dsh-recall-btn', onClick: closePanel }, '关闭')
+              )
+            )
+          }
+          if (recall.stage === 'confirm') {
+            const changes = recall.changes || []
+            const counts = { modified: 0, restored: 0, added: 0 }
+            for (const c of changes) {
+              if (c && counts[c.kind] !== undefined) counts[c.kind]++
+            }
+            const rows = changes.map((c, i) => React.createElement('div', { className: 'dsh-recall-file', key: i },
+              React.createElement('span', { className: 'dsh-recall-badge dsh-recall-badge-' + (c.kind || '') }, KIND_LABEL[c.kind] || c.kind || ''),
+              React.createElement('span', { className: 'dsh-recall-rel' }, c.rel || '')
+            ))
+            // cutSeq 为 null 表示该消息是会话第一条用户消息：文件可回退但对话无从回退
+            const canRevertChat = typeof recall.cutSeq === 'number'
+            return React.createElement('div', { className: 'dsh-recall-panel' },
+              React.createElement('div', { className: 'dsh-recall-panel-title' }, '整段回退'),
+              React.createElement('div', { className: 'dsh-recall-panel-note' },
+                '将项目恢复到' + (recall.time ? ' ' + clockText(recall.time) + ' ' : ' ') + '发送该消息时的状态。共 ' + changes.length + ' 个文件将变更' + (summaryText(counts) ? '（' + summaryText(counts) + '）' : '') + '。此操作会覆盖当前文件内容，不会自动创建备份。'
+              ),
+              React.createElement('div', { className: 'dsh-recall-panel-note' },
+                canRevertChat
+                  ? '对话将一并回退到该消息之前：该消息及之后的全部对话会从当前视图移除，原会话归档保存（可从归档找回）。'
+                  : '该消息是本会话中第一条用户消息，无法回退对话；确认后仅回退项目文件。'
+              ),
+              changes.length > 0 ? React.createElement('div', { className: 'dsh-recall-list' }, ...rows) : null,
+              React.createElement('div', { className: 'dsh-recall-panel-actions' },
+                React.createElement('button', { type: 'button', className: 'dsh-recall-btn', onClick: closePanel }, '取消'),
+                React.createElement('button', { type: 'button', className: 'dsh-recall-btn dsh-recall-btn-danger', onClick: executeRecall }, '确认回退')
+              )
+            )
+          }
+          if (recall.stage === 'executing') {
+            return React.createElement('div', { className: 'dsh-recall-panel' },
+              React.createElement('div', { className: 'dsh-recall-panel-title' }, '正在回退…')
+            )
+          }
+          if (recall.stage === 'done') {
+            return React.createElement('div', { className: 'dsh-recall-panel' },
+              React.createElement('div', { className: 'dsh-recall-panel-title' }, '回退完成'),
+              React.createElement('div', { className: 'dsh-recall-panel-note' },
+                recall.chatReverted
+                  ? '项目文件与对话已回退到该消息之前。新会话已打开，原会话已归档（可从归档找回）。'
+                  : '项目已恢复到发送该消息时的状态。' + (recall.chatError ? ' 对话回退失败：' + recall.chatError : '')
+              ),
+              React.createElement('div', { className: 'dsh-recall-panel-actions' },
+                React.createElement('button', { type: 'button', className: 'dsh-recall-btn', onClick: closePanel }, '关闭')
+              )
+            )
+          }
+          return null
+        }
+
+        function UserRecallNode(props) {
+          const node = props && props.node
+          const loadImage = props && props.loadImage
+          const sessionId = props && props.sessionId
+          const data = node && node.data ? node.data : {}
+          // node.id 是会话事件匹配时写入的真实消息 ID；node.key 是位置键（如 13:input），不能用于快照查询
+          const messageId = node ? String(node.id || node.key || '') : ''
+          const blocks = Array.isArray(data.content) ? data.content : []
+          const text = blocks.filter((b) => b && b.type === 'text' && typeof b.text === 'string').map((b) => b.text).join('')
+          const images = blocks.filter((b) => b && b.type === 'image' && b.attachment).map((b) => b.attachment)
+          const rest = blocks.filter((b) => !b || !(b.type === 'text' && typeof b.text === 'string') && !(b.type === 'image' && b.attachment))
+
+          const [copied, setCopied] = React.useState(false)
+          const [hasSnapshot, setHasSnapshot] = React.useState(false)
+          const [recall, setRecall] = React.useState({ stage: 'idle' })
+
+          React.useEffect(() => {
+            let alive = true
+            // 先等 init 预热完成再查快照存在性：避免索引未载入时误判 has:false
+            ensureInit(sessionId).then(() => {
+              if (!messageId || !alive) return
+              return api('snapshot-info', { messageId }).then((res) => {
+                if (alive && res && res.has) setHasSnapshot(true)
+              }).catch(() => {})
+            })
+            return () => { alive = false }
+          }, [messageId, sessionId])
+
+          const onCopy = () => {
+            if (copied) return
+            writeClipboard(text).then(() => {
+              setCopied(true)
+              const timer = ctx.get('timer')
+              if (timer && typeof timer.timeout === 'function') {
+                timer.timeout(() => setCopied(false), 1200)
+              } else {
+                setTimeout(() => setCopied(false), 1200)
+              }
+            })
+          }
+
+          const openPreview = () => {
+            if (recall.stage === 'loading' || recall.stage === 'executing') return
+            setRecall({ stage: 'loading' })
+            api('preview', { messageId, sessionId }).then((res) => {
+              if (!res || !res.ok) {
+                setRecall({ stage: 'error', message: (res && res.error) || '无法获取快照' })
+                return
+              }
+              setRecall({
+                stage: 'confirm',
+                changes: res.changes || [],
+                time: res.time || null,
+                cutSeq: typeof res.cutSeq === 'number' ? res.cutSeq : null
+              })
+            }).catch((error) => {
+              setRecall({ stage: 'error', message: String(error) })
+            })
+          }
+
+          const executeRecall = () => {
+            if (recall.stage !== 'confirm') return
+            const changes = recall.changes || []
+            const previewCut = typeof recall.cutSeq === 'number' ? recall.cutSeq : null
+            setRecall({ stage: 'executing', changes })
+            api('execute', { messageId, sessionId }).then(async (res) => {
+              if (!res || !res.ok) {
+                setRecall({ stage: 'error', message: (res && res.error) || '回退失败' })
+                return
+              }
+              // 文件已回退；对话回退独立进行，失败只降级为“仅文件回退”而不是整体失败
+              const cutSeq = typeof res.cutSeq === 'number' ? res.cutSeq : previewCut
+              let chatReverted = false
+              let chatError = ''
+              if (cutSeq !== null && sessionsSvc && typeof sessionsSvc.fork === 'function') {
+                try {
+                  const childId = await sessionsSvc.fork({ sessionId, atSeq: cutSeq, increaseTitle: true })
+                  if (childId) {
+                    if (typeof sessionsSvc.open === 'function') sessionsSvc.open(childId)
+                    chatReverted = true
+                    // 回退前的原会话归档：只是从列表隐藏、可恢复，避免侧栏出现两个近似会话
+                    if (workspacesSvc && typeof workspacesSvc.archiveSession === 'function') {
+                      workspacesSvc.archiveSession(sessionId).catch(() => {})
+                    }
+                  } else {
+                    chatError = '未返回新会话'
+                  }
+                } catch (error) {
+                  chatError = String(error)
+                }
+              }
+              setHasSnapshot(false)
+              setRecall({ stage: 'done', count: typeof res.count === 'number' ? res.count : changes.length, chatReverted, chatError })
+            }).catch((error) => {
+              setRecall({ stage: 'error', message: String(error) })
+            })
+          }
+
+          const closePanel = () => setRecall({ stage: 'idle' })
+
+          const bubbleChildren = []
+          if (text !== '') bubbleChildren.push(React.createElement('div', { className: 'dsh-recall-bubble', key: 'text' }, text))
+          for (let i = 0; i < images.length; i++) {
+            bubbleChildren.push(React.createElement(ImageBox, { key: 'img-' + i, attachment: images[i], loadImage }))
+          }
+          for (let i = 0; i < rest.length; i++) {
+            bubbleChildren.push(React.createElement('pre', { className: 'dsh-recall-json', key: 'rest-' + i }, JSON.stringify(rest[i], null, 2)))
+          }
+
+          const actions = []
+          actions.push(React.createElement('span', { className: 'dsh-recall-time', key: 'time' }, clockText(data.time)))
+          actions.push(React.createElement('button', {
+            key: 'copy',
+            type: 'button',
+            className: 'dsh-recall-action',
+            'aria-label': copied ? '已复制' : '复制',
+            title: copied ? '已复制' : '复制',
+            onClick: onCopy
+          }, copied ? React.createElement(CheckIcon, {}) : React.createElement(CopyIcon, {})))
+          if (hasSnapshot) {
+            actions.push(React.createElement('button', {
+              key: 'recall',
+              type: 'button',
+              className: 'dsh-recall-action',
+              'aria-label': '撤回',
+              title: '整段回退：文件与对话一并回到该消息之前',
+              onClick: openPreview
+            }, React.createElement(UndoIcon, {})))
+          }
+
+          return React.createElement('div', { className: 'dsh-recall-row', 'data-time-hover-root': true },
+            bubbleChildren.length > 0 ? React.createElement('div', { className: 'dsh-recall-stack', key: 'stack' }, ...bubbleChildren) : null,
+            React.createElement('div', { className: 'dsh-recall-actions', key: 'actions' }, ...actions),
+            recallPanel(recall, closePanel, executeRecall)
+          )
+        }
+
+        // keyed slot 显式用低于默认 0 的 priority 注册：默认 0 通常被平台/
+        // 其他插件的渲染器占据，不指定 priority 会因 keyed slot 冲突拒载
+        // 整个插件；lowest renders，负值恰好覆盖默认渲染器实现撤回 UI。
+        // priority -1 也可能被别的机器上的插件占用（同样抛冲突），所以
+        // 递减重试三次——最坏情况只是撤回按钮不渲染，绝不让插件加载失败。
+        let mounted = false
+        for (let priority = -1; priority >= -3 && !mounted; priority--) {
+          try {
+            slots.inject('conversation.chat.node', () => slots.register(
+              { name: 'conversation.chat.node', key: 'user', priority },
+              UserRecallNode
+            ))
+            mounted = true
+          } catch (error) {
+            if (priority === -3) console.error('[dsh-recall-plugin] slot register failed:', error)
+          }
+        }
+      }
+    }
+  }
+})

package/lib/index.js

@@ -0,0 +1,657 @@
+/**
+ * dsh-recall-plugin — Host 半（持久插件形态，bundle 行挂载）
+ *
+ * 职责：监听 session/event，为每条用户消息创建项目快照（独立影子 git 仓库，
+ * 默认存于 DSH home，受限会话自动降级项目内并可迁回）；
+ * 通过 webServer 注册 /api/recall/* HTTP API，供 Client 半调用
+ * （init / snapshot-info / preview / execute）。
+ *
+ * 这是持久 npm 插件包的主入口（exports["."]），由 cordis.patch.yml 的
+ * insert 行挂载进 profile composition，DSH 重启后自动生效。
+ */
+
+export const name = 'dsh-recall-plugin'
+
+// 硬依赖：shell（PowerShell 执行）、sessions（会话/沙箱策略）、
+// webServer（Client 半的 HTTP API 通道）。其余服务按需 ctx.get。
+export const inject = ['shell', 'sessions', 'webServer']
+
+const MAX_FILE_BYTES = 104857600
+const HOME_RETRY_MS = 300000
+
+export function apply(ctx) {
+  const shell = ctx.shell
+  const sessions = ctx.sessions
+  const webServer = ctx.webServer
+
+  const state = {
+    roots: new Map(),
+    stores: new Map(),
+    snapshots: new Map(),
+    queue: Promise.resolve(),
+    indexLoaded: new Set(),
+    gitReady: new Set(),
+    cutSeqCache: new Map(),
+    homeRetryAt: new Map(),
+    gitExe: null
+  }
+
+  function psq(value) {
+    return "'" + String(value).replace(/'/g, "''") + "'"
+  }
+
+  // 每次 shell 调用都带会话沙箱策略：默认受限模式下不带策略连临时目录都写不了。
+  async function runShell(command, opts, sessionId) {
+    let policy
+    const sp = ctx.get('sandboxPolicy')
+    if (sp) {
+      const session = sessionId ? sessions.get(sessionId) : undefined
+      policy = sp.resolve(session ? { session } : {})
+    }
+    const spec = shell.resolve({
+      command,
+      timeoutMs: (opts && opts.timeoutMs) || 300000,
+      stdoutMaxBytes: (opts && opts.stdoutMaxBytes) || 4194304,
+      ...(policy ? { sandboxPolicy: policy } : {})
+    })
+    const res = await shell.run(spec)
+    const out = (res && res.stdout && res.stdout.text) || ''
+    if (res && res.exitCode !== 0) {
+      const err = ((res && res.stderr && res.stderr.text) || '').trim() || ('exit ' + String(res.exitCode))
+      throw new Error(err.slice(0, 1500))
+    }
+    return out
+  }
+
+  function stripBom(text) {
+    return text.replace(/^\uFEFF/, '')
+  }
+
+  async function resolveRoot(sessionId) {
+    const key = sessionId ? String(sessionId) : 'fallback'
+    const cached = state.roots.get(key)
+    if (cached) return cached
+    let root = null
+    if (sessionId) {
+      const session = sessions.get(sessionId)
+      if (session && session.header && session.header.cwd) root = session.header.cwd
+    }
+    if (!root) {
+      const sp = ctx.get('sandboxPolicy')
+      if (sp && sp.workspaceRoot) root = sp.workspaceRoot
+    }
+    if (root) state.roots.set(key, root)
+    return root
+  }
+
+  // 会话查找（按 cwd 匹配），用于索引读写与 git 操作的沙箱策略
+  function sessionForRoot(root) {
+    const found = sessions.list().find((s) => s && s.header && s.header.cwd === root)
+    return found ? found.id : null
+  }
+
+  // 解析 git 可执行文件路径：DSH 进程 PATH 可能不含 git，
+  // 求值一次并缓存，脚本里用绝对路径调用，避免每条命令依赖 PATH。
+  async function resolveGit() {
+    if (state.gitExe !== null) return state.gitExe
+    try {
+      let path = stripBom(await runShell("$g = (Get-Command git -ErrorAction SilentlyContinue).Source; if (-not $g -and (Test-Path -LiteralPath 'C:\\Program Files\\Git\\cmd\\git.exe')) { $g = 'C:\\Program Files\\Git\\cmd\\git.exe' }; if ($g) { Write-Output $g }", { stdoutMaxBytes: 4096 }, null)).trim()
+      state.gitExe = path || ''
+    } catch (error) {
+      state.gitExe = ''
+    }
+    return state.gitExe
+  }
+
+  // 计算项目对应的 home 存储目录（DSH_HOME 优先，否则 ~/.dsh）。
+  // 哈希用 Create()+ComputeHash+BitConverter 而不是 HashData+ToHexString：
+  // 后两者是 .NET 5+（仅 PS 7）API，别人机器的 shell 若是 Windows PowerShell
+  // 5.1 会抛错，导致 home 存储永远降级到项目内；前者两个版本都可用。
+  async function homeDirFor(root, sessionId) {
+    const dirScript = [
+      '$r = ' + psq(root),
+      '$h = if ($env:DSH_HOME) { $env:DSH_HOME } else { Join-Path $env:USERPROFILE ".dsh" }',
+      '$sha = [Security.Cryptography.SHA256]::Create()',
+      "$hex = ([BitConverter]::ToString($sha.ComputeHash([Text.Encoding]::UTF8.GetBytes($r))) -replace '-','').ToLower()",
+      "Write-Output (Join-Path $h ('dsh-recall-snapshots\\' + $hex))"
+    ].join('\n')
+    const text = stripBom(await runShell(dirScript, { stdoutMaxBytes: 4096 }, sessionId)).trim()
+    if (!text) return null
+    // PS 的 Join-Path 可能带出连续反斜杠（旧版脚本遗留 "…\\<hex>" 形态）；
+    // 折叠成单反斜杠。Windows 把中间的重复分隔符视为同一个目录，
+    // 所以与既有快照数据（index.json、影子 git 仓库）路径完全兼容。
+    return text.replace(/\\{2,}/g, '\\')
+  }
+
+  // 存储根：优先放 DSH home（保持项目目录干净）；
+  // workspace-write 等受限会话写不了 home 时自动降级到项目内（功能优先于干净）。
+  // git init <dir> 会把真实 git-dir 建在 <dir>\.git，所以 store.repo 是
+  // 仓库工作目录、store.git 是真实 git-dir——冒烟测试踩过的坑。
+  async function resolveStore(root, sessionId) {
+    const cached = state.stores.get(root)
+    if (cached) return cached
+    let homeDir = null
+    try {
+      homeDir = await homeDirFor(root, sessionId)
+    } catch (error) {
+      homeDir = null
+    }
+    if (homeDir) {
+      try {
+        await runShell('New-Item -ItemType Directory -Force -Path ' + psq(homeDir) + ' | Out-Null', { stdoutMaxBytes: 4096 }, sessionId)
+        const store = { dir: homeDir, repo: homeDir + '\\git', git: homeDir + '\\git\\.git', home: true }
+        state.stores.set(root, store)
+        return store
+      } catch (error) {
+        console.error('recall home store unavailable, falling back to workspace:', String(error))
+      }
+    }
+    const fallback = root + '\\.dsh-recall-snapshots'
+    await runShell('New-Item -ItemType Directory -Force -Path ' + psq(fallback) + ' | Out-Null', { stdoutMaxBytes: 4096 }, sessionId)
+    const store = { dir: fallback, repo: fallback + '\\git', git: fallback + '\\git\\.git', home: false }
+    state.stores.set(root, store)
+    return store
+  }
+
+  // 降级后自动升级：会话权限提升（home 恢复可写）时，把项目内的
+  // 影子仓库整体迁回 home 并删除项目内目录，恢复“项目目录干净”。
+  // 失败节流 5 分钟，避免受限会话里每条消息都白试一次。
+  async function tryUpgradeToHome(root, sessionId) {
+    const store = state.stores.get(root)
+    if (!store || store.home) return store
+    const now = Date.now()
+    const last = state.homeRetryAt.get(root) || 0
+    if (now - last < HOME_RETRY_MS) return store
+    state.homeRetryAt.set(root, now)
+    let homeDir = null
+    try {
+      homeDir = await homeDirFor(root, sessionId)
+    } catch (error) {
+      homeDir = null
+    }
+    if (!homeDir) return store
+    try {
+      await runShell('New-Item -ItemType Directory -Force -Path ' + psq(homeDir) + ' | Out-Null', { stdoutMaxBytes: 4096 }, sessionId)
+      const migrate = [
+        "$ErrorActionPreference = 'Stop'",
+        '$src = ' + psq(store.dir),
+        '$dst = ' + psq(homeDir),
+        "if (Test-Path -LiteralPath (Join-Path $src 'git')) { Move-Item -LiteralPath (Join-Path $src 'git') -Destination (Join-Path $dst 'git') -Force }",
+        "if (Test-Path -LiteralPath (Join-Path $src 'index.json')) { Move-Item -LiteralPath (Join-Path $src 'index.json') -Destination (Join-Path $dst 'index.json') -Force }",
+        'Remove-Item -Recurse -Force -LiteralPath $src -ErrorAction SilentlyContinue',
+        "Write-Output 'MIGRATE_OK'"
+      ].join('\n')
+      await runShell(migrate, { timeoutMs: 300000, stdoutMaxBytes: 4096 }, sessionId)
+      const upgraded = { dir: homeDir, repo: homeDir + '\\git', git: homeDir + '\\git\\.git', home: true }
+      state.stores.set(root, upgraded)
+      state.gitReady.delete(store.git)
+      console.error('recall store upgraded to home:', root)
+      return upgraded
+    } catch (error) {
+      console.error('recall home upgrade failed:', String(error))
+      return store
+    }
+  }
+
+  // 建立影子仓库：普通 init（index 留在仓库内跨快照复用，git add 的 stat 缓存
+  // 让未变文件近乎零成本），core.longpaths 放开 Windows 深路径，
+  // info/exclude 排除 .git（项目是 git 仓库时）、node_modules、降级时的自目录。
+  // 幂等：gitReady 命中后直接跳过，省掉每条消息一次的 config/exclude 重写。
+  async function ensureGit(root, store, sessionId) {
+    if (state.gitReady.has(store.git)) return true
+    const gitExe = await resolveGit()
+    if (!gitExe) return false
+    const script = [
+      "$ErrorActionPreference = 'Stop'",
+      // 不设 PSNativeCommandUseErrorActionPreference：git 的 stderr 警告（hint 等）
+      // 在 DSH shell 注入方式下会被包成 ErrorRecord，配上 EAP=Stop 直接终止脚本；
+      // 真正的 git 失败由 runShell 统一按 exitCode 检测抛错，不依赖这里。
+      '$git = ' + psq(gitExe),
+      '$repo = ' + psq(store.repo),
+      '$g = ' + psq(store.git),
+      'if (-not (Test-Path -LiteralPath $g)) {',
+      '  & $git init $repo | Out-Null',
+      '}',
+      '& $git --git-dir=$g config core.longpaths true',
+      // autocrlf=false：按原始字节入快照（回退时逐字节还原），也避免
+      // 用户全局 autocrlf=true 时的 LF/CRLF stderr 警告；addEmbeddedRepo=false：
+      // 嵌套仓库 hint/warning 走 stderr，在 DSH shell（EAP=Stop）下会让
+      // 整条脚本非零退出，必须在仓库级配置里静默掉。
+      '& $git --git-dir=$g config core.autocrlf false',
+      '& $git --git-dir=$g config advice.addEmbeddedRepo false',
+      "Set-Content -LiteralPath (Join-Path $g 'info\\exclude') -Value \"`n.git`nnode_modules/`n.dsh-recall-snapshots/\" -Encoding utf8 -NoNewline",
+      "Write-Output 'GIT_OK'"
+    ].join('\n')
+    try {
+      await runShell(script, { stdoutMaxBytes: 4096 }, sessionId)
+      state.gitReady.add(store.git)
+      return true
+    } catch (error) {
+      console.error('recall ensureGit failed:', String(error))
+      return false
+    }
+  }
+
+  // 快照：git add -A 增量同步 index（.gitignore/exclude 语义由 git 统一处理），
+  // 剔除超大文件（参考 TraeWork update_snapshot_file_over_size 的跳过策略），
+  // write-tree 生成树、commit-tree 生成无父孤儿提交、tag 保对象可达。
+  // 不做 parent 链、不修剪：像 TraeWork 一样保留全量历史，tag 永远可查。
+  //
+  // 嵌套 git 仓库（工作区里的子项目自带 .git）会被 add -A 记成 gitlink（160000）；
+  // gitlink 残留在 index 时 add -A 会 fatal "in unpopulated submodule"，
+  // 且 gitlink 对文件回退毫无意义——所以 add 前后各清一次，子仓库内容不进快照。
+  // 依赖外层脚本已定义的 $git/$g；返回的行片段嵌入 snapshot/diff/rollback 三处
+  function dropGitlinksScript() {
+    return [
+      "& $git --git-dir=$g ls-files --stage | Where-Object { $_ -like '160000*' } | ForEach-Object {",
+      "  $p = ($_ -split \"`t\")[1]",
+      '  & $git --literal-pathspecs --git-dir=$g update-index --force-remove -- $p',
+      '}'
+    ].join('\n')
+  }
+
+  function snapshotScript(root, store, gitExe, messageId) {
+    const sync = [
+      "$ErrorActionPreference = 'Stop'",
+      // 不设 PSNativeCommandUseErrorActionPreference：git 的 stderr 警告（hint 等）
+      // 在 DSH shell 注入方式下会被包成 ErrorRecord，配上 EAP=Stop 直接终止脚本；
+      // 真正的 git 失败由 runShell 统一按 exitCode 检测抛错，不依赖这里。
+      '$git = ' + psq(gitExe),
+      '$g = ' + psq(store.git),
+      '$root = ' + psq(root),
+      dropGitlinksScript(),
+      '& $git --git-dir=$g --work-tree=$root add -A',
+      dropGitlinksScript(),
+      'Get-ChildItem -LiteralPath $root -Recurse -File -Force | Where-Object { $_.Length -gt ' + MAX_FILE_BYTES + ' } | ForEach-Object {',
+      "  $rel = $_.FullName.Substring($root.Length + 1).Replace('\\','/')",
+      '  & $git --literal-pathspecs --git-dir=$g update-index --force-remove -- $rel',
+      '}',
+      '$tree = (& $git --git-dir=$g --work-tree=$root write-tree).Trim()',
+      "$commit = (& $git --git-dir=$g -c user.name=dsh-recall -c user.email=recall@dsh.local commit-tree $tree -m ('snapshot ' + " + psq(messageId) + ")).Trim()",
+      '& $git --git-dir=$g tag ' + psq('snap-' + messageId) + ' $commit | Out-Null',
+      "Write-Output 'SNAP_OK'"
+    ]
+    return sync.join('\n')
+  }
+
+  // diff：把当前状态 add 进 index 后用 ls-files --stage 取当前清单，
+  // 与目标 tag 的 ls-tree 对比——ignore/exclude 语义两侧一致，不会把
+  // node_modules 等误报为“新增”。
+  // 不用 -z：PowerShell 捕获原生命令输出会丢弃含 NUL 的行（实测整段变 null），
+  // 改用 core.quotePath=false 让非 ASCII 路径原样输出，逐行按 TAB 解析；
+  // [Console]::OutputEncoding=UTF8 保证中文路径正确解码。
+  // 代价是文件名含换行的极端情况会解析错乱——概率可忽略，记录为已知限制。
+  function diffScript(root, store, gitExe, tag) {
+    const script = [
+      "$ErrorActionPreference = 'Stop'",
+      '$OutputEncoding = [Text.UTF8Encoding]::new($false)',
+      'try { [Console]::OutputEncoding = [Text.UTF8Encoding]::new($false) } catch {}',
+      '$git = ' + psq(gitExe),
+      '$g = ' + psq(store.git),
+      '$root = ' + psq(root),
+      dropGitlinksScript(),
+      '& $git --git-dir=$g --work-tree=$root add -A',
+      dropGitlinksScript(),
+      'Get-ChildItem -LiteralPath $root -Recurse -File -Force | Where-Object { $_.Length -gt ' + MAX_FILE_BYTES + ' } | ForEach-Object {',
+      "  $rel = $_.FullName.Substring($root.Length + 1).Replace('\\','/')",
+      '  & $git --literal-pathspecs --git-dir=$g update-index --force-remove -- $rel',
+      '}',
+      '$curOut = & $git -c core.quotePath=false --git-dir=$g --work-tree=$root ls-files --stage',
+      // 旧 tag 的树里可能仍有 gitlink（修复前留下的），从目标侧一并剔除，
+      // 否则 diff 会报出“恢复 dsh-recall-plugin”这类幻影条目
+      "$targetOut = @(& $git -c core.quotePath=false --git-dir=$g ls-tree -r " + psq(tag) + " | Where-Object { -not $_.StartsWith('160000') })",
+      '$curMap = @{}',
+      'foreach ($r in @($curOut)) {',
+      '  if (-not $r) { continue }',
+      '  $tab = $r.IndexOf("`t"); $path = $r.Substring($tab + 1)',
+      '  $sha = ($r.Substring(0, $tab) -split " ")[1]',
+      '  $curMap[$path] = $sha',
+      '}',
+      '$targetMap = @{}',
+      'foreach ($r in @($targetOut)) {',
+      '  if (-not $r) { continue }',
+      '  $tab = $r.IndexOf("`t"); $path = $r.Substring($tab + 1)',
+      '  $sha = ($r.Substring(0, $tab) -split " ")[2]',
+      '  $targetMap[$path] = $sha',
+      '}',
+      '$result = @()',
+      'foreach ($k in $curMap.Keys) {',
+      '  if (-not $targetMap.ContainsKey($k)) { $result += [pscustomobject]@{ rel = $k; kind = "added" } }',
+      '  elseif ($targetMap[$k] -ne $curMap[$k]) { $result += [pscustomobject]@{ rel = $k; kind = "modified" } }',
+      '}',
+      'foreach ($k in $targetMap.Keys) {',
+      '  if (-not $curMap.ContainsKey($k)) { $result += [pscustomobject]@{ rel = $k; kind = "restored" } }',
+      '}',
+      '$sorted = @($result | Sort-Object rel)',
+      'Write-Output (ConvertTo-Json -InputObject $sorted -Depth 3 -Compress)'
+    ]
+    return script.join('\n')
+  }
+
+  // 回退：archive 生成 zip 直接落盘（二进制不经 shell 文本管道），
+  // Expand-Archive 覆盖回工作区；再删除“当前有、目标无”的文件。
+  // 空树跳过 archive（空 zip 会让 Expand-Archive 报错），只执行删除。
+  // 回退后保留快照 tag 与索引：git delta 空间便宜，保留历史可再次
+  // 用该快照恢复（幂等），也避免误回退后无法找回。
+  function rollbackScript(root, store, gitExe, tag) {
+    const script = [
+      "$ErrorActionPreference = 'Stop'",
+      '$OutputEncoding = [Text.UTF8Encoding]::new($false)',
+      'try { [Console]::OutputEncoding = [Text.UTF8Encoding]::new($false) } catch {}',
+      '$git = ' + psq(gitExe),
+      '$g = ' + psq(store.git),
+      '$root = ' + psq(root),
+      dropGitlinksScript(),
+      '& $git --git-dir=$g --work-tree=$root add -A',
+      dropGitlinksScript(),
+      'Get-ChildItem -LiteralPath $root -Recurse -File -Force | Where-Object { $_.Length -gt ' + MAX_FILE_BYTES + ' } | ForEach-Object {',
+      "  $rel = $_.FullName.Substring($root.Length + 1).Replace('\\','/')",
+      '  & $git --literal-pathspecs --git-dir=$g update-index --force-remove -- $rel',
+      '}',
+      // 同 diffScript：-z 的 NUL 输出会被 PowerShell 捕获丢弃，改为逐行 + quotePath=false
+      '$curOut = & $git -c core.quotePath=false --git-dir=$g --work-tree=$root ls-files --stage',
+      // 旧 tag 的树里可能仍有 gitlink（修复前留下的），从目标侧一并剔除，
+      // 否则 diff 会报出“恢复 dsh-recall-plugin”这类幻影条目
+      "$targetOut = @(& $git -c core.quotePath=false --git-dir=$g ls-tree -r " + psq(tag) + " | Where-Object { -not $_.StartsWith('160000') })",
+      '$targetMap = @{}',
+      'foreach ($r in @($targetOut)) {',
+      '  if (-not $r) { continue }',
+      '  $tab = $r.IndexOf("`t"); $path = $r.Substring($tab + 1)',
+      '  $targetMap[$path] = $true',
+      '}',
+      '$restored = $targetMap.Count',
+      'if ($restored -gt 0) {',
+      '  $zip = ' + psq(store.dir + '\\restore-tmp.zip'),
+      '  & $git --git-dir=$g archive --format=zip --output=$zip ' + psq(tag),
+      '  Expand-Archive -LiteralPath $zip -DestinationPath $root -Force',
+      '  Remove-Item -LiteralPath $zip -Force',
+      '}',
+      '$deleted = 0',
+      'foreach ($r in @($curOut)) {',
+      '  if (-not $r) { continue }',
+      '  $tab = $r.IndexOf("`t"); $path = $r.Substring($tab + 1)',
+      '  if (-not $targetMap.ContainsKey($path)) {',
+      "    $full = Join-Path $root ($path.Replace('/','\\'))",
+      '    if (Test-Path -LiteralPath $full) { Remove-Item -LiteralPath $full -Force; $deleted++ }',
+      '  }',
+      '}',
+      "Write-Output ('ROLLBACK_OK ' + $deleted + ' ' + $restored)"
+    ]
+    return script.join('\n')
+  }
+
+  function listTagsScript(store, gitExe) {
+    return [
+      "$ErrorActionPreference = 'Stop'",
+      // 不设 PSNativeCommandUseErrorActionPreference：git 的 stderr 警告（hint 等）
+      // 在 DSH shell 注入方式下会被包成 ErrorRecord，配上 EAP=Stop 直接终止脚本；
+      // 真正的 git 失败由 runShell 统一按 exitCode 检测抛错，不依赖这里。
+      '$git = ' + psq(gitExe),
+      '$g = ' + psq(store.git),
+      '& $git --git-dir=$g tag -l "snap-*"'
+    ].join('\n')
+  }
+
+  // 索引写入合并为单次 shell 调用：pwsh 进程启动是主要耗时，能省一次是一次
+  async function saveIndex(root, sessionId) {
+    const store = state.stores.get(root)
+    if (!store) return
+    const entries = Array.from(state.snapshots.entries())
+      .filter(([, s]) => s.root === root)
+      .map(([id, s]) => ({ id, time: s.time, count: s.count, sessionId: s.sessionId }))
+    const json = JSON.stringify(entries)
+    try {
+      const b64 = Buffer.from(json, 'utf8').toString('base64')
+      await runShell("New-Item -ItemType Directory -Force -Path " + psq(store.dir) + " | Out-Null; [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('" + b64 + "')) | Set-Content -LiteralPath " + psq(store.dir + '\\index.json') + ' -Encoding utf8 -NoNewline', { stdoutMaxBytes: 4096 }, sessionId)
+    } catch (error) {
+      console.error('recall saveIndex failed:', String(error))
+    }
+  }
+
+  async function loadIndex(root, sessionId) {
+    if (state.indexLoaded.has(root)) return
+    state.indexLoaded.add(root)
+    const store = state.stores.get(root)
+    if (!store) return
+    try {
+      const raw = stripBom(await runShell('Get-Content -LiteralPath ' + psq(store.dir + '\\index.json') + ' -Raw -ErrorAction SilentlyContinue', { stdoutMaxBytes: 4194304 }, sessionId)).trim()
+      if (!raw) return
+      const entries = JSON.parse(raw)
+      if (!Array.isArray(entries)) 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(),
+          count: typeof entry.count === 'number' ? entry.count : 0,
+          sessionId: entry.sessionId || sessionId
+        })
+      }
+    } catch (error) {
+      /* 索引缺失或损坏时按空历史处理 */
+    }
+  }
+
+  // 索引丢失时从仓库 tag 重建：tag 名 snap-<messageId> 本身就是快照主键
+  async function rebuildOrphans(root, sessionId) {
+    const store = state.stores.get(root)
+    const gitExe = await resolveGit()
+    if (!store || !gitExe) return
+    try {
+      const listing = stripBom(await runShell(listTagsScript(store, gitExe), { stdoutMaxBytes: 4194304 }, sessionId)).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, count: 0, sessionId })
+      }
+      await saveIndex(root, sessionId)
+    } catch (error) {
+      console.error('recall rebuildOrphans failed:', String(error))
+    }
+  }
+
+  // 迁移收尾：删除旧版 blobs 格式的项目内 .dsh-recall-snapshots 目录，
+  // 仅在 home 存储可用时执行——降级场景下该目录就是新 store，不能删。
+  function cleanupLegacy(root, sessionId) {
+    const store = state.stores.get(root)
+    if (!store || !store.home) return
+    runShell('Remove-Item -Recurse -Force -LiteralPath ' + psq(root + '\\.dsh-recall-snapshots'), { timeoutMs: 120000, stdoutMaxBytes: 4096 }, sessionId).catch(() => {})
+  }
+
+  async function captureSnapshot(sessionId, messageId, time) {
+    const root = await resolveRoot(sessionId)
+    if (!root) return
+    let store = await resolveStore(root, sessionId)
+    store = await tryUpgradeToHome(root, sessionId)
+    const ok = await ensureGit(root, store, sessionId)
+    if (!ok) return
+    await loadIndex(root, sessionId)
+    try {
+      await runShell(snapshotScript(root, store, state.gitExe, messageId), { timeoutMs: 600000, stdoutMaxBytes: 65536 }, sessionId)
+      state.snapshots.set(String(messageId), { root, time: time || Date.now(), count: 0, sessionId })
+      await saveIndex(root, sessionId)
+    } catch (error) {
+      console.error('recall snapshot failed:', String(error))
+    }
+  }
+
+  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
+    const text = stripBom(await runShell(diffScript(snap.root, store, state.gitExe, 'snap-' + messageId), { timeoutMs: 600000, stdoutMaxBytes: 4194304 }, snap.sessionId))
+    const trimmed = text.trim()
+    if (!trimmed) return []
+    const parsed = JSON.parse(trimmed)
+    if (Array.isArray(parsed)) return parsed
+    if (parsed && typeof parsed === 'object') return [parsed]
+    return []
+  }
+
+  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 = stripBom(await runShell(rollbackScript(snap.root, store, state.gitExe, 'snap-' + messageId), { timeoutMs: 600000, stdoutMaxBytes: 65536 }, snap.sessionId))
+    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
+  }
+
+  // ---- HTTP API（Client 半经由 fetch 调用；动态插件的 harness RPC 在此换成 webServer 路由）----
+
+  async function readJsonBody(req) {
+    const chunks = []
+    for await (const chunk of req) chunks.push(chunk)
+    const text = Buffer.concat(chunks).toString('utf8')
+    if (!text.trim()) return {}
+    return JSON.parse(text)
+  }
+
+  function sendJson(res, status, body) {
+    res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' })
+    res.end(JSON.stringify(body))
+  }
+
+  ctx.effect(() => webServer.register({
+    kind: 'prefix',
+    path: '/api/recall',
+    handler: async (req, res) => {
+      const path = (req.url || '').split('?')[0]
+      const name = path.replace(/^\/api\/recall\/?/, '').split('/')[0]
+      try {
+        const args = await readJsonBody(req)
+        if (name === 'init') {
+          const sessionId = args && args.sessionId ? String(args.sessionId) : null
+          const root = await resolveRoot(sessionId)
+          if (root) {
+            let store = await resolveStore(root, sessionId)
+            store = await tryUpgradeToHome(root, sessionId)
+            await ensureGit(root, store, sessionId)
+            await loadIndex(root, sessionId)
+            await rebuildOrphans(root, sessionId)
+            cleanupLegacy(root, sessionId)
+          }
+          sendJson(res, 200, { ok: Boolean(root), root: root || null })
+          return
+        }
+        if (name === 'snapshot-info') {
+          await state.queue
+          const id = args && args.messageId ? String(args.messageId) : ''
+          const snap = state.snapshots.get(id)
+          sendJson(res, 200, { has: Boolean(snap), time: snap ? snap.time : null, id })
+          return
+        }
+        if (name === 'preview') {
+          const id = args && args.messageId ? String(args.messageId) : ''
+          const sessionId = args && args.sessionId ? String(args.sessionId) : null
+          try {
+            const changes = await diffFor(id)
+            if (changes === null) { sendJson(res, 200, { ok: false, error: '该消息没有可用的项目快照' }); return }
+            const snap = state.snapshots.get(id)
+            const cutSeq = await resolveCutSeq(sessionId, id)
+            sendJson(res, 200, { ok: true, changes, time: snap ? snap.time : null, root: snap ? snap.root : null, cutSeq })
+          } catch (error) {
+            sendJson(res, 200, { ok: false, error: String(error) })
+          }
+          return
+        }
+        if (name === 'execute') {
+          const id = args && args.messageId ? String(args.messageId) : ''
+          const sessionId = args && args.sessionId ? String(args.sessionId) : null
+          try {
+            const result = await rollbackFor(id)
+            if (!result.ok) { sendJson(res, 200, result); return }
+            // 文件回退后再解析切点：切点只依赖会话日志，与快照是否删除无关（命中缓存，瞬时）
+            const cutSeq = await resolveCutSeq(sessionId, id)
+            sendJson(res, 200, { ok: true, count: result.count, cutSeq })
+          } catch (error) {
+            sendJson(res, 200, { ok: false, error: String(error) })
+          }
+          return
+        }
+        sendJson(res, 404, { ok: false, error: 'unknown endpoint: ' + name })
+      } catch (error) {
+        sendJson(res, 500, { ok: false, error: String(error) })
+      }
+    }
+  }))
+
+  // 每条用户消息触发快照（子代理会话跳过）
+  ctx.on('session/event', (session, event) => {
+    if (!event || event.type !== 'user/message') return
+    const data = event.data
+    if (!data || typeof data.id !== 'string' || !data.id) return
+    const source = data.source
+    if (!source || source.kind !== 'user') return
+    if (session && session.header && session.header.origin === 'subagent') return
+    const messageId = data.id
+    const time = event.time
+    state.queue = state.queue
+      .then(() => captureSnapshot(session.id, messageId, time))
+      .catch((error) => console.error('recall snapshot error:', String(error)))
+  })
+
+  // 启动预热：所有已存在工作区解析存储、重建索引与孤儿快照，
+  // 并清理旧版项目内 blobs 目录（home 可用时）
+  for (const session of sessions.list()) {
+    const cwd = session && session.header && session.header.cwd
+    if (!cwd) continue
+    const sessionId = session.id
+    Promise.resolve(resolveStore(cwd, sessionId))
+      .then(() => tryUpgradeToHome(cwd, sessionId))
+      .then((store) => ensureGit(cwd, store, sessionId))
+      .then(() => loadIndex(cwd, sessionId))
+      .then(() => rebuildOrphans(cwd, sessionId))
+      .then(() => cleanupLegacy(cwd, sessionId))
+      .catch(() => {})
+  }
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "dsh-recall-plugin",
+  "version": "1.0.0",
+  "description": "DSH 消息撤回插件：在用户消息气泡旁加「撤回」按钮，把项目文件（独立影子 git 仓库快照）与对话历史（官方 fork）一并回退到该消息发送之前。",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/limbo947/dsh-recall-plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-web-react"
+      ]
+    }
+  },
+  "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",
+    "cordis": "^4.0.0-rc.7",
+    "react": "^18.2.0"
+  },
+  "peerDependenciesMeta": {
+    "cordis": { "optional": true }
+  },
+  "license": "MIT"
+}