dsh-vscode-mode 0.25.1 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-vscode-mode",
-  "version": "0.25.1",
+  "version": "0.26.0",
   "description": "DSH 上的类 VSCode 编码体验：Monaco 编辑器（文件页签/QuickOpen/状态栏，可驻 DSH 0.1.5+ 官方右侧 Sidebar 与对话同屏）+ 命令栏（Ctrl+Shift+P）与可扩展指令系统 + VS Code 兼容代码片段（.code-snippets 全局/项目，IntelliSense 展开）+ Agent 编辑差异审查（整文件差异/采纳/拒绝/归档/回滚）+ SVN 集成（侧栏变更面板/日志弹窗/并排差异）+ 语言服务器（LSP）智能（跳转定义/引用/hover/大纲 + VSIX 扩展市场安装），状态持久化到工作区旁车，界面状态（页签/光标/侧栏/编辑 Tab/导航历史）镜像到 DSH home 跨重启恢复",
   "icon": "assets/icon.svg",
   "keywords": [

package/src/client/reviewBar.ts

@@ -126,6 +126,9 @@ export const SIDECAR_KEEP_TITLE = '标记这些历史改动为已看过：只改
 /** 非官方 Undo 的作用域说明：走原有回滚校验写回磁盘，但不影响官方记录。 */
 export const SIDECAR_UNDO_TITLE = '撤销这些历史改动（写回受回滚校验保护）：只影响这份历史记录，不影响官方审查。'
 
+/** 非官方 Keep 之后的完成态：该通道 Keep 不写盘，不能沿用「已采纳」这种会让人以为改过文件的措辞。 */
+export const SIDECAR_KEEP_DONE = '已标记为看过（未改动文件）'
+
 /** 当前端没有该会话时，差异栏里给中性说明而不是红色报错。 */
 export const SESSION_DOWN_NOTICE = '这个会话没在当前端激活，官方审查数据暂时读不到；下面的历史改动仍可查看、Keep、Undo。'
 

package/src/client/reviewBatch.ts

@@ -30,7 +30,15 @@ export async function loadPending(port: Pick<BatchPort, 'snapshot'>): Promise<Re
   return page.items
 }
 
-/** @public @author ddj 2026年10月27号 @param port Guarded existing per-file decision adapter. @param reject Undo instead of Keep. @returns Precise partial result; Undo stops at first conflict, never claims atomic multi-file rollback. */
+/**
+ * @public
+ * @author ddj 2026年10月27号
+ * @description: 逐条决策引擎，现仅供 Undo All 使用（Keep 已改走 `reviewKeepAll.ts` 的宿主批量通道）；
+ * 保留 reject 形态以便对照既有契约与测试。
+ * @param port Guarded existing per-file decision adapter.
+ * @param reject Undo instead of Keep.
+ * @returns Precise partial result; Undo stops at first conflict, never claims atomic multi-file rollback.
+ */
 export async function runReviewBatch(port: BatchPort, reject: boolean): Promise<BatchResult> {
   const result: BatchResult = { completed: 0, total: 0, paths: [], error: '' }
   try {

package/src/client/reviewKeepAll.ts

@@ -0,0 +1,72 @@
+/**
+ * 批量 Keep：一次完整快照 + 一次批量 RPC，单条基线问题只跳过自己，不再整批中止。
+ * Undo 仍走 reviewBatch.ts 的逐条通道（写盘要逐项校验并在冲突处停止）。
+ * @author ddj 2026年11月03号
+ */
+import type { KeepAllItem, KeepAllResult, ReviewItem, ReviewPage, ReviewResult } from '../shared/review.js'
+import { loadPending } from './reviewBatch.js'
+
+/** 批量 Keep 的 RPC 适配器；guard 在取快照前后各校验一次会话寿命。 */
+export interface KeepAllPort {
+  snapshot: () => Promise<ReviewPage>
+  keepAll: (items: KeepAllItem[], batchId: string) => Promise<ReviewResult<{ result: KeepAllResult }>>
+  guard: () => void
+}
+
+/**
+ * @private
+ * @author ddj 2026年11月03号
+ * @description: 取一次完整待审快照；完整性校验失败时重取一次，避免瞬时漂移被当成不可恢复错误。
+ * @param port 已鉴权的 RPC 适配器
+ * @returns 冻结的批量目标
+ * @throws 两次都取不到一致快照时抛出原始原因
+ */
+async function snapshotOnce(port: KeepAllPort): Promise<KeepAllItem[]> {
+  try {
+    return toItems(await loadPending(port))
+  } catch {
+    // 分页期间数量漂移多为瞬时：guard 仍有效就重新取一次，仍不一致才放弃
+    port.guard()
+    return toItems(await loadPending(port))
+  }
+}
+
+/**
+ * @private
+ * @author ddj 2026年11月03号
+ * @description: 把快照条目裁成批量目标，只带 host 需要的身份与版本线索。
+ * @param items 完整待审集
+ * @returns 批量目标
+ */
+function toItems(items: ReviewItem[]): KeepAllItem[] {
+  return items.map((item) => ({ id: item.id, display: item.display, seq: item.seq, revision: item.revision }))
+}
+
+/**
+ * @public
+ * @author ddj 2026年11月03号
+ * @description: 批量保留全部待审记录（Keep 不改写磁盘）。一次往返完成，跳过项只进 skipped，
+ * 段级异常才写 error；guard 失效时保留已完成计数交给调用方呈现。
+ * @param port 已鉴权的 RPC 适配器
+ * @returns 与 BatchResult 同构的批量结果（含跳过明细）
+ */
+export async function runKeepAll(port: KeepAllPort): Promise<KeepAllResult> {
+  const result: KeepAllResult = { completed: 0, total: 0, paths: [], skipped: [], error: '' }
+  try {
+    port.guard()
+    const items = await snapshotOnce(port)
+    result.total = items.length
+    if (!items.length) return result
+
+    port.guard()
+    const reply = await port.keepAll(items, crypto.randomUUID())
+    if (!reply.ok) {
+      result.error = reply.error
+      return result
+    }
+    return reply.result
+  } catch (cause) {
+    result.error = cause instanceof Error ? cause.message : String(cause)
+    return result
+  }
+}

package/src/client/state/diffSummary.ts

@@ -32,6 +32,39 @@ export function officialPath(path: string, page: ReviewPage | null): boolean {
   return !!page?.overview?.coveredPaths.some((candidate) => diffPathKey(candidate) === key)
 }
 
+/**
+ * @author ddj 2026年11月3号
+ * @description: 本页待审条目占用的路径键：路径本身与其身份各一份。
+ * @param page 审查页
+ * @returns 待审覆盖的路径键集合
+ */
+function pendingCoverKeys(page: ReviewPage | null): Set<string> {
+  const keys = new Set<string>()
+  for (const item of page?.items ?? []) {
+    if (!item.id.startsWith(PENDING_PREFIX)) continue
+    // 待审条目的 path 取自写入时的原始写法（agent 常用工作区相对路径），官方导航用的却是绝对身份：
+    // 只按 path 建覆盖集时，同一文件的官方汇总行不会被压掉，差异栏把 3 个文件算成 6 条。
+    // 身份（id 去掉待审前缀）与官方 identity 同源，必须一起入集。
+    keys.add(diffPathKey(item.currentPath || item.path))
+    keys.add(diffPathKey(item.id.slice(PENDING_PREFIX.length)))
+  }
+  return keys
+}
+
+/**
+ * @public
+ * @author ddj 2026年11月3号
+ * @description: 取本页"已有权威通道在管"的路径键：官方汇总覆盖集 + 待审条目。
+ * 编辑器与差异汇总必须同口径，否则同一改动在列表里被压掉、在编辑器里却仍然画得出来并可以点。
+ * @param page 审查页
+ * @returns 路径比较键集合
+ */
+export function coveredPathKeys(page: ReviewPage | null): Set<string> {
+  const keys = pendingCoverKeys(page)
+  for (const path of page?.overview?.coveredPaths ?? []) keys.add(diffPathKey(path))
+  return keys
+}
+
 /**
  * @author ddj 2026年10月30号
  * @description: 取出本页待审条目（id 带待审前缀）并折算成文件行。
@@ -40,15 +73,9 @@ export function officialPath(path: string, page: ReviewPage | null): boolean {
  */
 function pendingRowsOf(page: ReviewPage | null): { rows: DiffFile[]; covered: Set<string> } {
   const rows: DiffFile[] = []
-  const covered = new Set<string>()
   for (const item of page?.items ?? []) {
     if (!item.id.startsWith(PENDING_PREFIX)) continue
     const path = item.currentPath || item.path
-    // 待审条目的 path 取自写入时的原始写法（agent 常用工作区相对路径），官方导航用的却是绝对身份：
-    // 只按 path 建覆盖集时，同一文件的官方汇总行不会被压掉，差异栏把 3 个文件算成 6 条。
-    // 身份（id 去掉待审前缀）与官方 identity 同源，必须一起入集。
-    covered.add(diffPathKey(path))
-    covered.add(diffPathKey(item.id.slice(PENDING_PREFIX.length)))
     rows.push({
       path,
       label: item.display || path,
@@ -59,7 +86,7 @@ function pendingRowsOf(page: ReviewPage | null): { rows: DiffFile[]; covered: Se
       sourceKind: 'pending',
     })
   }
-  return { rows, covered }
+  return { rows, covered: pendingCoverKeys(page) }
 }
 
 /** @public @author ddj 2026年10月26号 @param records Tool-call history. @param page Official file navigation, never only its first 50 rows. @returns Pending first, then official; legacy paths remain explicitly labelled. */

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: 版本库导入：把工作副本相对基线的改动折进待审条目，已存在条目按折叠规则并入。