dsh-vscode-mode 0.21.4 → 0.23.0

package/src/pendingRpc.ts

@@ -0,0 +1,210 @@
+/** 待审投影 RPC：Keep/Revert 走累计基线，旧官方审查入口不再承接写操作。 @author ddj 2026年10月29号 */
+import type { RpcHandlerMap } from './shared/rpc.js'
+import type { PendingRequest } from './shared/pendingReview.js'
+import { resolveScope, sessionOf } from './registry.js'
+import type { Registry } from './registry.js'
+import { bucketOf } from './registry.js'
+import { readText } from './pending/capture.js'
+import { pendingRawId, trackPendingCover } from './pendingCompat.js'
+import { loadEntries, saveEntry } from './pending/persist.js'
+import { applyDecide, importFromVcs, itemOf, loadDetail, loadPage, refreshed, removeEntry, undoDecide } from './pending/store.js'
+import type { ShellLike } from './pending/vcs.js'
+import type { Ctx } from './store.js'
+import { policyOf } from './store.js'
+
+/** 处理器共享的作用域能力：读允许跨实例冷读，写必须本端 live 会话。 */
+interface ScopeKit {
+  ctx: Ctx
+  read(sessionId: string): Promise<string>
+  write(sessionId: string): Promise<string>
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 解析会话工作区并预热记录桶；读路径也走它，避免冷读时桶未就绪。
+ * @param ctx Host 上下文
+ * @param registry 工作区记录桶缓存
+ * @param sessionId 请求作用域
+ * @returns 工作区路径
+ */
+async function workspaceOf(ctx: Ctx, registry: Registry, sessionId: string): Promise<string> {
+  const scope = await resolveScope(ctx, sessionId)
+  if ('err' in scope) throw new Error('会话不存在或没有工作区')
+  await bucketOf(registry, ctx, scope.cwd)
+  return scope.cwd
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 写路径专用的工作区解析：本端没有该会话就直接拒绝，不做跨实例写。
+ * @param ctx Host 上下文
+ * @param registry 工作区记录桶缓存
+ * @param sessionId 请求作用域
+ * @returns 工作区路径
+ */
+async function writeWorkspaceOf(ctx: Ctx, registry: Registry, sessionId: string): Promise<string> {
+  const cwd = await workspaceOf(ctx, registry, sessionId)
+  if (!sessionOf(ctx, sessionId)) throw new Error('写入要求本端活跃会话')
+  return cwd
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 把异常归一成可播报文案，避免处理器各自重复三元表达式。
+ * @param error 捕获到的异常
+ * @returns 错误文案
+ */
+function failureOf(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 按会话策略包装 shell：执行器默认按 workspace-write 跑，本机无可用沙箱后端会直接拒绝。
+ * @param raw 原始 shell 能力
+ * @param policy 会话沙箱策略
+ * @returns 带策略的 shell 视图
+ */
+function shellOf(raw: ShellLike, policy: unknown): ShellLike {
+  return {
+    resolve: (request) => raw.resolve(policy ? { ...request, sandboxPolicy: policy } : request),
+    execute: (spec) => raw.execute(spec),
+  }
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 读路径处理器：列表与详情，允许跨实例冷读。
+ * @param kit 作用域能力
+ * @returns 处理器表
+ */
+function readHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
+  return {
+    'edrv.pending.list': async (args: PendingRequest) => {
+      const cwd = await kit.read(args.sessionId)
+      const page = loadPage(cwd, args.sessionId)
+      // 列表即登记接管关系；旧写入口守卫之后只读内存集合，不再产生数据库读
+      for (const item of page.items) trackPendingCover(cwd, item.path, true)
+      return { ok: true, page }
+    },
+    'edrv.pending.detail': async (args: PendingRequest & { id: string }) => {
+      const cwd = await kit.read(args.sessionId)
+      const detail = loadDetail(cwd, pendingRawId(args.id))
+      return detail ? { ok: true, detail } : { ok: false, error: '待审条目不存在' }
+    },
+  }
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 判定处理器：Keep/Revert 与已解决条目移除，都会改变待审状态。
+ * @param kit 作用域能力
+ * @returns 处理器表
+ */
+function decideHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
+  return {
+    'edrv.pending.decide': async (args) => {
+      const cwd = await kit.write(args.sessionId)
+      const id = pendingRawId(args.id)
+      try {
+        const policy = policyOf(kit.ctx, sessionOf(kit.ctx, args.sessionId))
+        const result = await applyDecide(kit.ctx.get('fs'), cwd, { ...args, id }, undefined, policy)
+        if (!result.ok) return { ok: false, error: result.reason }
+        const detail = loadDetail(cwd, id)
+        return detail ? { ok: true, item: detail.item, wrote: result.wrote } : { ok: false, error: '待审条目不存在' }
+      } catch (error) {
+        return { ok: false, error: failureOf(error) }
+      }
+    },
+    'edrv.pending.remove': async (args) => {
+      const cwd = await kit.write(args.sessionId)
+      const id = pendingRawId(args.id)
+      const path = loadEntries(cwd).find((stored) => stored.entry.id === id)?.entry.path
+      const removed = removeEntry(cwd, id, args.revision)
+      // 移除后该路径不再由待审投影接管，旧入口守卫随之放行
+      if (removed && path) trackPendingCover(cwd, path, false)
+      return { ok: true, removed }
+    },
+  }
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 历史处理器：撤销/重做一次决定。
+ * @param kit 作用域能力
+ * @returns 处理器表
+ */
+function historyHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
+  return {
+    'edrv.pending.history': async (args) => {
+      const cwd = await kit.write(args.sessionId)
+      const policy = policyOf(kit.ctx, sessionOf(kit.ctx, args.sessionId))
+      try {
+        const result = await undoDecide(kit.ctx.get('fs'), cwd, args, undefined, policy)
+        return result.ok ? { ok: true, item: result.item, wrote: result.wrote } : { ok: false, error: result.reason }
+      } catch (error) {
+        return { ok: false, error: failureOf(error) }
+      }
+    },
+  }
+}
+
+/**
+ * @author ddj 2026年10月30号
+ * @description: 投影维护处理器：从版本库导入、按磁盘现状刷新单条。
+ * @param kit 作用域能力
+ * @returns 处理器表
+ */
+function refreshHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
+  return {
+    'edrv.pending.import': async (args) => {
+      const cwd = await kit.write(args.sessionId)
+      const raw = kit.ctx.get('shell') as unknown as ShellLike | undefined
+      if (!raw) return { ok: false, error: '当前环境没有 shell 能力，无法读取版本库基线' }
+      const policy = policyOf(kit.ctx, sessionOf(kit.ctx, args.sessionId))
+      try {
+        const shell = shellOf(raw, policy)
+        const result = await importFromVcs(shell, cwd, args.sessionId, { includeUntracked: args.includeUntracked, path: args.path })
+        for (const item of loadPage(cwd, args.sessionId).items) trackPendingCover(cwd, item.path, true)
+        return { ok: true, imported: result.imported, changes: result.changes }
+      } catch (error) {
+        return { ok: false, error: failureOf(error) }
+      }
+    },
+    'edrv.pending.refresh': async (args: PendingRequest & { id: string }) => {
+      const cwd = await kit.write(args.sessionId)
+      const id = pendingRawId(args.id)
+      const stored = loadEntries(cwd).find((entry) => entry.entry.id === id)
+      if (!stored) return { ok: false, error: '待审条目不存在' }
+      const fs = kit.ctx.get('fs')
+      const session = sessionOf(kit.ctx, args.sessionId)
+      const target = await fs.resolve(id, { cwd, agent: session })
+      const content = await readText(fs, target).catch(() => undefined)
+      if (content === undefined) return { ok: false, error: '读取失败' }
+      const next = refreshed(stored, content, Date.now())
+      if (next) saveEntry(cwd, next)
+      return { ok: true, item: itemOf(next ?? stored) }
+    },
+  }
+}
+
+/**
+ * @author ddj 2026年10月29号
+ * @description: 待审投影处理器表：按用途拆成读/判定/历史/维护四组，便于分别收敛权限。
+ * @param ctx Host 上下文
+ * @param registry 工作区记录桶缓存
+ * @returns 待审相关处理器表
+ */
+export function pendingHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandlerMap> {
+  const kit: ScopeKit = {
+    ctx,
+    read: (sessionId) => workspaceOf(ctx, registry, sessionId),
+    write: (sessionId) => writeWorkspaceOf(ctx, registry, sessionId),
+  }
+  return {
+    ...readHandlers(kit),
+    ...decideHandlers(kit),
+    ...historyHandlers(kit),
+    ...refreshHandlers(kit),
+  }
+}

package/src/quickMenu.ts

@@ -0,0 +1,269 @@
+/**
+ * dsh-vscode-mode host — 快捷菜单配置的读写（~/.dsh/dsh-vscode-mode/data/quick-menu.json）。
+ *
+ * 为什么单独成模块：菜单项是用户数据而不是界面镜像——不能落在 cache/（会被 sweep、
+ * 且与 uiState 共享 512KB 预算），也不适合塞进 Config schema（嵌套 JSON 不参与校验）。
+ * 写入约定：revision 乐观并发 + 同文件串行队列 + tmp 原子替换 + 单代 .bak 备份，
+ * 解析失败时把原文件另存 .bad-<ts>.json 再回落默认文档，绝不让坏文件阻塞功能。
+ * 作者 ddj 2026年10月30号
+ */
+import { copyFile, mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import {
+  defaultDoc,
+  normalizeDoc,
+  parseDoc,
+  serializeDoc,
+  QUICK_MENU_BYTES_CAP,
+  QUICK_MENU_MAX_ITEMS,
+} from './shared/quickMenu.js'
+import type { QuickMenuDoc } from './shared/quickMenu.js'
+import { quickMenuFile } from './paths.js'
+
+/** 一次性读取结果。 */
+export interface QuickMenuState {
+  /** 合法文档（读到坏文件时为默认文档）。 */
+  doc: QuickMenuDoc
+  /** 读取告警（坏文件被备份并重置时给出）。 */
+  warning?: string
+  /** 文件最后修改时间毫秒（缺失为 0）。 */
+  mtime: number
+}
+
+/** 写入结果（冲突时把磁盘上的最新文档带回，供客户端刷新）。 */
+export type QuickMenuSaveResult =
+  | { ok: true; doc: QuickMenuDoc }
+  | { ok: false; error: string; doc?: QuickMenuDoc }
+
+/** mtime 缓存（文件未变则复用解析结果，避免每次打开菜单都读盘）。 */
+const stateCache = new Map<string, QuickMenuState>()
+
+/** 同文件写队列尾（串行化并发写入；队列清空即移除条目，与 uiState 同套路）。 */
+const writeChains = new Map<string, Promise<unknown>>()
+
+/**
+ * 把写任务挂到该文件的队尾串行执行（前序失败不影响后续）。
+ * @author ddj 2026年10月30号
+ * @param file 目标文件绝对路径
+ * @param run 实际写操作
+ * @returns 本次写操作结果
+ */
+function chainWrite<T>(file: string, run: () => Promise<T>): Promise<T> {
+  const prev = writeChains.get(file) ?? Promise.resolve()
+  const next = prev.then(run, run)
+  const tail = next.then(() => undefined, () => undefined)
+  writeChains.set(file, tail)
+  void tail.then(() => {
+    if (writeChains.get(file) === tail) writeChains.delete(file)
+  })
+  return next
+}
+
+/**
+ * 读取文件修改时间（缺失/不可读返回 0）。
+ * @author ddj 2026年10月30号
+ * @param file 文件路径
+ * @returns mtime 毫秒
+ */
+async function mtimeOf(file: string): Promise<number> {
+  try {
+    return (await stat(file)).mtimeMs
+  } catch {
+    return 0
+  }
+}
+
+/**
+ * 原子写文本（先写 .tmp 再改名，缺目录自动建；失败时尽量清掉临时文件）。
+ * @author ddj 2026年10月30号
+ * @param file 目标文件
+ * @param text 文本
+ */
+async function writeAtomic(file: string, text: string): Promise<void> {
+  await mkdir(dirname(file), { recursive: true })
+  const temporary = file + '.tmp'
+  await writeFile(temporary, text, 'utf8')
+  await rename(temporary, file)
+}
+
+/**
+ * 把坏文件另存为 .bad-<ts>.json（尽力而为，失败不影响主流程）。
+ * @author ddj 2026年10月30号
+ * @param file 源文件
+ * @returns 备份路径（失败为 null）
+ */
+async function backupCorrupt(file: string): Promise<string | null> {
+  const target = file + '.bad-' + Date.now() + '.json'
+  try {
+    await copyFile(file, target)
+    return target
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 把上一次内容写成单代备份（quick-menu.bak.json）。
+ * @author ddj 2026年10月30号
+ * @param file 源文件
+ */
+async function backupPrevious(file: string): Promise<void> {
+  try {
+    await copyFile(file, file.replace(/\.json$/, '') + '.bak.json')
+  } catch {
+    // 首次保存没有旧文件，忽略
+  }
+}
+
+/**
+ * 读盘并归一（绕过缓存；文件缺失按默认文档处理）。
+ * @author ddj 2026年10月30号
+ * @param file 文件路径
+ * @returns 文档 + 告警 + mtime
+ */
+async function loadFile(file: string): Promise<QuickMenuState> {
+  const mtime = await mtimeOf(file)
+  if (mtime === 0) return { doc: defaultDoc(), mtime: 0 }
+  let text = ''
+  try {
+    text = await readFile(file, 'utf8')
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error)
+    return { doc: defaultDoc(), warning: '快捷菜单配置读取失败（' + reason + '），已回落默认配置', mtime }
+  }
+  const parsed = parseDoc(text)
+  if (!parsed.warning) return { doc: parsed.doc, mtime }
+  // 坏文件：先备份原文件，再写回默认文档，避免每次打开都重复告警
+  const backup = await backupCorrupt(file)
+  const doc = parsed.doc
+  try {
+    await writeAtomic(file, serializeDoc(doc))
+  } catch {
+    // 只读环境/权限不足时保留告警即可，功能继续用内存默认文档
+  }
+  const hint = backup ? '已备份为 ' + backup : '备份失败'
+  return { doc, warning: parsed.warning + '（' + hint + '）', mtime }
+}
+
+/**
+ * 读取快捷菜单文档（mtime 未变时复用缓存）。
+ * @author ddj 2026年10月30号
+ * @param home DSH home（测试可注入）
+ * @returns 文档 + 告警
+ */
+export async function readQuickMenu(home?: string): Promise<QuickMenuState> {
+  const file = quickMenuFile(home)
+  const mtime = await mtimeOf(file)
+  const cached = stateCache.get(file)
+  if (cached && cached.mtime === mtime) return cached
+  const state = await loadFile(file)
+  stateCache.set(file, state)
+  return state
+}
+
+/**
+ * 清空读取缓存（测试或外部改动后强制重读）。
+ * @author ddj 2026年10月30号
+ * @param home DSH home（缺省清全部）
+ */
+export function resetMenuCache(home?: string): void {
+  if (home === undefined) stateCache.clear()
+  else stateCache.delete(quickMenuFile(home))
+}
+
+/**
+ * 校验待保存文档的硬性上限（超出即拒绝，避免静默截断用户数据）。
+ * @author ddj 2026年10月30号
+ * @param doc 待保存文档
+ * @returns 错误文案（合法为 null）
+ */
+function checkLimits(doc: QuickMenuDoc): string | null {
+  if (doc.items.length > QUICK_MENU_MAX_ITEMS) return '菜单项超过上限（' + QUICK_MENU_MAX_ITEMS + ' 项）'
+  const bytes = Buffer.byteLength(serializeDoc(doc), 'utf8')
+  if (bytes > QUICK_MENU_BYTES_CAP) return '配置超出容量上限（' + QUICK_MENU_BYTES_CAP + ' 字节）'
+  return null
+}
+
+/**
+ * 保存文档（revision 不匹配即判定为并发冲突，返回磁盘最新文档）。
+ * @author ddj 2026年10月30号
+ * @param doc 客户端提交的完整文档
+ * @param baseRevision 客户端读到的 revision
+ * @param home DSH home（测试可注入）
+ * @returns 保存结果
+ */
+export async function saveQuickMenu(
+  doc: QuickMenuDoc,
+  baseRevision: number,
+  home?: string,
+): Promise<QuickMenuSaveResult> {
+  const file = quickMenuFile(home)
+  return chainWrite(file, async () => {
+    const limit = checkLimits(doc)
+    if (limit) return { ok: false as const, error: limit }
+    const current = await loadFile(file)
+    if (current.doc.revision !== baseRevision) {
+      return { ok: false as const, error: '配置已被其他窗口修改，请重新加载后再保存', doc: current.doc }
+    }
+    const next = normalizeDoc(doc)
+    // 悬浮按钮坐标只由 patchLauncher 维护：保存表单时沿用磁盘现值，
+    // 否则「拖动/重置位置」与「保存设置」并发时会互相覆盖（曾实测重置后被旧坐标顶回）。
+    next.launcher = current.doc.launcher
+    next.revision = current.doc.revision + 1
+    next.updatedAt = new Date().toISOString()
+    try {
+      await backupPrevious(file)
+      await writeAtomic(file, serializeDoc(next))
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error)
+      return { ok: false as const, error: '快捷菜单配置写入失败：' + reason }
+    }
+    const state: QuickMenuState = { doc: next, mtime: await mtimeOf(file) }
+    stateCache.set(file, state)
+    return { ok: true as const, doc: next }
+  })
+}
+
+/**
+ * 只更新悬浮按钮坐标（不推进 revision，避免拖拽把正在编辑的表单顶掉）。
+ * @author ddj 2026年10月30号
+ * @param launcher 坐标（null 表示回到输入框锚点）
+ * @param home DSH home（测试可注入）
+ * @returns 保存结果
+ */
+export async function patchLauncher(
+  launcher: { x: number | null; y: number | null },
+  home?: string,
+): Promise<QuickMenuSaveResult> {
+  const file = quickMenuFile(home)
+  return chainWrite(file, async () => {
+    const current = await loadFile(file)
+    const next: QuickMenuDoc = {
+      ...current.doc,
+      launcher: { x: launcher.x, y: launcher.y },
+      updatedAt: new Date().toISOString(),
+    }
+    try {
+      await writeAtomic(file, serializeDoc(next))
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error)
+      return { ok: false as const, error: '保存悬浮按钮位置失败：' + reason }
+    }
+    const state: QuickMenuState = { doc: next, mtime: await mtimeOf(file) }
+    stateCache.set(file, state)
+    return { ok: true as const, doc: next }
+  })
+}
+
+/** 导出/导入时的建议文件名（浏览器侧下载用，host 不参与）。 */
+export const quickMenuBaseName = 'quick-menu.json'
+
+/**
+ * 当前 home 下的配置路径（诊断日志用）。
+ * @author ddj 2026年10月30号
+ * @param home DSH home
+ * @returns 绝对路径
+ */
+export function quickMenuPath(home?: string): string {
+  return quickMenuFile(home)
+}

package/src/reviewDb.ts

@@ -207,6 +207,9 @@ export function reviewPage(cwd: string, cursor = 0, history = false, path?: stri
 
 /** @public @author ddj 2026年10月26号 @param cwd Migrated workspace. @param path Legacy write target. @returns Whether any official version owns the file, including decided history. */
 export function hasOfficial(cwd: string, path: string): boolean {
+  // 防御：解析结果若被误当成路径传进来（不透明对象），按「无官方记录」处理，
+  // 否则 SQLite 会把对象当命名参数绑定，抛出与真实原因无关的错误。
+  if (typeof path !== 'string') return false
   const db = dbFor(cwd)
   // A read guard must not acquire a migration write lock on legacy-only databases.
   if (!db.prepare("SELECT 1 FROM sqlite_master WHERE name='review_files' AND type='table'").get()) return false

package/src/reviewRpc.ts

@@ -1,7 +1,10 @@
 /** Session-scoped official review RPC. @author ddj 2026年10月26号 */
 import type { RpcHandlerMap } from './shared/rpc.js'
+import type { PendingPage } from './shared/pendingReview.js'
 import { decideReview, reviewDetail, reviewPage } from './reviewDb.js'
 import { undoReview } from './reviewUndo.js'
+import { applyDecide, loadDetail, loadPage } from './pending/store.js'
+import { PENDING_PREFIX, mergedPage, pendingDetailOf, pendingItemOf, pendingSamePath } from './pendingCompat.js'
 import { bucketOf, resolveScope, sessionOf } from './registry.js'
 import type { Registry } from './registry.js'
 import type { Ctx } from './store.js'
@@ -31,19 +34,67 @@ export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandler
     await bucketOf(registry, ctx, scope.cwd)
     return scope.cwd
   }
+
+  /**
+   * @private
+   * @author ddj 2026年10月30号
+   * @description: 读取待审页；待审库尚未建立或迁移失败时按空页处理。
+   * 待审投影是增量能力，不能因为它让官方列表整体不可用。
+   * @param cwd 工作区
+   * @param sessionId 请求会话
+   * @returns 待审页（失败为空页）
+   */
+  function pendingPageOf(cwd: string, sessionId: string): PendingPage {
+    try { return loadPage(cwd, sessionId) }
+    catch { return { items: [], pending: 0, nextCursor: null, gaps: [] } }
+  }
+
   return {
     'edrv.review.list': async (args) => {
       const cwd = await workspace(args.sessionId)
-      return { ok: true, page: reviewPage(cwd, args.cursor, args.history, args.path) }
+      const official = reviewPage(cwd, args.cursor, args.history, args.path)
+      const pending = pendingPageOf(cwd, args.sessionId)
+      // 历史快照只属于官方通道；待审条目没有轮次历史，混进去会造出假的「轮次 0」。
+      if (args.history) return { ok: true, page: official }
+      if (args.path !== undefined) {
+        // 单文件台账（差异栏「详情」展开处）必须并上该路径的待审条目，
+        // 否则待审详情（块判定 + 批注 + 让 AI 应答）在这条入口上永远点不到。
+        const key = args.path
+        const own = pending.items.filter((item) => pendingSamePath(item.path, key)).map((item) => pendingItemOf(item, cwd))
+        // 待审接管后同路径的官方轮次行只是旧口径残影：留着会让人点进只读详情，以为没有判定入口。
+        const history = own.length ? official.items.filter((item) => !pendingSamePath(item.path, key)) : official.items
+        return { ok: true, page: { ...official, items: [...own, ...history] } }
+      }
+      // 待审投影就位后由它承接被覆盖路径，官方旧行让位，同一路径只保留一个权威
+      return { ok: true, page: mergedPage(official, pending, cwd) }
     },
     'edrv.review.detail': async (args) => {
       const cwd = await workspace(args.sessionId)
+      if (args.id.startsWith(PENDING_PREFIX)) {
+        const detail = loadDetail(cwd, args.id.slice(PENDING_PREFIX.length))
+        if (!detail) return { ok: false, error: '待审条目不存在' }
+        return { ok: true, detail: pendingDetailOf(detail, new Date(detail.item.updatedAt).toISOString(), cwd) }
+      }
       const detail = reviewDetail(cwd, args.id)
       return detail ? { ok: true, detail } : { ok: false, error: '官方审查记录不存在' }
     },
     'edrv.review.decide': async (args) => {
       // 写类操作要求 live 会话：避免两端并发写同一工作区审查库，回滚也依赖本端会话内容
       const cwd = await liveWorkspace(args.sessionId)
+      if (args.id.startsWith(PENDING_PREFIX)) {
+        // 待审条目走累计基线：Keep 零写盘，Revert 写回并读回校验
+        const result = await applyDecide(ctx.get('fs'), cwd, {
+          sessionId: args.sessionId,
+          id: args.id.slice(PENDING_PREFIX.length),
+          revision: args.revision,
+          operationId: args.operationId,
+          decision: args.decision,
+          scope: args.scope === 'hunk' ? 'block' : 'file',
+          ...(args.blockId === undefined ? {} : { blockId: args.blockId }),
+        })
+        if (!result.ok) return { ok: false, error: result.reason }
+        return { ok: true, revision: result.flags.revision }
+      }
       try {
         const result = args.decision === 'rejected'
           ? await undoReview(ctx, sessionOf(ctx, args.sessionId), cwd, args)