dsh-vscode-mode 0.25.1 → 0.27.0

package/src/pending/store.ts

@@ -5,10 +5,9 @@
 import type { PendingDecide, PendingDetail, PendingHistoryMove, PendingItem, PendingPage } from '../shared/pendingReview.js'
 import type { ReviewBlockState } from '../shared/reviewRegions.js'
 import { reviewBlocks } from '../shared/reviewRegions.js'
-import { unlink } from 'node:fs/promises'
-import { resolve, sep } from 'node:path'
+import { addedFiles } from '../reviewDb.js'
 import type { PendingWrite } from './capture.js'
-import { readText } from './capture.js'
+import { readText, pendingGaps } from './capture.js'
 import type { ShellLike, VcsImportOptions } from './vcs.js'
 import { importVcsChanges } from './vcs.js'
 import type { DecideOutcome, WriteResult } from './decide.js'
@@ -16,9 +15,10 @@ import { capabilityOf, decide, diffOf } from './decide.js'
 import { entryFromNew, isSettled, mergeEntries } from './kernel.js'
 import type { PendingEntry } from './kernel.js'
 import type { PendingFlags, StoredEntry } from './persist.js'
+import type { KeepRecord } from './persist.js'
 import {
-  dropEntry, earliestUndone, latestApplied, loadBlocks, loadEntries, pushHistory,
-  readOp, saveBlocks, saveEntry, setHistoryState, writeOp,
+  dropEntry, earliestUndone, latestApplied, loadBlocks, loadEntries, pendingDb, pushHistory,
+  readOp, saveBlocks, saveDecisions, saveEntry, setHistoryState, writeOp,
 } from './persist.js'
 
 /**
@@ -120,19 +120,43 @@ export function itemOf(stored: StoredEntry, baselineEmpty = false): PendingItem
   return item
 }
 
+/**
+ * @private
+ * @author ddj 2026年11月04号
+ * @description 从条目来源判断创建基线；任何决定历史都阻止展示层复活已推进的旧基线。
+ * @param cwd 工作区
+ * @param stored 累计条目
+ * @param sourceAdds 单次读取内的来源创建集合缓存
+ * @returns 是否将展示基线置空
+ */
+function emptyBaseOf(cwd: string, stored: StoredEntry, sourceAdds = new Map<string, Set<string>>()): boolean {
+  if (isSettled(stored.entry)) return false
+  const decided = pendingDb(cwd).prepare('SELECT 1 FROM pending_history WHERE entry_id=? LIMIT 1').get(stored.entry.id)
+  if (decided) return false
+  for (const sourceId of stored.entry.sessionIds) {
+    let createdPaths = sourceAdds.get(sourceId)
+    if (!createdPaths) {
+      createdPaths = addedFiles(cwd, sourceId)
+      sourceAdds.set(sourceId, createdPaths)
+    }
+    if (createdPaths.has(stored.entry.id)) return true
+  }
+  return false
+}
+
 /**
  * @author ddj 2026年10月29号
- * @description: 读一页待审条目，按更新时间升序；会话过滤走血缘集合。
+ * @description: 读工作区全部待审条目，按更新时间升序；来源会话仅用于追溯。
  * @param cwd 工作区
- * @param sessionId 当前会话
- * @param wholeAdd 本次会话新建的文件身份集合，命中时基线置空
+ * @param _sessionId 兼容旧调用签名，不再用于可见性过滤
  * @returns 列表
  */
-export function loadPage(cwd: string, sessionId?: string, wholeAdd?: ReadonlySet<string>): PendingPage {
+export function loadPage(cwd: string, _sessionId?: string): PendingPage {
   const all = loadEntries(cwd)
-  const visible = sessionId ? all.filter((stored) => stored.entry.sessionIds.includes(sessionId)) : all
-  const items = visible.map((stored) => itemOf(stored, wholeAdd?.has(stored.entry.id) === true))
-  const gaps: string[] = []
+  const visible = all
+  const sourceAdds = new Map<string, Set<string>>()
+  const items = visible.map((stored) => itemOf(stored, emptyBaseOf(cwd, stored, sourceAdds)))
+  const gaps: string[] = pendingGaps(cwd)
   for (const stored of visible) {
     if (stored.flags.oversized) gaps.push(`${stored.entry.path}: 文本超出上限，仅保留标记`)
   }
@@ -150,9 +174,10 @@ export function loadPage(cwd: string, sessionId?: string, wholeAdd?: ReadonlySet
 export function loadDetail(cwd: string, id: string, baselineEmpty = false): PendingDetail | null {
   const stored = loadEntries(cwd).find((item) => item.entry.id === id)
   if (!stored) return null
-  const diff = diffOf(stored.entry, baselineEmpty)
+  const emptyBase = baselineEmpty || emptyBaseOf(cwd, stored)
+  const diff = diffOf(stored.entry, emptyBase)
   return {
-    item: itemOf(stored, baselineEmpty),
+    item: itemOf(stored, emptyBase),
     diff,
     blocks: blockStatesOf(stored.entry),
     capability: capabilityOf(stored.entry, stored.flags),
@@ -229,19 +254,19 @@ export function writerFor(
     } catch {
       return { ok: false, reason: 'resolve-failed' }
     }
-    const current = await readText(fs, target).catch(() => undefined)
-    if (current === undefined) return { ok: false, reason: 'read-failed' }
-    // 撤销「Revert 删除新建文件」时文件已不存在，只有显式允许重建才放行
-    const recreate = allowCreate && current === null
-    if (!recreate && current !== expected) return { ok: false, reason: 'diverged' }
-    const currentStat = await fs.stat(target, signal).catch(() => undefined)
+    const snapshot = await stableRead(fs, target, signal)
+    if (!snapshot.ok) return snapshot
+    // 缺失仅允许撤销/重做重建；原子 createIfAbsent 防止检查后被其他写入抢占。
+    const recreate = allowCreate && snapshot.content === null
+    if (!recreate && snapshot.content !== expected) return { ok: false, reason: 'diverged' }
+    if (snapshot.content === null && !recreate) return { ok: false, reason: 'missing' }
+    const intent = recreate
+      ? { kind: 'createIfAbsent' }
+      : { kind: 'replaceIfVersion', version: snapshot.version }
     try {
-      // 第五个实参是沙箱策略；缺它时 provider 会以 FS_SANDBOX_DENIED 拒绝写入
-      const written = await fs.writeText(
-        target, content ?? '', currentStat ? { kind: 'replaceIfVersion', version: currentStat.version } : undefined, signal, policy,
-      )
+      const written = await fs.writeText(target, content ?? '', intent, signal, policy)
       const readBack = await readText(fs, target)
-      if ((content ?? '') !== (readBack ?? '')) return { ok: false, reason: 'read-back-mismatch' }
+      if (content !== readBack) return { ok: false, reason: 'read-back-mismatch' }
       if (content === null && readBack !== null) return { ok: false, reason: 'delete-failed' }
       void written
       return { ok: true, content }
@@ -273,7 +298,7 @@ export async function applyDecide(
     blocks: beforeBlocks,
     now: Date.now(),
     write: (content) => {
-      if (content === null) return deleteTarget(fs, cwd, stored.entry.id, signal)
+      if (content === null) return deleteTarget(fs, cwd, stored.entry.id, stored.entry.newText, signal, policy)
       return writerFor(fs, cwd, stored.entry.id, stored.entry.newText, signal, policy)(content)
     },
   })
@@ -289,6 +314,80 @@ export async function applyDecide(
   return outcome
 }
 
+/** 批量 Keep 的目标条目：display 只用于回报，operationId 由 host 按批次派生。 */
+export interface PendingKeepTarget {
+  id: string
+  display: string
+  operationId: string
+}
+/** 批量 Keep 的结果：kept 是真正推进到保留态的条目，skipped 说明该条为什么没保留。 */
+export interface PendingKeepOutcome {
+  kept: { id: string; path: string }[]
+  skipped: { id: string; display: string; reason: string }[]
+}
+
+/**
+ * @public
+ * @author ddj 2026年11月03号
+ * @description: 一次读取全表后批量保留待审条目（Keep 不写盘）。写入用刚读到的最新 revision，
+ * 客户端快照漂移不会整批中止；单条 oversized、不存在或落库时被抢先推进只跳过自己。
+ * @param cwd 工作区
+ * @param items 待保留条目
+ * @returns 保留成功与跳过的明细
+ * @throws 待审库迁移未就绪等存储级异常
+ */
+export async function keepAll(cwd: string, items: PendingKeepTarget[]): Promise<PendingKeepOutcome> {
+  const stored = new Map(loadEntries(cwd).map((item) => [item.entry.id, item]))
+  const now = Date.now()
+  const outcome: PendingKeepOutcome = { kept: [], skipped: [] }
+  const records: KeepRecord[] = []
+
+  for (const item of items) {
+    const before = stored.get(item.id)
+    if (!before) {
+      outcome.skipped.push({ id: item.id, display: item.display, reason: '待审条目不存在' })
+      continue
+    }
+    if (before.flags.oversized) {
+      outcome.skipped.push({ id: item.id, display: item.display, reason: '文本超出上限，不能整文件保留' })
+      continue
+    }
+    // 已经是保留态：幂等无操作，仍算保留成功
+    if (isSettled(before.entry)) {
+      outcome.kept.push({ id: item.id, path: before.entry.path })
+      continue
+    }
+
+    const beforeBlocks = blockStatesOf(before.entry)
+    const outcomeOf = await decide({
+      request: { sessionId: before.entry.sessionId, id: item.id, revision: before.flags.revision,
+        operationId: item.operationId, decision: 'accepted', scope: 'file' },
+      entry: before.entry, flags: before.flags, blocks: beforeBlocks, now,
+      // Keep 永不写盘：真走到写回说明逻辑被改坏，宁可炸掉也不静默落盘
+      write: () => { throw new Error('批量 Keep 不写盘') },
+    })
+    if (!outcomeOf.ok) {
+      outcome.skipped.push({ id: item.id, display: item.display, reason: outcomeOf.reason })
+      continue
+    }
+    outcome.kept.push({ id: item.id, path: before.entry.path })
+    records.push({ entryId: item.id, stored: before, next: { entry: outcomeOf.entry, flags: outcomeOf.flags },
+      blocks: outcomeOf.blocks, snapshot: JSON.stringify({
+        before: { entry: before.entry, flags: before.flags, blocks: beforeBlocks },
+        after: { entry: outcomeOf.entry, flags: outcomeOf.flags, blocks: outcomeOf.blocks },
+        wrote: outcomeOf.wrote,
+      }) })
+  }
+
+  // 落库阶段被别的决定抢先推进的条目从 kept 挪到 skipped，如实反映磁盘状态
+  const displayOf = new Map(items.map((item) => [item.id, item.display]))
+  for (const conflict of saveDecisions(cwd, records)) {
+    outcome.kept = outcome.kept.filter((entry) => entry.id !== conflict.id)
+    outcome.skipped.push({ id: conflict.id, display: displayOf.get(conflict.id) ?? conflict.id, reason: conflict.reason })
+  }
+  return outcome
+}
+
 /**
  * @author ddj 2026年10月30号
  * @description: 版本库导入：把工作副本相对基线的改动折进待审条目，已存在条目按折叠规则并入。
@@ -370,7 +469,7 @@ export async function undoDecide(
 async function writeBack(
   fs: any, cwd: string, stored: StoredEntry, target: HistoryState, signal?: AbortSignal, policy?: unknown,
 ): Promise<WriteResult> {
-  if (target.flags.missing) return deleteTarget(fs, cwd, stored.entry.id, signal)
+  if (target.flags.missing) return deleteTarget(fs, cwd, stored.entry.id, stored.entry.newText, signal, policy)
   const write = writerFor(fs, cwd, stored.entry.id, stored.entry.newText, signal, policy, true)
   return write(target.entry.newText)
 }
@@ -405,48 +504,62 @@ function parseSnapshot(text: string): HistorySnapshot | null {
   }
 }
 
+/** 稳定快照；缺失与读取失败严格区分，不允许省略现存文件的版本。 */
+type StableFile = { ok: true; content: string | null; version?: string } | { ok: false; reason: string }
+
 /**
- * @author ddj 2026年10月29号
- * @description: Revert 的删除分支：FileSystem 抽象没有删除能力，只有确认仍在工作区内才用宿主 unlink。
- * @param fs 文件系统
- * @param cwd 工作区
- * @param identity 目标身份
+ * @private
+ * @author ddj 2026年11月04号
+ * @description 版本—内容—版本读取，防止将新版本令牌与旧内容拼成写入依据。
+ * @param fs 文件提供方
+ * @param target 已解析目标
  * @param signal 取消信号
- * @returns 删除结果
+ * @returns 稳定快照或拒绝原因
  */
-async function deleteTarget(fs: any, cwd: string, identity: string, signal?: AbortSignal): Promise<WriteResult> {
-  let target: any
-  try {
-    target = await fs.resolve(identity, { cwd, signal })
-  } catch {
-    return { ok: false, reason: 'resolve-failed' }
-  }
-  const currentStat = await fs.stat(target, signal).catch(() => undefined)
-  if (!currentStat) return { ok: true, content: null }
-  const absolute = String(fs.processPath(target))
-  if (!insideWorkspace(cwd, absolute)) return { ok: false, reason: 'outside-workspace' }
+async function stableRead(fs: any, target: any, signal?: AbortSignal): Promise<StableFile> {
   try {
-    await unlink(absolute)
+    const before = await fs.stat(target, signal)
+    if (!before) return { ok: true, content: null }
+    if (before.type !== 'file' || !before.version) return { ok: false, reason: 'unguarded-file' }
+    const content = await readText(fs, target, signal)
+    if (content === null) return { ok: false, reason: 'revision-mismatch' }
+    const after = await fs.stat(target, signal)
+    if (after?.type !== 'file' || after.version !== before.version) return { ok: false, reason: 'revision-mismatch' }
+    return { ok: true, content, version: before.version }
   } catch (error) {
     return { ok: false, reason: reasonOf(error) }
   }
-  const after = await fs.stat(target, signal).catch(() => undefined)
-  return after ? { ok: false, reason: 'delete-failed' } : { ok: true, content: null }
 }
 
 /**
- * @author ddj 2026年10月29号
- * @description: 判断宿主路径是否位于工作区内，Windows 下按大小写不敏感比较。
- * @param cwd 工作区
- * @param absolute 目标绝对路径
- * @returns 是否在工作区内
+ * @private
+ * @author ddj 2026年11月04号
+ * @description 通过 provider 受控删除，保留会话策略与原子版本校验；旧 Host 不回落直删。
+ * @param fs 文件提供方
+ * @param cwd 工作目录
+ * @param identity 目标身份
+ * @param expected 应有内容
+ * @param signal 取消信号
+ * @param policy 会话沙箱策略
+ * @returns 删除结果；结果不明不提交决定
  */
-function insideWorkspace(cwd: string, absolute: string): boolean {
-  const root = resolve(cwd)
-  const candidate = resolve(absolute)
-  const normalize = (value: string) => (process.platform === 'win32' ? value.toLowerCase() : value)
-  const rootKey = normalize(root).endsWith(sep) ? normalize(root) : normalize(root) + sep
-  return normalize(candidate).startsWith(rootKey)
+async function deleteTarget(
+  fs: any, cwd: string, identity: string, expected: string, signal?: AbortSignal, policy?: unknown,
+): Promise<WriteResult> {
+  if (typeof fs.deleteFile !== 'function') return { ok: false, reason: 'delete-unavailable' }
+  try {
+    const target = await fs.resolve(identity, { cwd, signal })
+    const snapshot = await stableRead(fs, target, signal)
+    if (!snapshot.ok) return snapshot
+    if (snapshot.content === null) return { ok: true, content: null }
+    if (snapshot.content !== expected) return { ok: false, reason: 'diverged' }
+
+    await fs.deleteFile(target, { version: snapshot.version }, signal, policy)
+    const after = await fs.stat(target, signal)
+    return after ? { ok: false, reason: 'delete-failed' } : { ok: true, content: null }
+  } catch (error) {
+    return { ok: false, reason: reasonOf(error) }
+  }
 }
 
 /**

package/src/pendingCompat.ts

@@ -7,8 +7,11 @@ import type { ReviewDetail, ReviewItem, ReviewPage } from './shared/review.js'
 import type { PendingDetail, PendingItem, PendingPage } from './shared/pendingReview.js'
 import { pathKeyFor } from './shared/pathKey.js'
 
-/** 进程内"已被待审接管"的路径集合；旧写入口守卫只读它，绝不碰数据库。 */
-const coveredPaths = new Set<string>()
+/**
+ * 进程内"已被待审接管"的路径集合；旧写入口守卫只读它，绝不碰数据库。
+ * 按工作区登记，来源会话仅作追溯；任一对话重建或注销都会更新同一份集合。
+ */
+const coveredWorkspace = new Map<string, Map<string, string | null>>()
 
 /** 待审条目在面板列表里的 id 前缀，用于把请求路由回待审内核。 */
 export { PENDING_PREFIX } from './shared/pendingReview.js'
@@ -138,28 +141,88 @@ export function pendingDetailOf(detail: PendingDetail, capturedAt: string, cwd?:
 }
 
 /**
- * @author ddj 2026年10月29号
+ * @author ddj 2026年11月3号
+ * @description: 覆盖登记键：工作区与路径各自归一化后再拼接，避免同一文件多种写法登记成两条。
+ * @param cwd 工作区
+ * @param path 路径
+ * @returns 覆盖登记键
+ */
+function coverKey(cwd: string, path: string): string {
+  return `${pathKey(cwd)}|${pathKey(path)}`
+}
+
+/**
+ * @private
+ * @author ddj 2026年11月04号
+ * @description: 取工作区唯一接管集合；来源对话仅保留为诊断信息。
+ * @param cwd 工作区路径
+ * @returns 路径到登记来源的映射
+ */
+function workspaceCovers(cwd: string): Map<string, string | null> {
+  const workspaceKey = pathKey(cwd)
+  const existing = coveredWorkspace.get(workspaceKey)
+  if (existing) return existing
+  const created = new Map<string, string | null>()
+  coveredWorkspace.set(workspaceKey, created)
+  return created
+}
+
+/**
+ * @author ddj 2026年11月3号
  * @description: 记住/忘记"该路径由待审投影接管"。进程内集合，绝不在旧写入口上查库（避免撞上写事务锁）。
  * @param cwd 工作区
  * @param path 路径
  * @param covered 是否接管
+ * @param sessionId 会话 id；缺省落到无归属的工作区集合
  * @returns 无
  */
-export function trackPendingCover(cwd: string, path: string, covered: boolean): void {
-  const key = `${pathKey(cwd)}|${pathKey(path)}`
-  if (covered) coveredPaths.add(key)
-  else coveredPaths.delete(key)
+export function trackPendingCover(cwd: string, path: string, covered: boolean, sessionId?: string): void {
+  const key = coverKey(cwd, path)
+  const target = workspaceCovers(cwd)
+  if (covered) target.set(key, sessionId ?? null)
+  else target.delete(key)
+}
+
+/**
+ * @author ddj 2026年11月3号
+ * @description: 用完整列表重建工作区接管集合，清除任何对话留下的过期登记。
+ * @param cwd 工作区
+ * @param sessionId 会话 id
+ * @param paths 本会话当前可见的待审条目路径
+ * @returns 无
+ */
+export function setPendingCovers(cwd: string, sessionId: string, paths: readonly string[]): void {
+  const next = new Map<string, string | null>()
+  for (const path of paths) {
+    if (path) next.set(coverKey(cwd, path), sessionId)
+  }
+  coveredWorkspace.set(pathKey(cwd), next)
+}
+
+/**
+ * @author ddj 2026年11月3号
+ * @description: 找出接管某路径的会话，用于把"谁在管"写进提示文案；仅读内存，不查库。
+ * @param cwd 工作区
+ * @param path 路径
+ * @returns 首个接管会话 id；无人接管返回 null
+ */
+export function pendingCoverOwner(cwd: string, path: string): string | null {
+  const key = coverKey(cwd, path)
+  return coveredWorkspace.get(pathKey(cwd))?.get(key) ?? null
 }
 
 /**
  * @author ddj 2026年10月29号
  * @description: 判断某路径是否已由待审投影接管；仅读进程内集合，不产生任何 IO。
+ * 所有对话按同一工作区集合判定，兼容参数不影响可见范围。
  * @param cwd 工作区
  * @param path 请求路径
+ * @param sessionId 会话 id；缺省按并集判定
  * @returns 是否已被接管
  */
-export function pendingCovers(cwd: string, path: string): boolean {
-  return coveredPaths.has(`${pathKey(cwd)}|${pathKey(path)}`)
+export function pendingCovers(cwd: string, path: string, sessionId?: string): boolean {
+  const key = coverKey(cwd, path)
+  return coveredWorkspace.get(pathKey(cwd))?.has(key) === true
 }
 
 /**

package/src/pendingRpc.ts

@@ -5,10 +5,9 @@ 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 { pendingRawId, setPendingCovers, 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 { addedFiles } from './reviewDb.js'
 import type { ShellLike } from './pending/vcs.js'
 import type { Ctx } from './store.js'
 import { policyOf } from './store.js'
@@ -83,16 +82,16 @@ 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, addedFiles(cwd, args.sessionId))
-      // 列表即登记接管关系；旧写入口守卫之后只读内存集合，不再产生数据库读
-      for (const item of page.items) trackPendingCover(cwd, item.path, true)
+      // 与统一审查入口共用来源基线，不按查看者对话切分。
+      const page = loadPage(cwd, args.sessionId)
+      // 完整工作区列表重建唯一接管集合，清除所有来源的过期登记。
+      setPendingCovers(cwd, args.sessionId, page.items.map((item) => item.path))
       return { ok: true, page }
     },
     'edrv.pending.detail': async (args: PendingRequest & { id: string }) => {
       const cwd = await kit.read(args.sessionId)
       const rawId = pendingRawId(args.id)
-      const detail = loadDetail(cwd, rawId, addedFiles(cwd, args.sessionId).has(rawId))
+      const detail = loadDetail(cwd, rawId)
       return detail ? { ok: true, detail } : { ok: false, error: '待审条目不存在' }
     },
   }
@@ -124,8 +123,8 @@ function decideHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
       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)
+      // 移除后注销工作区唯一登记，其他对话不留过期副本。
+      if (removed && path) trackPendingCover(cwd, path, false, args.sessionId)
       return { ok: true, removed }
     },
   }
@@ -168,7 +167,8 @@ function refreshHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
       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)
+        const page = loadPage(cwd, args.sessionId)
+        setPendingCovers(cwd, args.sessionId, page.items.map((item) => item.path))
         return { ok: true, imported: result.imported, changes: result.changes }
       } catch (error) {
         return { ok: false, error: failureOf(error) }

package/src/reviewCapture.ts

@@ -3,7 +3,8 @@ import { rawReviewFile, evidenceBlocks } from './reviewEvidence.js'
 import type { RawReviewFile } from './reviewEvidence.js'
 import type { ReviewSnapshot } from './shared/review.js'
 import { reviewDb } from './reviewDb.js'
-import { resolveTarget } from './store.js'
+import { cwdOfSession } from './store.js'
+import { toolTargets } from './toolTargets.js'
 import type { Ctx } from './store.js'
 import { log } from './log.js'
 
@@ -18,12 +19,19 @@ export function installEvidence(ctx: Ctx): EvidenceCapture {
   const chains = new Map<string, Map<string, ByteChain>>()
   const staged = new Map<string, Map<string, ByteChain>>()
   let stopped = false
+  const disposed = new Set<string>()
   ctx.on('tools/execute', aroundTool)
   ctx.on('session/event', onEvent)
   ctx.on('session/disposed', onDisposed)
 
   /** @private @author ddj 2026年10月27号 @param session Disposed owner. Drops optional in-memory evidence, never persisted official facts. */
-  function onDisposed(session: { id: string }): void { chains.delete(session.id) }
+  function onDisposed(session: { id: string }): void {
+    disposed.add(session.id)
+    chains.delete(session.id)
+    for (const key of staged.keys()) {
+      if ((JSON.parse(key) as unknown[])[0] === session.id) staged.delete(key)
+    }
+  }
 
   /** @private @author ddj 2026年10月27号 @returns Current bounded capture footprint, excluding transient filesystem reads. */
   function footprint(): number {
@@ -39,34 +47,67 @@ export function installEvidence(ctx: Ctx): EvidenceCapture {
   /** @private @author ddj 2026年10月27号 @param exec Allowed tool dispatch. @param next Original dispatch. @returns Original result unchanged, regardless of capture failure. */
   async function aroundTool(exec: any, next: () => Promise<any>): Promise<any> {
     const session = exec.agent?.session
-    const path = exec.arguments?.file_path
-    if (stopped || !session?.id || !['edit', 'write'].includes(exec.name) || typeof path !== 'string') return next()
-    let fs: any
-    let chain: ByteChain | undefined
-    let target: any
+    if (stopped || !session?.id) return next()
+    const captures: Array<{ fs: any; target: any; chain: ByteChain }> = []
     try {
-      if ((chains.size >= 16 && !chains.has(session.id)) || footprint() >= 32 * 1024 * 1024) return next()
-      fs = ctx.get('fs')
-      target = await resolveTarget(ctx, session, path)
-      const identity = fs.processPath(target)
-      const before = await readRaw(fs, target, exec.signal)
-      let files = chains.get(session.id)
-      if (!files) { files = new Map(); chains.set(session.id, files) }
-      if (files.size >= 64 && !files.has(identity)) return next()
-      chain = files.get(identity)
-      if (!chain) { chain = { before, after: before, busy: false, invalid: false }; files.set(identity, chain) }
-      if (chain.busy || chain.after.hash !== before.hash) chain.invalid = true
-      chain.busy = true
-    } catch { /* No trustworthy read means no undo evidence, not a failed user tool. */ }
+      const cwd = cwdOfSession(ctx, session)
+      const fs = ctx.get('fs')
+      const paths = await toolTargets(exec)
+      for (const path of paths) {
+        try {
+          const capture = await prepareRaw(fs, session.id, cwd ?? undefined, path, exec.signal)
+          if (capture) captures.push(capture)
+        } catch { /* A failed target never prevents independent targets. */ }
+      }
+    } catch { /* Optional parser absence must not fail the original tool. */ }
     try { return await next() }
     finally {
-      if (chain) {
-        try { chain.after = await readRaw(fs, target, exec.signal) } catch { chain.invalid = true }
-        chain.busy = false
+      for (const capture of captures) {
+        try {
+          const after = await readRaw(capture.fs, capture.target, exec.signal)
+          if (!stopped && !disposed.has(session.id)) {
+            capture.chain.after = after
+            if (footprint() > 32 * 1024 * 1024) {
+              capture.chain.invalid = true
+              capture.chain.before = rawReviewFile(null); capture.chain.after = rawReviewFile(null)
+            }
+          }
+        } catch { capture.chain.invalid = true }
+        capture.chain.busy = false
       }
     }
   }
 
+  /** @private @author ddj 2026年11月04号 @param sessionId Frozen owner. @param cwd Frozen workspace. @param path Patch target. @param signal Tool cancellation. @returns Reserved raw capture or no evidence. */
+  async function prepareRaw(fs: any, sessionId: string, cwd: string | undefined, path: string, signal?: AbortSignal) {
+    if (stopped || disposed.has(sessionId) || !cwd || (chains.size >= 16 && !chains.has(sessionId)) || footprint() >= 32 * 1024 * 1024) return null
+    const target = await fs.resolve(path, { cwd })
+    if (stopped || disposed.has(sessionId)) return null
+    const identity = fs.processPath(target)
+    let files = chains.get(sessionId)
+    if (!files) { files = new Map(); chains.set(sessionId, files) }
+    if (files.size >= 64 && !files.has(identity)) return null
+    let chain = files.get(identity)
+    if (chain?.busy) { chain.invalid = true; return null }
+    const empty = rawReviewFile(null)
+    if (!chain) {
+      chain = { before: empty, after: empty, busy: true, invalid: false }
+      files.set(identity, chain)
+      try { chain.before = await readRaw(fs, target, signal); chain.after = chain.before }
+      catch (error) { chain.invalid = true; chain.busy = false; throw error }
+    } else {
+      chain.busy = true
+      try {
+        const before = await readRaw(fs, target, signal)
+        if (chain.after.hash !== before.hash) chain.invalid = true
+      } catch (error) { chain.invalid = true; chain.busy = false; throw error }
+    }
+    if (stopped || disposed.has(sessionId) || footprint() > 32 * 1024 * 1024) {
+      chain.invalid = true; chain.busy = false; files.delete(identity); return null
+    }
+    return { fs, target, chain }
+  }
+
   /** @private @author ddj 2026年10月27号 @param session Source session. @param event Published official turn. Freezes the chain before the next turn can mutate it. */
   function onEvent(session: any, event: any): void {
     if (stopped || event.type !== 'workspace/changes') return