dsh-vscode-mode 0.26.0 → 0.27.0

package/src/client/ui/EditorView.ts

@@ -274,11 +274,11 @@ export function EditorView(props) {
   const [monacoErr, setMonacoErr] = React.useState(null)
   const [records, setRecords] = React.useState({})
   const [review, setReview] = React.useState({ page: null, error: '' })
+  React.useEffect(() => { setReview({ page: null, error: '' }) }, [sessionId])
   React.useEffect(() => {
-    setReview({ page: null, error: '' })
-    if (!sessionId) return undefined
+    if (!sessionId || props.visible === false) return undefined
     return subscribeReview(sessionId, setReview)
-  }, [sessionId])
+  }, [sessionId, props.visible])
   const [tabs, setTabs] = React.useState([])
   const [active, setDiskActive] = React.useState(null)
   const [planTabs, setPlanTabs] = React.useState([])
@@ -1454,12 +1454,12 @@ export function EditorView(props) {
 
   // 挂载：接入会话级共享订阅（单定时器由 recordsFeed 持有，本组件不再自建 interval）
   React.useEffect(() => {
-    if (!sessionId) return undefined
+    if (!sessionId || props.visible === false) return undefined
     const offRecords = subscribeRecords(sessionId, applyRecords)
     const offErrors = subscribeErrors(sessionId, (message) => setError('list异常:' + message))
     refreshRecords()
     return () => { offRecords(); offErrors() }
-  }, [sessionId])
+  }, [sessionId, props.visible])
 
   /**
    * 展示外部同步提示（按路径+类型去重：同一文件重复回调不重置已关闭的提示）。
@@ -1560,12 +1560,21 @@ export function EditorView(props) {
   })
 
   React.useEffect(() => {
-    const publishLsp = (servers) => setLspServers(Array.isArray(servers) ? servers : [])
+    let alive = true
+    let loading = false
+    const publishLsp = (servers) => { if (alive) setLspServers(Array.isArray(servers) ? servers : []) }
+    const refreshLsp = async () => {
+      if (loading || props.visible === false || document.hidden) return
+      loading = true
+      try { publishLsp(await refreshStatus(true)) }
+      finally { loading = false }
+    }
     const unsubscribe = onLspProgress(publishLsp)
-    void refreshStatus(true).then(publishLsp)
-    const timer = setInterval(() => { void refreshStatus(true).then(publishLsp) }, 1500)
-    return () => { unsubscribe(); clearInterval(timer) }
-  }, [sessionId])
+    void refreshLsp()
+    const timer = setInterval(refreshLsp, 1500)
+    document.addEventListener('visibilitychange', refreshLsp)
+    return () => { alive = false; unsubscribe(); clearInterval(timer); document.removeEventListener('visibilitychange', refreshLsp) }
+  }, [sessionId, props.visible])
 
   // LSP 会话：EditorView 持有权威 sessionId，直接写入 lspClient 并广播。
   // 直接调用不依赖事件时序（订阅可能晚于首次派发），广播供其它消费方复用。
@@ -1609,6 +1618,9 @@ export function EditorView(props) {
   const fileOpenRef = React.useRef(null)
   /** @private @author ddj 2026年10月08号 @param e Routed file request. Always uses the current workspace and save/preview callbacks. */
   fileOpenRef.current = (e) => {
+    if (e?.detail?.sessionId && e.detail.sessionId !== sessionId) return
+    if (e?.detail?.ownerId && e.detail.ownerId !== props?.ownerId) return
+    if (!e?.detail?.ownerId && props?.visible === false) return
     const p = e?.detail?.path
     if (!p) return
     // G9：入口统一归一为工作区相对路径（差异栏/对话链接/LSP 跳转等都经此事件）
@@ -4108,6 +4120,8 @@ export function EditorView(props) {
   }
   const tabMenuActions = (path) => ({
     'add-to-conversation': () => addRefToChat(path),
+    'forge-open': () => props.forge?.open(sessionId),
+    'forge-local': () => props.forge?.open(sessionId, true),
     'split-left': () => splitTab(path, 'left'),
     'split-right': () => splitTab(path, 'right'),
     'split-top': () => splitTab(path, 'top'),
@@ -4144,6 +4158,7 @@ export function EditorView(props) {
       cwd,
       hasSession: Boolean(sessionId),
       canAddToConversation: Boolean(addToConversation),
+      forgeReady: props.forge?.available() === true,
       canSplit: workbench.groups.length < GROUP_LIMIT && !workbench.floats.some((item) => item.group === ownerOf(workbench, tabMenu.path)?.id),
       canFloat: workbench.groups.length < GROUP_LIMIT,
       canReturn: ownerOf(workbench, tabMenu.path)?.id !== MAIN_GROUP,
@@ -4442,6 +4457,25 @@ export function EditorView(props) {
   function consumeDrag() { return dragRef.current?.consumeClick() ?? false }
   /** @private @author ddj 2026年10月14号 @param path File. @param event Context trigger. */
   function paneMenu(path, event) { setTabMenu({ path, x: event.clientX, y: event.clientY }) }
+  const menuOwner = React.useRef({ sessionId, scope, alive: true })
+  menuOwner.current.sessionId = sessionId
+  menuOwner.current.scope = scope
+  const menuValid = React.useRef(null)
+  React.useEffect(() => {
+    menuOwner.current.alive = props.visible !== false
+    return () => { menuOwner.current.alive = false; if (menuValid.current) props.officialMenus?.invalidate(menuValid.current) }
+  }, [sessionId, scope, props.visible, props.officialMenus])
+  React.useEffect(() => {
+    if (!tabMenu || !props.officialMenus || !sessionId) return
+    const capturedSession = sessionId
+    const capturedScope = scope
+    const path = tabMenu.path
+    const groupId = ownerOf(benchRef.current, path)?.id
+    const valid = () => menuOwner.current.alive && menuOwner.current.sessionId === capturedSession && menuOwner.current.scope === capturedScope && ownerOf(benchRef.current, path)?.id === groupId && tabsRef.current.some((tab) => tab.path === path)
+    menuValid.current = valid
+    const items = tabMenuEntries().map((entry) => ({ ...entry, run: entry.onClick ?? (() => {}) }))
+    if (props.officialMenus.open('tab', sessionId, path, { x: tabMenu.x, y: tabMenu.y }, items, valid)) setTabMenu(null)
+  }, [tabMenu, props.officialMenus, sessionId, scope])
   /** @private @author ddj 2026年10月14号 @param group Auxiliary group. Return documents rather than closing them. */
   function returnPane(group) { acceptLayout(returnGroup(benchRef.current, group)) }
   /** @private @author ddj 2026年10月14号 @param group Float id. @param rect Viewport-safe bounds. */
@@ -5047,6 +5081,9 @@ export function EditorView(props) {
     editor: () => editorRef.current,
     outlineSources: props.outlineSources,
     fileMenuItems: props.fileMenuItems,
+    officialMenus: props.officialMenus,
+    visible: props.visible,
+    forge: props.forge,
     addToConversation,
     svn: svnStatus,
     // SVN 变更：面板列表 + 文件树徽标查表（客户端合成，不改 listDir 契约）

package/src/client/ui/OfficialSideTab.ts

@@ -11,7 +11,7 @@ import React from 'react'
 import { pickSessionScope } from '../sessionScope.js'
 import { EditorView } from './EditorView.js'
 import { setSideEditorMounted } from '../sidebarBridge.js'
-import { editorMountEpoch, markEditorActive, markEditorMounted, parseOfficialFileAddress, resolveNavLine, resolveNavOpen } from '../officialSidebar.js'
+import { editorMountEpoch, markEditorActive, markEditorMounted, parseOfficialFileAddress, resolveNavLine, resolveNavColumn, resolveNavOpen } from '../officialSidebar.js'
 
 /**
  * 官方侧边栏 Tab 正文组件（keyed slot sidebar.right.pane.tab 装配）。
@@ -22,10 +22,14 @@ export function OfficialSideTab(props) {
   const sessionId = props?.sessionId
   const useTabInfo = props?.useTabInfo
   let navigation
+  let tab
+  let visible = true
   // useTabInfo 是 slot 框架按组件实例生成的 hook，须在组件顶层无条件调用
   if (typeof useTabInfo === 'function') {
     try {
-      navigation = useTabInfo()?.tab?.navigation
+      tab = useTabInfo()?.tab
+      navigation = tab?.navigation
+      visible = tab?.visible !== false
     } catch {
       navigation = undefined
     }
@@ -67,16 +71,16 @@ export function OfficialSideTab(props) {
     // file 资源 Tab：地址即文件（解码出真实路径，透传 params.line 行号定位）
     const fileHit = parseOfficialFileAddress(navigation?.address)
     if (fileHit) {
-      const line = navigation?.params?.line
+      const line = resolveNavLine(navigation?.params)
       window.dispatchEvent(new CustomEvent('edrv:open-editor', {
-        detail: { path: fileHit.path, line: typeof line === 'number' ? line : undefined, preview: navigation?.params?.preview },
+        detail: { sessionId, ownerId: tab?.id, path: fileHit.path, line, column: resolveNavColumn(navigation?.params), preview: navigation?.params?.preview },
       }))
       return
     }
     // 页类型 Tab：params 携带打开请求（line = 行引用/工具行跳转的行号定位）
     const request = resolveNavOpen(navigation?.params)
     window.dispatchEvent(new CustomEvent('edrv:open-editor', {
-      detail: { path: request.path, focusDiff: request.focusDiff, line: resolveNavLine(navigation?.params), preview: navigation?.params?.preview },
+      detail: { sessionId, ownerId: tab?.id, path: request.path, focusDiff: request.focusDiff, line: resolveNavLine(navigation?.params), column: resolveNavColumn(navigation?.params), preview: navigation?.params?.preview },
     }))
   })
 
@@ -84,11 +88,15 @@ export function OfficialSideTab(props) {
     key: sessionId,
     sessionId,
     layout: 'side',
+    visible,
+    ownerId: tab?.id,
     schedule: props?.schedule,
     addToConversation: props?.addToConversation,
     sidebarPanels: props?.sidebarPanels,
     outlineSources: props?.outlineSources,
     fileMenuItems: props?.fileMenuItems,
+    officialMenus: props?.officialMenus,
+    forge: props?.forge,
     fileOpeners: props?.fileOpeners,
     sessions: props?.sessions,
   })

package/src/pending/capture.ts

@@ -2,15 +2,32 @@
  * 待审差异采集：环绕一次文件写入读取真实前后内容，只有内容确实变化才落库。
  * @author ddj 2026年10月29号
  */
-import { cwdOf } from '../registry.js'
-import { resolveTarget } from '../store.js'
+import { cwdOfSession } from '../store.js'
 import type { Ctx } from '../store.js'
 import { log } from '../log.js'
+import { toolTargets, patchDiagnostics } from '../toolTargets.js'
+import { rawText, rawReviewFile } from '../reviewEvidence.js'
 
 /** 可被采信为待审来源的写文件工具。 */
-const WRITE_TOOLS = ['edit', 'write', 'str_replace_editor']
+const WRITE_TOOLS = ['edit', 'write', 'str_replace_editor', 'apply_patch']
 /** 单文件文本上限：超过即标注 oversized，不静默截断。 */
 const MAX_TEXT = 1024 * 1024
+const captureGaps = new Map<string, { cwd: string; sessionId: string; message: string }>()
+
+/** @public @author ddj 2026年11月04号 @param cwd Workspace identity. @returns Bounded runtime-only capture diagnostics. */
+export function pendingGaps(cwd: string): string[] {
+  return [...captureGaps.values()].filter((gap) => gap.cwd === cwd).map((gap) => gap.message)
+}
+
+/** @private @author ddj 2026年11月04号 @param ctx Host scope. @param exec Original call. @param path Failed target. @param error Evidence failure. Records no writable state. */
+function recordGap(scope: { cwd: string; sessionId: string }, exec: WriteExec, path: string, error: unknown): void {
+  const { cwd, sessionId } = scope
+  const key = JSON.stringify([cwd, sessionId, exec.id, path])
+  captureGaps.set(key, { cwd, sessionId, message: path + ': ' + String(error) })
+  const local = [...captureGaps].filter(([, gap]) => gap.cwd === cwd)
+  while (local.length > 50) captureGaps.delete(local.shift()![0])
+  while (captureGaps.size > 500) captureGaps.delete(captureGaps.keys().next().value!)
+}
 
 /** 一次已确认的写入。 */
 export interface PendingWrite {
@@ -33,12 +50,14 @@ export interface PendingCapture {
 interface CaptureState {
   busy: Set<string>
   stopped: boolean
+  disposed: Set<string>
 }
 
 /** 工具的写工具参数形状；只取本采集关心的字段。 */
 interface WriteExec {
+  id?: string
   name?: string
-  arguments?: { file_path?: unknown; path?: unknown }
+  arguments?: { file_path?: unknown; path?: unknown; input?: unknown }
   agent?: { session?: { id?: string; cwd?: string } }
 }
 
@@ -50,12 +69,19 @@ interface WriteExec {
  * @returns 可释放的采集器
  */
 export function installPending(ctx: Ctx, sink: (write: PendingWrite) => void): PendingCapture {
-  const state: CaptureState = { busy: new Set<string>(), stopped: false }
+  const state: CaptureState = { busy: new Set<string>(), stopped: false, disposed: new Set<string>() }
   ctx.on('tools/execute', (exec: WriteExec, next: () => Promise<unknown>) => aroundTool(ctx, state, sink, exec, next))
+  ctx.on('session/disposed', (session: { id: string }) => {
+    state.disposed.add(session.id)
+    for (const [key, gap] of captureGaps) {
+      if (gap.sessionId === session.id) captureGaps.delete(key)
+    }
+  })
   return {
     dispose(): void {
       state.stopped = true
       state.busy.clear()
+      captureGaps.clear()
     },
   }
 }
@@ -68,20 +94,24 @@ export function installPending(ctx: Ctx, sink: (write: PendingWrite) => void): P
  * @param exec 工具分发上下文
  * @returns 采集计划或 null
  */
-async function planOf(ctx: Ctx, state: CaptureState, exec: WriteExec): Promise<CapturePlan | null> {
-  const session = exec.agent?.session
-  const requested = exec.arguments?.file_path ?? exec.arguments?.path
-  if (state.stopped || !session?.id || typeof requested !== 'string') return null
-  if (!WRITE_TOOLS.includes(String(exec.name))) return null
-  const cwd = cwdOf(session as never)
-  if (!cwd) return null
-  const fs = ctx.get('fs')
-  const target = await resolveTarget(ctx, session as never, requested)
+async function planOf(scope: { cwd: string; sessionId: string; fs: any }, state: CaptureState, requested: string): Promise<CapturePlan | null> {
+  const { cwd, sessionId, fs } = scope
+  if (state.stopped || state.disposed.has(sessionId)) return null
+  const target = await fs.resolve(requested, { cwd })
   const identity = fs.processPath(target)
-  if (typeof identity !== 'string' || !identity || state.busy.has(identity)) return null
-  const before = await readText(fs, target)
-  if (before !== null && before.length > MAX_TEXT) return null
-  return { cwd: String(cwd), sessionId: String(session.id), path: requested, identity, before, session: session as never }
+  if (state.stopped || state.disposed.has(sessionId) || typeof identity !== 'string' || !identity || state.busy.has(identity)) return null
+  state.busy.add(identity)
+  try {
+    const before = await readText(fs, target)
+    if (state.stopped || state.disposed.has(sessionId) || (before !== null && before.length > MAX_TEXT)) {
+      state.busy.delete(identity)
+      return null
+    }
+    return { cwd: String(cwd), sessionId, path: requested, identity, before, target, fs }
+  } catch (error) {
+    state.busy.delete(identity)
+    throw error
+  }
 }
 
 /** 一次采集所需的固定信息。 */
@@ -91,7 +121,8 @@ interface CapturePlan {
   path: string
   identity: string
   before: string | null
-  session: never
+  target: unknown
+  fs: any
 }
 
 /**
@@ -108,58 +139,76 @@ async function aroundTool(
   ctx: Ctx, state: CaptureState, sink: (write: PendingWrite) => void,
   exec: WriteExec, next: () => Promise<unknown>,
 ): Promise<unknown> {
-  let plan: CapturePlan | null = null
+  if (state.stopped || !WRITE_TOOLS.includes(String(exec.name))) return next()
+  const session = exec.agent?.session
+  const cwd = session ? cwdOfSession(ctx, session as never) : null
+  if (!session?.id || !cwd) return next()
+  const scope = { cwd, sessionId: session.id, fs: ctx.get('fs') }
+  const plans: CapturePlan[] = []
   try {
-    plan = await planOf(ctx, state, exec)
-  } catch (error) {
-    log.debug('待审采集跳过：' + String(error))
-  }
-  if (!plan) return next()
+    const paths = await toolTargets(exec)
+    for (const path of paths) {
+      try {
+        if (plans.length >= 16) throw new Error('capture target budget exceeded')
+        const plan = await planOf(scope, state, path)
+        if (plan) plans.push(plan)
+      } catch (error) { if (!state.stopped && !state.disposed.has(scope.sessionId)) recordGap(scope, exec, path, error); log.debug('待审采集跳过：' + path + ': ' + String(error)) }
+    }
+  } catch (error) { if (!state.stopped && !state.disposed.has(scope.sessionId)) recordGap(scope, exec, String(exec.name), error); log.debug('待审目标不可用：' + String(error)) }
 
-  state.busy.add(plan.identity)
   try {
-    return await next()
+    const result = await next()
+    if (exec.name === 'apply_patch' && !state.stopped && !state.disposed.has(scope.sessionId)) {
+      for (const diagnostic of patchDiagnostics(result)) recordGap(scope, exec, 'apply_patch', diagnostic)
+    }
+    return result
   } finally {
-    state.busy.delete(plan.identity)
-    try {
-      reportWrite(ctx, sink, plan)
-    } catch (error) {
-      log.debug('待审上报失败：' + String(error))
+    for (const plan of plans) {
+      try { await reportWrite(state, sink, plan) }
+      catch (error) { if (!state.stopped && !state.disposed.has(scope.sessionId)) recordGap(scope, exec, plan.path, error); log.debug('待审上报失败：' + String(error)) }
+      finally { state.busy.delete(plan.identity) }
     }
   }
 }
 
 /**
- * @author ddj 2026年10月29号
- * @description: 写后读回并比较，内容一致视为无净变化不产生条目。
- * @param ctx Host 生命周期
+ * @author ddj 2026年11月04号
+ * @description: 固定目标写后读回；内容一致不产生条目，卸载后不再上报。
+ * @param state 采集生命周期状态
  * @param sink 已确认写入的接收方
  * @param plan 采集计划
  * @returns 无；读回失败只记日志
  */
-function reportWrite(ctx: Ctx, sink: (write: PendingWrite) => void, plan: CapturePlan): void {
-  const fs = ctx.get('fs')
-  void resolveTarget(ctx, plan.session, plan.path).then(async (target: unknown) => {
-    const after = await readText(fs, target)
-    if (after !== null && after.length > MAX_TEXT) return
-    if (plan.before === after) return
-    sink({ cwd: plan.cwd, sessionId: plan.sessionId, path: plan.path, identity: plan.identity, before: plan.before, after, now: Date.now() })
-  }).catch((error: unknown) => log.debug('待审读回失败：' + String(error)))
+async function reportWrite(state: CaptureState, sink: (write: PendingWrite) => void, plan: CapturePlan): Promise<void> {
+  if (state.stopped || state.disposed.has(plan.sessionId)) return
+  // 目录、provider 和目标均在写前冻结，切目录或卸载不能将内容串到其他工作区。
+  const after = await readText(plan.fs, plan.target)
+  if (state.stopped || state.disposed.has(plan.sessionId)) return
+  if (after !== null && after.length > MAX_TEXT) throw new Error('capture text budget exceeded')
+  for (const [key, gap] of captureGaps) {
+    const identity = JSON.parse(key) as unknown[]
+    if (gap.cwd === plan.cwd && gap.sessionId === plan.sessionId && identity[3] === plan.path) captureGaps.delete(key)
+  }
+  if (plan.before === after) return
+  sink({ cwd: plan.cwd, sessionId: plan.sessionId, path: plan.path, identity: plan.identity, before: plan.before, after, now: Date.now() })
 }
 
 /**
  * @author ddj 2026年10月29号
- * @description: 读取全文；缺失或不可读按"无内容"处理，交由上层决定语义。
+ * @description: 读取全文；只有明确缺失返回 null，不可读或超限错误保留失败语义。
  * @param fs 文件系统
  * @param target 目标
  * @returns 文本或 null
  */
-export async function readText(fs: any, target: any): Promise<string | null> {
+export async function readText(fs: any, target: any, signal?: AbortSignal): Promise<string | null> {
   try {
-    return String(await fs.readText(target))
+    if (typeof fs.readBytes === 'function') {
+      return rawText(rawReviewFile(await fs.readBytes(target, signal, MAX_TEXT)))
+    }
+    throw new Error('Raw byte capture unavailable')
   } catch (error) {
     const code = (error as { code?: string }).code
-    if (code === 'ENOENT' || code === 'FS_NOT_FOUND' || code === 'FS_TOO_LARGE') return null
+    if (code === 'ENOENT' || code === 'FS_NOT_FOUND') return null
     throw error
   }
 }

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'
@@ -18,7 +17,7 @@ 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,
+  dropEntry, earliestUndone, latestApplied, loadBlocks, loadEntries, pendingDb, pushHistory,
   readOp, saveBlocks, saveDecisions, saveEntry, setHistoryState, writeOp,
 } from './persist.js'
 
@@ -121,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}: 文本超出上限，仅保留标记`)
   }
@@ -151,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),
@@ -230,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 }
@@ -274,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)
     },
   })
@@ -445,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)
 }
@@ -480,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) }
+  }
 }
 
 /**