dsh-vscode-mode 0.25.0 → 0.26.0

package/src/client/ui/EditorView.ts

@@ -24,10 +24,12 @@ import { dbg, isDebug, rpc } from '../rpc.js'
 import { refreshFeed, subscribeErrors, subscribeRecords } from '../state/recordsFeed.js'
 import { subscribeReview, refreshReview } from '../state/reviewFeed.js'
 import { runReviewBatch } from '../reviewBatch.js'
+import { runKeepAll } from '../reviewKeepAll.js'
+import { toastDom } from '../externalOpen.js'
 import { ReviewAllConfirm } from './ReviewAllConfirm.js'
 import { reviewRegions } from '../../shared/reviewRegions.js'
 import { PENDING_PREFIX } from '../../shared/pendingReview.js'
-import { diffSummary, officialPath } from '../state/diffSummary.js'
+import { coveredPathKeys, diffPathKey, diffSummary } from '../state/diffSummary.js'
 import { emitFileChanged, emitRefresh } from '../events.js'
 import { langOf, loadMonaco, snippetLanguageOf } from '../monaco/loader.js'
 import { bindEditActions, runEditAction } from '../monaco/editActions.js'
@@ -134,7 +136,7 @@ import { clampToolbarPosition, loadToolbarPosition, saveToolbarPosition } from '
 import { editorModelPathOf } from '../dap/modelPath.js'
 import { dapTrace } from '../dap/trace.js'
 import { isSessionMissingError, sessionErrorText, sessionMissingDetail, sessionMissingTitle } from '../sessionError.js'
-import { officialDownView, SESSION_DOWN_NOTICE } from '../reviewBar.js'
+import { officialDownView, SESSION_DOWN_NOTICE, SIDECAR_KEEP_DONE } from '../reviewBar.js'
 
 /** 官方差异读取失败前缀：仅用于清理同源陈旧错误，不吞并保存类错误。@author ddj 2026年10月27号 */
 const REVIEW_LOAD_ERROR = '官方差异读取失败：'
@@ -565,14 +567,17 @@ export function EditorView(props) {
   layoutRef.current = layout
   if (!diffRendererRef.current) diffRendererRef.current = createDiffRenderer((sid, t) => dbg(sid, t))
 
+  // 已有权威通道（官方汇总 / 待审累计基线）在管的路径：旧工具记录不得再画出来，也不得被批量纳入
+  const coveredPaths = React.useMemo(() => coveredPathKeys(review.page), [review.page])
+
   const currentRecords = React.useMemo(() => {
     const list = []
     for (const rec of Object.values(records)) {
-      if (rec.archived === true || officialPath(rec.path, review.page)) continue
+      if (rec.archived === true || coveredPaths.has(diffPathKey(rec.path))) continue
       if (sameFile(rec.path, active)) list.push(rec)
     }
     return list
-  }, [records, active, cwd, review.page])
+  }, [records, active, cwd, coveredPaths])
 
   const reviewOpsRef = React.useRef(new Map())
   // 已自动结案的记录 id：防止「改动已不在文件中」的记录在刷新期间被反复提交判定
@@ -3315,8 +3320,10 @@ export function EditorView(props) {
       }
       // #endregion
       if (!res || !res.ok || !Array.isArray(res.results)) {
-        setError(res?.error ? String(res.error) : '批量处理失败')
-        return { ok: 0, fail: items.length, stale: 0 }
+        const failure = res?.error ? String(res.error) : '批量处理失败'
+        setError(failure)
+        // 真实原因要一路带到调用处：调用方按计数兜底会把 Host 原文盖掉，用户只看得到泛化文案
+        return { ok: 0, fail: items.length, stale: 0, error: failure }
       }
       let ok = 0
       let fail = 0
@@ -3336,8 +3343,9 @@ export function EditorView(props) {
       if (Object.keys(next).length) setRecords((prev) => Object.assign({}, prev, next))
       return { ok, fail, stale }
     }).catch((e) => {
-      setError('批量处理异常:' + String(e))
-      return { ok: 0, fail: items.length, stale: 0 }
+      const failure = '批量处理异常:' + String(e)
+      setError(failure)
+      return { ok: 0, fail: items.length, stale: 0, error: failure }
     })
   }
 
@@ -3470,6 +3478,33 @@ export function EditorView(props) {
     finally { batchBusyRef.current = false; if (lifetime?.live) setReviewBatchBusy(false) }
   }
 
+  /**
+   * 批量失败提示：Host 原文优先，只有拿不到原因时才按计数兜底。
+   * @author ddj 2026年11月3号
+   * @param result actMany 的结果
+   * @returns 提示文案；没有失败返回 null
+   */
+  const batchError = (result) => {
+    if (!result.error) return batchFailText(result)
+    // 会话没在当前端激活：写类 RPC 一律被 requireSession 拒绝（冷读列表却正常），
+    // 只把「会话不存在」原文丢给用户会像新故障，这里改说清「没执行、记录没动、怎么恢复」。
+    if (isSessionMissingError(result.error)) return '这个会话没在当前端激活，Keep/Undo 没有执行（记录未改动）；在会话里发一条消息激活后重试'
+    return result.error
+  }
+
+  /**
+   * 批量结果没有 Host 原文时的计数兜底文案。
+   * @author ddj 2026年11月3号
+   * @param result actMany 的结果
+   * @returns 提示文案；没有失败返回 null
+   */
+  const batchFailText = (result) => {
+    if (!result.fail) return null
+    return result.stale
+      ? `${result.fail} 处未处理（其中 ${result.stale} 处已不在文件中，只更新了记录），可刷新后重试`
+      : `${result.fail} 处未处理，可刷新后重试`
+  }
+
   const acceptFile = () => {
     if (missingNow && !officialDetail) return decideMissing(false)
     if (officialDetail) return decideOfficial(false)
@@ -3479,8 +3514,11 @@ export function EditorView(props) {
       batchBusyRef.current = false
       reloadFile(true)
       emitRefresh({ scope, paths: active ? [active] : undefined, kind: 'structure' })
-      setStatus(decideStatus('已采纳 ', result))
-      if (result.fail) setError(result.fail + ' 处差异处理失败（可能已被后续修改影响），可刷新后重试')
+      // 能走到这里的都是「历史改动」通道：Keep 只把记录标成已看过，不写盘，
+      // 用「已采纳」会让人以为文件被改过，这里必须换成准确措辞
+      setStatus(result.ok ? `${SIDECAR_KEEP_DONE}（${result.ok} 处）` : decideStatus('已采纳 ', result))
+      const message = batchError(result)
+      if (message) setError(message)
     }).catch(() => { batchBusyRef.current = false })
   }
   const undoFile = () => {
@@ -3493,7 +3531,8 @@ export function EditorView(props) {
       reloadFile(true)
       emitRefresh({ scope, paths: active ? [active] : undefined, kind: 'structure' })
       setStatus(decideStatus('已不采纳 ', result))
-      if (result.fail) setError(result.fail + ' 处差异处理失败（可能已被后续修改影响），可刷新后重试')
+      const message = batchError(result)
+      if (message) setError(message)
     }).catch(() => { batchBusyRef.current = false })
   }
 
@@ -3501,7 +3540,7 @@ export function EditorView(props) {
   const allPending = React.useMemo(() => {
     const out = []
     for (const rec of Object.values(records)) {
-      if (rec.superseded === true || officialPath(rec.path, review.page)) continue
+      if (rec.superseded === true || coveredPaths.has(diffPathKey(rec.path))) continue
       const perHunk = Array.isArray(rec.decisions?.perHunk) ? rec.decisions.perHunk : []
       const hunks = Array.isArray(rec.hunks) ? rec.hunks : []
       for (let i = 0; i < hunks.length; i++) {
@@ -3555,7 +3594,8 @@ export function EditorView(props) {
       if (reject || !missingNow) reloadFile(true)
       emitRefresh({ scope, paths, kind: 'structure' })
       setStatus(decideStatus(reject ? '已不采纳 ' : '已采纳 ', result) + `；删除文件 ${handled.size} 个`)
-      if (result.fail) setError(result.fail + ' 处差异处理失败，可刷新后重试')
+      const message = batchError(result)
+      if (message) setError(message)
     } catch (cause) { if (lifetime?.live) setError(String(cause)) }
     finally { batchBusyRef.current = false; if (lifetime?.live) refreshRecords() }
   }
@@ -3592,6 +3632,68 @@ export function EditorView(props) {
     return false
   }
 
+  /** @private @author ddj 2026年11月03号 @description 批量通道的一次性完整快照（分页口径的 pending 只是页内计数）。 @returns 完整待审页 */
+  async function batchSnapshot() {
+    const res = await rpc('edrv.review.list', { sessionId, all: true })
+    if (!res.ok) throw new Error(res.error)
+    return res.page
+  }
+
+  /** @private @author ddj 2026年11月03号 @param token 起批时的会话寿命 @returns 逐条 Undo 的精确部分完成（冲突处停止） */
+  function undoAllBatch(token) {
+    return runReviewBatch({
+      snapshot: batchSnapshot,
+      detail: async (id) => { const res = await rpc('edrv.review.detail', { sessionId, id }); if (!res.ok) throw new Error(res.error); return res.detail },
+      decide: (detail, undo, operationId) => rpc('edrv.review.decide', { sessionId, id: detail.item.id, seq: detail.item.seq, revision: detail.item.revision, operationId, scope: 'file', decision: undo ? 'rejected' : 'accepted' }),
+      guard: () => guardReviewAll(true, token), operation: batchOperation,
+    }, true)
+  }
+
+  /** @private @author ddj 2026年11月03号 @param token 起批时的会话寿命 @returns 一次 RPC 的批量 Keep 结果（跳过项不算失败） */
+  function keepAllBatch(token) {
+    return runKeepAll({
+      snapshot: batchSnapshot,
+      keepAll: (items, batchId) => rpc('edrv.review.keepAll', { sessionId, batchId, items }),
+      guard: () => guardReviewAll(false, token),
+    })
+  }
+
+  /**
+   * @private
+   * @author ddj 2026年11月03号
+   * @description: 批量结果落界面：刷新列表、状态栏计数；Keep 的跳过只做提示不当错误，
+   * Undo 保持「遇冲突停止」口径。
+   * @param result 批量结果
+   * @param reject 本次是 Undo 还是 Keep
+   * @param undoPath 起批时的活动文件
+   * @param undoModel 起批时的编辑器模型
+   * @param undoVersion 起批时的模型版本
+   * @returns 官方段是否完全成功（legacy 通道是否继续）
+   */
+  function finishReviewAll(result, reject, undoPath, undoModel, undoVersion) {
+    refreshReview(sessionId)
+    if (result.paths.length) emitRefresh({ scope, paths: result.paths, kind: 'structure' })
+    if (reject) {
+      if (result.paths.some((path) => sameFile(path, undoPath)) && activeRef.current === undoPath
+        && !dirtyRef.current[undoPath] && !savingRef.current.has(undoPath) && undoModel?.getVersionId?.() === undoVersion) reloadFile(true)
+      setStatus(`Undo All：官方记录已完成 ${result.completed} / ${result.total}`)
+      if (result.error) setError(`批量已停止，已完成 ${result.completed} 项，其余未处理。${result.error}`)
+      return !result.error
+    }
+
+    const skipped = result.skipped ?? []
+    setStatus(`Keep All：已保留 ${result.completed} / ${result.total}` + (skipped.length ? `，跳过 ${skipped.length} 条` : ''))
+    if (result.error) setError(`Keep All 未全部完成：${result.error}`)
+    if (skipped.length) toastDom(skippedTip(skipped))
+    return !result.error
+  }
+
+  /** @private @author ddj 2026年11月03号 @param skipped 被跳过的条目 @returns 最多 3 条、余量汇总的提示文案 */
+  function skippedTip(skipped) {
+    const head = skipped.slice(0, 3).map((item) => `${item.display}：${item.reason}`).join('；')
+    return skipped.length > 3 ? `${head}；等 ${skipped.length} 条` : head
+  }
+
   /** @private @author ddj 2026年10月27号 @param reject Undo or Keep all workspace pending records, including previous rounds. @returns Explicit partial results; legacy proceeds only when official stage fully succeeds. */
   async function actReviewAll(reject) {
     if (batchBusyRef.current) return
@@ -3604,23 +3706,9 @@ export function EditorView(props) {
     batchBusyRef.current = true; setReviewBatchBusy(true)
     setStatus(reject ? '正在检查并 Undo 全部待审记录…' : '正在 Keep 全部待审记录…')
     try {
-      const result = await runReviewBatch({
-        snapshot: async () => {
-          const res = await rpc('edrv.review.list', { sessionId, all: true })
-          if (!res.ok) throw new Error(res.error)
-          return res.page
-        },
-        detail: async (id) => { const res = await rpc('edrv.review.detail', { sessionId, id }); if (!res.ok) throw new Error(res.error); return res.detail },
-        decide: (detail, undo, operationId) => rpc('edrv.review.decide', { sessionId, id: detail.item.id, seq: detail.item.seq, revision: detail.item.revision, operationId, scope: 'file', decision: undo ? 'rejected' : 'accepted' }),
-        guard: () => guardReviewAll(reject, token), operation: batchOperation,
-      }, reject)
+      const result = reject ? await undoAllBatch(token) : await keepAllBatch(token)
       if (!token?.live) return
-      refreshReview(sessionId)
-      if (reject && result.paths.some((path) => sameFile(path, undoPath)) && activeRef.current === undoPath
-        && !dirtyRef.current[undoPath] && !savingRef.current.has(undoPath) && undoModel?.getVersionId?.() === undoVersion) reloadFile(true)
-      if (result.paths.length) emitRefresh({ scope, paths: result.paths, kind: 'structure' })
-      setStatus(`${reject ? 'Undo All' : 'Keep All'}：官方记录已完成 ${result.completed} / ${result.total}`)
-      if (result.error) { setError(`批量已停止，已完成 ${result.completed} 项，其余未处理。${result.error}`); return }
+      if (!finishReviewAll(result, reject, undoPath, undoModel, undoVersion)) return
       guardReviewAll(reject, token)
       // Official-owned paths are excluded from allPending; never run legacy writes for official history.
       if (allPending.length) { batchBusyRef.current = false; await actAllPending(reject) }

package/src/client/ui/ReviewAllConfirm.ts

@@ -19,7 +19,7 @@ export function ReviewAllConfirm(props: ReviewAllProps): React.ReactElement {
   const action = props.reject ? 'Undo All' : 'Keep All'
   const warning = props.reject
     ? '撤销会改写磁盘；逐项安全校验，遇到冲突停止，已完成项不会自动恢复。'
-    : '只标记待审修改为保留，不改写文件。'
+    : '只标记待审修改为保留，不改写文件；个别条目若已变化或需在活跃端判定会被跳过并留在列表里，可逐个处理。'
   const footer = React.createElement(React.Fragment, null,
     React.createElement(Button, { variant: 'ghost', onClick: props.onCancel, autoFocus: true }, '取消'),
     React.createElement(Button, { variant: 'primary', onClick: props.onConfirm }, '确认 ' + action))

package/src/index.ts

@@ -76,7 +76,7 @@ function attachRuntime(ctx: Ctx, runtime: Runtime): void {
   const stopCapture = installCapture(ctx, (cwd, snapshot) => { evidence.persist(cwd, snapshot); return true })
   // 待审累计基线：只有写后内容确实变化才落库，异常一律不打断用户工具调用
   const pending = installPending(ctx, (write) => {
-    try { trackPendingCover(write.cwd, write.path, true) } catch { /* 内存登记失败不阻断采集 */ }
+    try { trackPendingCover(write.cwd, write.path, true, write.sessionId) } catch { /* 内存登记失败不阻断采集 */ }
     try { recordWrite(write) } catch (error) { log.warn('待审差异落库失败：' + String(error)) }
   })
   /** @author ddj 2026年09月28号 @param exec Tool execution. @param result Tool result. */

package/src/pending/persist.ts

@@ -107,8 +107,20 @@ export function loadEntries(cwd: string): StoredEntry[] {
  * @returns 无
  */
 export function saveEntry(cwd: string, stored: StoredEntry): void {
+  upsertEntry(pendingDb(cwd), stored)
+}
+
+/**
+ * @private
+ * @author ddj 2026年11月03号
+ * @description: 在给定连接上写入或更新一条条目（含标记），供单条与批量两个入口复用。
+ * @param db 已迁移连接（可能已在事务中）
+ * @param stored 条目与标记
+ * @returns 无
+ */
+function upsertEntry(db: DatabaseSync, stored: StoredEntry): void {
   const { entry, flags } = stored
-  pendingDb(cwd).prepare(`INSERT INTO pending_entries
+  db.prepare(`INSERT INTO pending_entries
     (id,path,earlier,old_text,new_text,updated_at,unseen,missing,diverged,oversized,revision,session_id,session_ids,lineage)
     VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)
     ON CONFLICT(id) DO UPDATE SET path=excluded.path,earlier=excluded.earlier,old_text=excluded.old_text,
@@ -165,9 +177,7 @@ export function saveBlocks(cwd: string, entryId: string, blocks: { id: string; d
   const db = pendingDb(cwd)
   db.exec('BEGIN IMMEDIATE')
   try {
-    db.prepare('DELETE FROM pending_blocks WHERE entry_id=?').run(entryId)
-    const insert = db.prepare('INSERT INTO pending_blocks VALUES(?,?,?)')
-    for (const block of blocks) insert.run(entryId, block.id, block.decision)
+    writeBlocks(db, entryId, blocks)
     db.exec('COMMIT')
   } catch (error) {
     if (db.isTransaction) db.exec('ROLLBACK')
@@ -175,6 +185,21 @@ export function saveBlocks(cwd: string, entryId: string, blocks: { id: string; d
   }
 }
 
+/**
+ * @private
+ * @author ddj 2026年11月03号
+ * @description: 在给定连接上覆盖某条目的块决定集合，供单条与批量两个入口复用。
+ * @param db 已迁移连接（可能已在事务中）
+ * @param entryId 条目身份
+ * @param blocks 块决定
+ * @returns 无
+ */
+function writeBlocks(db: DatabaseSync, entryId: string, blocks: { id: string; decision: string }[]): void {
+  db.prepare('DELETE FROM pending_blocks WHERE entry_id=?').run(entryId)
+  const insert = db.prepare('INSERT INTO pending_blocks VALUES(?,?,?)')
+  for (const block of blocks) insert.run(entryId, block.id, block.decision)
+}
+
 
 /**
  * @author ddj 2026年10月29号
@@ -222,7 +247,21 @@ export function writeOp(
  * @returns 无
  */
 export function pushHistory(cwd: string, kind: string, entryId: string, snapshot: string, now: number): void {
-  const db = pendingDb(cwd)
+  insertHistory(pendingDb(cwd), kind, entryId, snapshot, now)
+}
+
+/**
+ * @private
+ * @author ddj 2026年11月03号
+ * @description: 在给定连接上追加撤销栈记录并截断重做分支，供单条与批量两个入口复用。
+ * @param db 已迁移连接（可能已在事务中）
+ * @param kind 操作种类
+ * @param entryId 涉及的条目
+ * @param snapshot 可重放快照
+ * @param now 时间
+ * @returns 无
+ */
+function insertHistory(db: DatabaseSync, kind: string, entryId: string, snapshot: string, now: number): void {
   db.prepare("DELETE FROM pending_history WHERE state='undone'").run()
   db.prepare("INSERT INTO pending_history(kind,entry_id,snapshot,created_at,state) VALUES(?,?,?,?,'applied')")
     .run(kind, entryId, snapshot, now)
@@ -327,3 +366,53 @@ function flagsOfRow(row: Row): PendingFlags {
     revision: Number(row.revision),
   }
 }
+
+/** 批量 Keep 的一条落库记录：stored 提供 CAS 依据与撤销快照 before，next 是推进后的条目。 */
+export interface KeepRecord {
+  entryId: string
+  stored: StoredEntry
+  next: StoredEntry
+  blocks: { id: string; decision: string }[]
+  snapshot: string
+}
+
+/**
+ * @public
+ * @author ddj 2026年11月03号
+ * @description: 在一次事务内批量推进多条待审条目（批量 Keep 用）。每条按 revision 做 CAS，
+ * 只跳过冲突的那一条，不牵连整批；块决定与撤销快照与单条路径同口径。
+ * @param cwd 工作区
+ * @param records 待落库记录
+ * @returns 因版本已变被跳过的条目
+ * @throws 事务级异常（SQL/程序错误）整体回滚后抛出
+ */
+export function saveDecisions(cwd: string, records: KeepRecord[]): { id: string; reason: string }[] {
+  const db = pendingDb(cwd)
+  const skipped: { id: string; reason: string }[] = []
+  const advance = db.prepare(`UPDATE pending_entries SET path=?,earlier=?,old_text=?,new_text=?,updated_at=?,unseen=?,
+    missing=?,diverged=?,oversized=?,revision=?,session_id=?,session_ids=?,lineage=? WHERE id=? AND revision=?`)
+
+  db.exec('BEGIN IMMEDIATE')
+  try {
+    for (const record of records) {
+      const { entry, flags } = record.next
+      const expected = record.stored.flags.revision
+      const changed = advance.run(entry.path, entry.earlierVersion, entry.oldText, entry.newText, entry.updatedAt,
+        entry.unseen === true ? 1 : 0, flags.missing ? 1 : 0, flags.diverged ? 1 : 0, flags.oversized ? 1 : 0,
+        flags.revision, entry.sessionId, JSON.stringify(entry.sessionIds),
+        entry.lineage ? JSON.stringify(entry.lineage) : null, record.entryId, expected)
+      // 读条目到落库之间被别的决定推进过：只放弃这一条
+      if (changed.changes !== 1) {
+        skipped.push({ id: record.entryId, reason: '待审条目已变化，请重试' })
+        continue
+      }
+      writeBlocks(db, record.entryId, record.blocks)
+      insertHistory(db, 'decide', record.entryId, record.snapshot, Date.now())
+    }
+    db.exec('COMMIT')
+    return skipped
+  } catch (error) {
+    if (db.isTransaction) db.exec('ROLLBACK')
+    throw error
+  }
+}

package/src/pending/store.ts

@@ -16,9 +16,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,
+  readOp, saveBlocks, saveDecisions, saveEntry, setHistoryState, writeOp,
 } from './persist.js'
 
 /**
@@ -289,6 +290,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: 版本库导入：把工作副本相对基线的改动折进待审条目，已存在条目按折叠规则并入。

package/src/pendingCompat.ts

@@ -7,8 +7,13 @@ 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>()
+/**
+ * 进程内"已被待审接管"的路径集合；旧写入口守卫只读它，绝不碰数据库。
+ * 按会话登记：待审列表按会话可见，守卫必须同口径，否则会出现"拦得住、看不见"的死锁。
+ * 无会话归属的登记落在 workspace 集合（兼容只有工作区+路径的旧用法）。
+ */
+const coveredBySession = new Map<string, Set<string>>()
+const coveredWorkspace = new Set<string>()
 
 /** 待审条目在面板列表里的 id 前缀，用于把请求路由回待审内核。 */
 export { PENDING_PREFIX } from './shared/pendingReview.js'
@@ -138,28 +143,94 @@ 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)}`
+}
+
+/**
+ * @author ddj 2026年11月3号
+ * @description: 取某会话的覆盖集合；首次登记时就地建集合，避免调用方判空。
+ * @param sessionId 会话 id
+ * @returns 该会话的覆盖键集合
+ */
+function sessionCovers(sessionId: string): Set<string> {
+  const existing = coveredBySession.get(sessionId)
+  if (existing) return existing
+  const created = new Set<string>()
+  coveredBySession.set(sessionId, 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, sessionId?: string): void {
+  const key = coverKey(cwd, path)
+  const target = sessionId ? sessionCovers(sessionId) : coveredWorkspace
+  if (covered) target.add(key)
+  else target.delete(key)
+}
+
+/**
+ * @author ddj 2026年11月3号
+ * @description: 用一次列表结果整体重建某会话的接管集合：条目被移除或结案后自动失效，不再残留登记。
+ * @param cwd 工作区
+ * @param sessionId 会话 id
+ * @param paths 本会话当前可见的待审条目路径
  * @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 setPendingCovers(cwd: string, sessionId: string, paths: readonly string[]): void {
+  const next = new Set<string>()
+  for (const path of paths) {
+    if (path) next.add(coverKey(cwd, path))
+  }
+  coveredBySession.set(sessionId, 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)
+  for (const [sessionId, set] of coveredBySession) {
+    if (set.has(key)) return sessionId
+  }
+  return null
 }
 
 /**
  * @author ddj 2026年10月29号
  * @description: 判断某路径是否已由待审投影接管；仅读进程内集合，不产生任何 IO。
+ * 给 sessionId 时按该会话的可见范围判定（列表看不到的接管不拦旧入口），缺省按全工作区并集判定。
  * @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)
+  if (coveredWorkspace.has(key)) return true
+  if (sessionId) return coveredBySession.get(sessionId)?.has(key) === true
+  for (const set of coveredBySession.values()) {
+    if (set.has(key)) return true
+  }
+  return false
 }
 
 /**

package/src/pendingRpc.ts

@@ -5,7 +5,7 @@ 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'
@@ -85,8 +85,8 @@ function readHandlers(kit: ScopeKit): Partial<RpcHandlerMap> {
       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)
+      // 列表即登记接管关系：整集重建本会话的登记，条目被移出列表后自动失效
+      setPendingCovers(cwd, args.sessionId, page.items.map((item) => item.path))
       return { ok: true, page }
     },
     'edrv.pending.detail': async (args: PendingRequest & { id: string }) => {
@@ -124,8 +124,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 +168,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) }