dsh-vscode-mode 0.23.0 → 0.23.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-vscode-mode",
-  "version": "0.23.0",
+  "version": "0.23.2",
   "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/reviewBatch.ts

@@ -1,8 +1,9 @@
 /** Official bulk decisions use persisted metadata, never the visible history page. @author ddj 2026年10月27号 */
 import type { ReviewDetail, ReviewItem, ReviewPage, ReviewResult } from '../shared/review.js'
+import { PENDING_PREFIX } from '../shared/pendingReview.js'
 
 export interface BatchPort {
-  list: (cursor?: number) => Promise<ReviewPage>
+  snapshot: () => Promise<ReviewPage>
   detail: (id: string) => Promise<ReviewDetail>
   decide: (detail: ReviewDetail, reject: boolean, operationId: string) => Promise<ReviewResult<{ revision: number }>>
   guard: () => void
@@ -10,27 +11,23 @@ export interface BatchPort {
 }
 export interface BatchResult { completed: number; total: number; paths: string[]; error: string }
 
-/** @public @author ddj 2026年10月27号 @param port Authenticated RPC adapter. @returns Frozen complete pending set; aborts before any decision if pagination shifts. @throws Incomplete or changing pages. */
-export async function loadPending(port: Pick<BatchPort, 'list'>): Promise<ReviewItem[]> {
-  const items: ReviewItem[] = []
+/**
+ * @public
+ * @author ddj 2026年10月31号
+ * @description: 取一次完整待审快照。分页计数只用于展示，批量写入必须一次取全，避免把页内数字当成总数。
+ * @param port 已鉴权的 RPC 适配器
+ * @returns 冻结的完整待审集；任何不一致都在首个写入前中止
+ * @throws 快照重复、版本已变或数量不完整
+ */
+export async function loadPending(port: Pick<BatchPort, 'snapshot'>): Promise<ReviewItem[]> {
+  const page = await port.snapshot()
   const seen = new Set<string>()
-  const cursors = new Set<number>()
-  let cursor: number | undefined
-  let expected: number | undefined
-  do {
-    const page = await port.list(cursor)
-    expected ??= page.pending
-    if (page.pending !== expected) throw new Error('待审记录在分页期间变化，请刷新后重试')
-    for (const item of page.items) {
-      if (seen.has(item.id) || !item.current || item.decision !== 'pending') throw new Error('待审分页发生重复或版本变化，请刷新后重试')
-      seen.add(item.id); items.push(item)
-    }
-    if (page.nextCursor === null) break
-    if (cursors.has(page.nextCursor) || page.items.length === 0) throw new Error('待审分页未完整返回，请刷新后重试')
-    cursor = page.nextCursor; cursors.add(cursor)
-  } while (true)
-  if (items.length !== expected) throw new Error('待审记录数量不完整，未执行批量操作')
-  return items
+  for (const item of page.items) {
+    if (seen.has(item.id) || !item.current || item.decision !== 'pending') throw new Error('待审快照发生重复或版本变化，请刷新后重试')
+    seen.add(item.id)
+  }
+  if (page.nextCursor !== null || page.items.length !== page.pending) throw new Error('待审记录数量不完整，未执行批量操作')
+  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. */
@@ -45,6 +42,10 @@ export async function runReviewBatch(port: BatchPort, reject: boolean): Promise<
     for (const item of items) {
       port.guard()
       const detail = await port.detail(item.id)
+      // 待审条目判定要在会话活跃的一端做：冷端能力位已关闭，这里给出比「版本变化」更准确的原因
+      if (detail.capability.live === false && item.id.startsWith(PENDING_PREFIX)) {
+        throw new Error(`${item.display}：待审条目需要在会话活跃的一端判定，请先在那一端处理或在本端打开该会话`)
+      }
       if (!detail.item.current || detail.item.seq !== item.seq || detail.item.revision !== item.revision
         || !detail.capability.keep) throw new Error(`${item.display}：审查版本变化，请刷新后重试`)
       if (reject && !detail.capability.undo) throw new Error(`${item.display}：${detail.capability.reason}`)

package/src/client/ui/EditorView.ts

@@ -569,6 +569,8 @@ export function EditorView(props) {
   }, [records, active, cwd, review.page])
 
   const reviewOpsRef = React.useRef(new Map())
+  // 已自动结案的记录 id：防止「改动已不在文件中」的记录在刷新期间被反复提交判定
+  const settledRef = React.useRef(new Set())
   const [officialDetail, setOfficialDetail] = React.useState(null)
   const [officialRecords, setOfficialRecords] = React.useState([])
   const [selectedReview, setSelectedReview] = React.useState(null)
@@ -588,6 +590,9 @@ export function EditorView(props) {
       .find((path) => sameFile(path, active))
     const coveredPath = review.page?.overview?.coveredPaths.find((path) => sameFile(path, active))
     const reviewPath = coveredPath ?? pendingPath
+    dbg(sessionId, `[DEBUG reviewPath] active=${active ?? '(null)'} covered=${coveredPath ?? '(none)'}`
+      + ` pending=${pendingPath ?? '(none)'} coveredCount=${review.page?.overview?.coveredPaths.length ?? -1}`
+      + ` items=${review.page?.items?.length ?? -1} overview=${review.page?.overview ? 1 : 0}`)
     if (!active || !reviewPath) {
       setOfficialDetail(null)
       setOfficialRecords([])
@@ -601,9 +606,15 @@ export function EditorView(props) {
         if (controller.signal.aborted) return
         if (!page.ok) throw new Error(page.error)
         const selected = page.page.items.find((item) => item.id === selectedReview) ?? page.page.items[0]
+        dbg(sessionId, `[DEBUG reviewList] path=${reviewPath} items=${page.page.items.length}`
+          + ` waiting=${page.page.pending} selected=${selected?.id ?? '(none)'}`)
         if (!selected) { setOfficialRecords([]); setOfficialDetail(null); return }
         const result = await rpc('edrv.review.detail', { sessionId, id: selected.id }, controller.signal)
         if (controller.signal.aborted) return
+        dbg(sessionId, `[DEBUG reviewDetail] id=${selected.id} ok=${result.ok ? 1 : 0}`
+          + ` keep=${result.ok ? (result.detail.capability?.keep === true ? 1 : 0) : '-'}`
+          + ` live=${result.ok ? String(result.detail.capability?.live) : '-'}`
+          + ` err=${result.ok ? '' : String(result.error).slice(0, 120)}`)
         if (!result.ok) throw new Error(result.error)
         setOfficialRecords((previous) => JSON.stringify(previous) === JSON.stringify(page.page.items) ? previous : page.page.items)
         setOfficialDetail((previous) => JSON.stringify(previous) === JSON.stringify(result.detail) ? previous : result.detail)
@@ -672,6 +683,15 @@ export function EditorView(props) {
   const noBlocks = !!officialDetail && (officialDetail.diff.kind !== 'text' || officialDetail.diff.hunks.length === 0)
   // 单文件 Keep/Undo 的作用域：可定位差异 + 无法定位的冲突差异（后者否则永久留在待处理列表）
   const decideRegions = React.useMemo(() => [...pendingRegions, ...staleRegions], [pendingRegions, staleRegions])
+  // 记录的改动已全部不在当前文件中时没有可见差异可审：自动结案，不再让「改动已失效」占用差异栏。
+  React.useEffect(() => {
+    if (!officialDetail || contentReady !== true || batchBusyRef.current) return
+    if (pendingRegions.length > 0 || staleRegions.length === 0) return
+    if (noBlocks || officialDetail.capability?.keep !== true) return
+    if (dirtyRef.current[active]) return
+
+    void settleInvisibleRecord(officialDetail)
+  }, [officialDetail, contentReady, pendingRegions, staleRegions, noBlocks, active])
   hoverRegionsRef.current = pendingRegions
   // 行 → 差异区域 映射（hover O(1) 命中；每行归属其区域）
   const lineRegionMap = React.useMemo(() => {
@@ -3303,33 +3323,84 @@ export function EditorView(props) {
    */
   const itemOf = (r, reject) => ({ callId: r.callId, scope: r.create ? 'call' : 'hunk', hunkIndex: r.idx, decision: reject ? 'rejected' : 'accepted' })
 
+  /**
+   * @private
+   * @author ddj 2026年10月31号
+   * @description: 提交一条官方记录的判定；operationId 按决策键复用，网络重试保持幂等。
+   * @param detail 目标记录（含冻结的 seq / revision）
+   * @param reject true=Undo
+   * @param blockId 可选的连续块；缺省为整文件
+   * @returns 成功返回提交结果，失败抛出 host 给出的原因
+   */
+  async function submitOfficialDecision(detail, reject, blockId) {
+    const source = detail.item
+    const opKey = JSON.stringify([sessionId, source.id, source.seq, source.revision, blockId, reject])
+    let operationId = reviewOpsRef.current.get(opKey)
+    if (!operationId) { operationId = crypto.randomUUID(); reviewOpsRef.current.set(opKey, operationId) }
+
+    const result = await rpc('edrv.review.decide', { sessionId, id: source.id, seq: source.seq,
+      revision: source.revision, operationId, scope: blockId ? 'hunk' : 'file', blockId,
+      decision: reject ? 'rejected' : 'accepted' })
+    if (!result.ok) throw new Error(result.error)
+
+    reviewOpsRef.current.delete(opKey)
+    return result
+  }
+
+  /**
+   * @private
+   * @author ddj 2026年10月31号
+   * @description: 结案一条改动已不在当前文件中的官方记录：等价于 Keep（只标记已采纳，不改写磁盘）。
+   * 这类记录没有可见差异可审，留在差异栏只会让用户去处理一个不存在的东西。
+   * @param detail 待结案的记录
+   */
+  async function settleInvisibleRecord(detail) {
+    if (batchBusyRef.current) return
+
+    const settled = settledRef.current
+    if (settled.has(detail.item.id)) return
+    settled.add(detail.item.id)
+
+    batchBusyRef.current = true
+    try {
+      await submitOfficialDecision(detail, false)
+      refreshReview(sessionId)
+    } catch (cause) {
+      // 结案失败不打扰用户：记录仍留在待审列表，下次打开该文件再试
+      settled.delete(detail.item.id)
+      dbg(sessionId, `[DEBUG settleInvisible] id=${detail.item.id} err=${String(cause).slice(0, 160)}`)
+    } finally { batchBusyRef.current = false }
+  }
+
   /** @private @author ddj 2026年10月27号 @param reject Undo instead of Keep. @param blockId Optional contiguous block. @returns Persisted decision result; never reloads over a dirty buffer. */
   async function decideOfficial(reject, blockId) {
-    if (!officialDetail || batchBusyRef.current) return false
+    dbg(sessionId, `[DEBUG decideOfficial] reject=${reject ? 1 : 0} detail=${officialDetail ? 1 : 0}`
+      + ` busy=${batchBusyRef.current ? 1 : 0} active=${active ?? '(null)'}`)
+    if (!officialDetail || batchBusyRef.current) {
+      // 详情缺失时按钮仍可点（能力位来自列表数据），必须给可读原因而不是静默返回
+      if (!officialDetail && !batchBusyRef.current) setError('官方差异详情尚未加载完成，请稍后重试；若一直如此，请切换文件或刷新页面。')
+      return false
+    }
     if (reject && (dirtyRef.current[active] || savingRef.current.has(active) || saveTimerRef.current.isPending())) {
       setError('存在未保存或正在保存的修改，请等待完成后重试'); return false
     }
     batchBusyRef.current = true
-    const source = officialDetail.item
+    const detail = officialDetail
     const undoPath = active
     const undoModel = editorRef.current?.getModel?.()
     const undoVersion = undoModel?.getVersionId?.()
-    const opKey = JSON.stringify([sessionId, source.id, source.seq, source.revision, blockId, reject])
-    let operationId = reviewOpsRef.current.get(opKey)
-    if (!operationId) { operationId = crypto.randomUUID(); reviewOpsRef.current.set(opKey, operationId) }
     try {
-      const result = await rpc('edrv.review.decide', { sessionId, id: source.id, seq: source.seq,
-        revision: source.revision, operationId, scope: blockId ? 'hunk' : 'file', blockId,
-        decision: reject ? 'rejected' : 'accepted' })
-      if (!result.ok) throw new Error(result.error)
-      reviewOpsRef.current.delete(opKey)
+      await submitOfficialDecision(detail, reject, blockId)
       if (reject && activeRef.current === undoPath && !dirtyRef.current[undoPath]
         && !savingRef.current.has(undoPath) && undoModel?.getVersionId?.() === undoVersion) reloadFile(true)
       else if (reject) setError('Undo 已完成，编辑器在等待期间变化；未覆盖当前缓冲区，请核对磁盘后刷新')
       refreshReview(sessionId)
       setStatus(reject ? '已 Undo 选中差异' : '已 Keep 选中差异')
       return true
-    } catch (cause) { setError(String(cause)); return false }
+    } catch (cause) {
+      dbg(sessionId, `[DEBUG decideOfficialFail] id=${detail.item.id} reject=${reject ? 1 : 0} err=${String(cause).slice(0, 160)}`)
+      setError(String(cause)); return false
+    }
     finally { batchBusyRef.current = false }
   }
 
@@ -3466,10 +3537,26 @@ export function EditorView(props) {
     return operationId
   }
 
+  /**
+   * @private
+   * @author ddj 2026年10月31号
+   * @description: 批量操作要求官方待审列表已就绪；切换会话后列表还在载入时，
+   * 先触发一次刷新并给出可读提示，而不是直接报错中止（用户看到红色「尚未就绪」会以为功能坏了）。
+   * @param action 面向用户的动作名
+   * @returns 列表已就绪时为 true
+   */
+  function reviewReadyForBatch(action) {
+    if (review.page?.overview) return true
+
+    refreshReview(sessionId)
+    setStatus(`官方待审列表正在载入，载入完成后请再次点击${action}`)
+    return false
+  }
+
   /** @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
-    if (!review.page?.overview) { setError('官方待审列表尚未就绪，未执行批量操作'); return }
+    if (!reviewReadyForBatch(reject ? 'Undo All' : 'Keep All')) return
     if (!sum.pendingFiles.length) return
     const token = reviewLifeRef.current
     const undoPath = activeRef.current
@@ -3479,7 +3566,11 @@ export function EditorView(props) {
     setStatus(reject ? '正在检查并 Undo 全部待审记录…' : '正在 Keep 全部待审记录…')
     try {
       const result = await runReviewBatch({
-        list: async (cursor) => { const res = await rpc('edrv.review.list', { sessionId, cursor }); if (!res.ok) throw new Error(res.error); return res.page },
+        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,
@@ -3500,7 +3591,7 @@ export function EditorView(props) {
   /** @private @author ddj 2026年10月27号 @param reject Whether to undo pending files. @description Open a DSH confirmation without starting any mutations. */
   function askReviewAll(reject) {
     if (batchBusyRef.current || !sum.pendingFiles.length) return
-    if (!review.page?.overview) { setError('官方待审列表尚未就绪，未执行批量操作'); return }
+    if (!reviewReadyForBatch(reject ? 'Undo All' : 'Keep All')) return
     setReviewAllPrompt({ reject, count: sum.pendingFiles.length, token: reviewLifeRef.current })
   }
 
@@ -4693,6 +4784,9 @@ export function EditorView(props) {
   const sessionDown = isSessionMissingError(rawReviewError)
   const reviewErrorTone = sessionDown ? 'info' : 'error'
   const reviewErrorText = !rawReviewError ? undefined : sessionDown ? SESSION_DOWN_NOTICE : sessionErrorText(rawReviewError)
+  // 官方元数据未到位且没有报错 = 首次载入中：此时还不知道哪些历史记录会被官方通道接管，
+  // 直接按历史记录报数会在每次重启时闪出几十个「待处理文件」，故先显示占位、批量也先不放开。
+  const reviewLoading = review.page === null && !review.error
   const buildDockSnapshot = () => ({
     mode: editorDockMode(active),
     missingDeletion: !!missingNow,
@@ -4714,7 +4808,7 @@ export function EditorView(props) {
     onUndoFile: undoFile,
     onAcceptAllFiles: acceptAllFiles,
     onUndoAllFiles: undoAllFiles,
-    allPendingCount: allPending.length + (review.page?.pending ?? 0),
+    allPendingCount: reviewLoading ? 0 : allPending.length + (review.page?.pending ?? 0),
     reviewBatchBusy,
     batchUnavailable: !review.page?.overview ? '官方待审列表尚未就绪' : undefined,
     onRollback: rollbackFile,
@@ -4728,7 +4822,7 @@ export function EditorView(props) {
     contentReady,
     diffTotal: displayDiffTotal(contentReady, pendingRegions.length, sum.files.find((file) => sameFile(file.path, active))?.pending ?? 0),
     fileIdx,
-    fileTotal: sum.pendingFiles.length,
+    fileTotal: reviewLoading ? null : sum.pendingFiles.length,
     onPrevDiff: () => gotoDiff(-1),
     onNextDiff: () => gotoDiff(1),
     onPrevFile: () => gotoFile(-1),

package/src/client/ui/OfficialDiffBar.tsx

@@ -15,7 +15,8 @@ export interface OfficialBarProps {
   diffIdx?: number
   /** 编辑器内容是否就绪；未就绪时不得断言差异失效 */
   contentReady?: boolean
-  fileTotal?: number
+  /** 待审文件总数；null 表示官方元数据尚未就绪，栏内显示占位 */
+  fileTotal?: number | null
   fileIdx?: number
   allPendingCount?: number
   reviewBatchBusy?: boolean
@@ -51,6 +52,20 @@ export function barIcon(mark: Mark): React.ReactElement {
   return <svg width="16" height="16" viewBox="0 0 16 16" fill="none" stroke="currentColor" strokeWidth={1.5} strokeLinecap="round" strokeLinejoin="round" aria-hidden="true"><path d={marks[mark]} /></svg>
 }
 
+/**
+ * @private
+ * @author ddj 2026年10月31号
+ * @description: Keep 按钮提示。会话不在本端活跃时 Keep 仍可执行（只写共享审查库），
+ * 提示里补一句说明，免得用户把它当成跨端不可用的按钮。
+ * @param hint 差异栏给出的 Keep 说明
+ * @param live 会话是否在本端活跃
+ * @returns 按钮 title 文本
+ */
+function keepTitle(hint: string, live: boolean): string {
+  if (live) return hint
+  return `${hint}（会话在另一端激活：Keep 写入共享审查库，仍可执行）`
+}
+
 /** @public @author ddj 2026年10月27号 @param props Existing review callbacks and immutable record metadata. @returns Responsive review toolbar; no disk or decision side effects until an explicit action. */
 export function OfficialDiffBar(props: OfficialBarProps): React.ReactElement {
   const { official, pendingRegions = [], staleRegions = [], diffIdx = 0 } = props
@@ -75,7 +90,7 @@ export function OfficialDiffBar(props: OfficialBarProps): React.ReactElement {
 
   return <div className="edrv-diffbar edrv-diffbar-dock edrv-reviewbar" data-edrv-diffbox="1" data-edrv-diff-source="official" role="region" aria-label="文件差异审查">
     <ReviewAllRow
-      total={props.fileTotal ?? 0}
+      total={props.fileTotal ?? null}
       current={(props.fileTotal ?? 0) && (props.fileIdx ?? -1) >= 0 ? (props.fileIdx ?? 0) + 1 : 0}
       busy={props.reviewBatchBusy}
       unavailable={props.batchUnavailable}
@@ -104,7 +119,7 @@ export function OfficialDiffBar(props: OfficialBarProps): React.ReactElement {
       </div>
       <div className="edrv-review-actions">
         <Button size="sm" variant="ghost" className="edrv-review-undo" icon={barIcon('undo')} onClick={props.onUndoFile} disabled={props.reviewBatchBusy || !detail?.capability.undo} title={detail?.capability.reason}>Undo</Button>
-        <Button size="sm" variant="primary" className="edrv-review-keep" icon={barIcon('check')} onClick={props.onAcceptFile} disabled={props.reviewBatchBusy || !detail?.capability.keep} title={detail?.capability.keep ? view.keepHint : detail?.capability.reason}>Keep</Button>
+        <Button size="sm" variant="primary" className="edrv-review-keep" icon={barIcon('check')} onClick={props.onAcceptFile} disabled={props.reviewBatchBusy || !detail?.capability.keep} title={detail?.capability.keep ? keepTitle(view.keepHint, detail.capability.live !== false) : detail?.capability.reason}>Keep</Button>
         <Menu open={menu === 'more'} anchor={moreTrigger} items={[{ id: 'pending', label: '差异总览' }, { id: 'archive', label: '归档 / 历史' }]} onSelect={openOverview} onClose={closeMenu} side="top" align="end" portal compact autoFocus />
       </div>
     </div>

package/src/client/ui/SidecarDiffBar.tsx

@@ -29,7 +29,8 @@ export interface SidecarBarProps {
   /** 编辑器内容是否就绪；未就绪时不得断言差异失效 */
   contentReady?: boolean
   fileIdx?: number
-  fileTotal?: number
+  /** 待审文件总数；null 表示官方元数据尚未就绪，栏内显示占位 */
+  fileTotal?: number | null
   allPendingCount?: number
   reviewBatchBusy?: boolean
   /** 官方元数据通道失败时的可操作提示 */
@@ -86,7 +87,7 @@ export function SidecarDiffBar(props: SidecarBarProps): React.ReactElement {
 
   return <div className="edrv-diffbar edrv-diffbar-dock edrv-reviewbar" data-edrv-diffbox="1" data-edrv-diff-source="sidecar" role="region" aria-label="文件差异审查">
     <ReviewAllRow
-      total={props.fileTotal ?? 0}
+      total={props.fileTotal ?? null}
       current={(props.fileTotal ?? 0) && (props.fileIdx ?? -1) >= 0 ? (props.fileIdx ?? 0) + 1 : 0}
       busy={busy}
       pending={props.allPendingCount}

package/src/client/ui/reviewAllRow.tsx

@@ -5,8 +5,8 @@ import { Button } from '@deepseek-ai/dsh-client-ui-primitives'
 export interface ReviewAllRowProps {
   /** 当前文件序号（1 基，0 表示未定位） */
   current: number
-  /** 差异文件总数 */
-  total: number
+  /** 差异文件总数；null 表示官方元数据尚未就绪、归属还分不清，显示占位而不报个数 */
+  total: number | null
   /** 批量操作进行中 */
   busy?: boolean
   /** 批量不可用原因（悬浮提示） */
@@ -34,12 +34,13 @@ export interface ReviewAllRowProps {
  * @returns 持久化的全工作区控制条
  */
 export function ReviewAllRow(props: ReviewAllRowProps): React.ReactElement {
-  const total = props.total ?? 0
+  const known = typeof props.total === 'number'
+  const total = known ? props.total as number : 0
   const current = total && props.current > 0 ? props.current : 0
   const disabled = props.busy || !!props.unavailable || !props.pending
 
   return <div className="edrv-review-global" role="group" aria-label="全部待审文件">
-    <Button size="sm" variant="ghost" className="edrv-review-total" onClick={props.onOpen} title="打开当前工作区全部待审差异文件">差异文件 <strong>{current} / {total}</strong></Button>
+    <Button size="sm" variant="ghost" className="edrv-review-total" onClick={props.onOpen} title="打开当前工作区全部待审差异文件">差异文件 <strong>{known ? `${current} / ${total}` : '—'}</strong></Button>
     <span className="edrv-review-all-actions">
       <Button size="sm" variant="ghost" onClick={props.onKeepAll} disabled={disabled || !props.onKeepAll} title={props.unavailable || props.keepTitle || 'Keep 当前工作区全部待审文件'}>Keep All</Button>
       <Button size="sm" variant="ghost" className="edrv-review-undo" onClick={props.onUndoAll} disabled={disabled || !props.onUndoAll} title={props.unavailable || props.undoTitle || 'Undo 当前工作区全部待审文件'}>Undo All</Button>

package/src/reviewRpc.ts

@@ -1,5 +1,6 @@
 /** Session-scoped official review RPC. @author ddj 2026年10月26号 */
 import type { RpcHandlerMap } from './shared/rpc.js'
+import type { ReviewItem, ReviewPage } from './shared/review.js'
 import type { PendingPage } from './shared/pendingReview.js'
 import { decideReview, reviewDetail, reviewPage } from './reviewDb.js'
 import { undoReview } from './reviewUndo.js'
@@ -8,6 +9,50 @@ import { PENDING_PREFIX, mergedPage, pendingDetailOf, pendingItemOf, pendingSame
 import { bucketOf, resolveScope, sessionOf } from './registry.js'
 import type { Registry } from './registry.js'
 import type { Ctx } from './store.js'
+import { log } from './log.js'
+
+/** 批量写入快照的硬上限：待审积压超过它说明状态异常，宁可拒绝也不做无界写循环。 */
+const BATCH_LIMIT = 2000
+
+/** 冷端 Undo 说明：Undo 会校验证据并写回源文件，只能在持有该会话的那一端执行。 */
+const UNDO_NEEDS_LIVE = 'Undo 需要在本端活跃的会话上执行：该会话当前在另一端（Web / 桌面）激活。'
+  + 'Keep 不受影响，可在任一端执行；或在本端打开该会话后重试。'
+
+/** 冷端待审判定说明：待审库是按工作区的本地存储，判定需要与正在编辑的那一端保持一致。 */
+const PENDING_NEEDS_LIVE = '待审条目的判定需要在本端活跃的会话上执行：该会话当前在另一端激活，'
+  + '请在那一端处理，或在本端打开该会话后重试。'
+
+/**
+ * @private
+ * @author ddj 2026年10月31号
+ * @description: 批量写入用的一次性完整快照。合并口径与列表一致（待审投影优先、同路径官方旧行让位），
+ * 但一次取全，且 items 与 pending 同源，客户端才能把它当成写前不变式。
+ * @param cwd 工作区
+ * @param pending 该会话可见的待审页
+ * @returns 完整快照；待审积压超过上限或分页期间数量漂移时返回错误
+ */
+function batchSnapshot(cwd: string, pending: PendingPage): { ok: true; page: ReviewPage } | { ok: false; error: string } {
+  const first = reviewPage(cwd)
+  if (first.pending > BATCH_LIMIT) return { ok: false, error: `待审记录过多（${first.pending} 条，上限 ${BATCH_LIMIT}），请先分批处理后重试` }
+
+  const official: ReviewItem[] = []
+  let page: ReviewPage | undefined = first
+  while (page) {
+    for (const item of page.items) if (item.current && item.decision === 'pending') official.push(item)
+    page = page.nextCursor === null ? undefined : reviewPage(cwd, page.nextCursor)
+  }
+  // 分页期间有记录被判定掉：数量对不上就不给客户端一份半截快照
+  if (official.length !== first.pending) return { ok: false, error: '待审记录数量不完整，未执行批量操作' }
+
+  // 待审投影已接管的路径，官方旧行必须让位，否则同一文件会被批量写两次
+  const live = pending.items.filter((item) => !item.settled)
+  const kept = official.filter((row) => !live.some((entry) => pendingSamePath(entry.path, row.currentPath) || pendingSamePath(entry.path, row.path)))
+  const items = [...live.map((entry) => pendingItemOf(entry, cwd)), ...kept]
+  return {
+    ok: true,
+    page: { items, pending: items.length, nextCursor: null, gaps: first.gaps, ...(first.overview ? { overview: first.overview } : {}) },
+  }
+}
 
 /**
  * @public
@@ -19,20 +64,52 @@ import type { Ctx } from './store.js'
  * @returns 审查相关处理器表
  */
 export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandlerMap> {
-  /** @private @author ddj 2026年10月28号 @param sessionId 请求作用域 @returns 已迁移工作区（允许跨实例冷读） */
-  async function workspace(sessionId: string): Promise<string> {
+  /**
+   * @private
+   * @author ddj 2026年10月31号
+   * @description: 解析会话作用域，并标明本端是否持有该会话的活跃实例。
+   * 工作区一律由 host 解析，绝不采信调用方 cwd；冷读作用域只带 cwd，不带会话实例。
+   * @param sessionId 请求作用域
+   * @returns 已迁移工作区与活跃标记
+   * @throws 会话不存在、会话无工作区或活跃库迁移未完成
+   */
+  async function scopeOf(sessionId: string): Promise<{ cwd: string; live: boolean }> {
     const scope = await resolveScope(ctx, sessionId)
     if ('err' in scope) throw new Error('会话不存在或没有工作区')
+
     await bucketOf(registry, ctx, scope.cwd)
-    return scope.cwd
+    return { cwd: scope.cwd, live: !!scope.session }
   }
 
-  /** @private @author ddj 2026年10月28号 @param sessionId 请求作用域 @returns 本端 live 会话的工作区；冷读作用域一律拒绝写入 */
-  async function liveWorkspace(sessionId: string): Promise<string> {
-    const scope = await resolveScope(ctx, sessionId)
-    if ('err' in scope || !scope.session) throw new Error('会话不存在或没有工作区')
-    await bucketOf(registry, ctx, scope.cwd)
-    return scope.cwd
+  /**
+   * @private
+   * @author ddj 2026年10月31号
+   * @description: 本端是否持有该会话的活跃实例（纯诊断用，不解析工作区）。
+   * @param sessionId 请求作用域
+   * @returns 本端加载了该会话时为 true
+   */
+  function liveOf(sessionId: string): boolean {
+    return !!sessionOf(ctx, sessionId)
+  }
+
+  /**
+   * @private
+   * @author ddj 2026年10月31号
+   * @description: 按本端是否活跃覆写面板能力位。活跃端保持数据库结论；
+   * 冷端关闭依赖会话的操作（Undo、待审判定）并给出跨端原因，Keep 仍按数据库结论放行。
+   * @param capability 数据库推导的能力位
+   * @param live 本端是否持有活跃会话
+   * @param pending 是否为待审投影条目
+   * @returns 面板可用的能力位
+   */
+  function liveCapabilityOf(
+    capability: { keep: boolean; undo: boolean; reason: string },
+    live: boolean,
+    pending: boolean,
+  ): { keep: boolean; undo: boolean; reason: string; live: boolean } {
+    if (live) return { ...capability, live: true }
+    if (pending) return { keep: false, undo: false, reason: PENDING_NEEDS_LIVE, live: false }
+    return { ...capability, undo: false, live: false, reason: capability.undo ? UNDO_NEEDS_LIVE : capability.reason }
   }
 
   /**
@@ -45,13 +122,23 @@ export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandler
    * @returns 待审页（失败为空页）
    */
   function pendingPageOf(cwd: string, sessionId: string): PendingPage {
-    try { return loadPage(cwd, sessionId) }
-    catch { return { items: [], pending: 0, nextCursor: null, gaps: [] } }
+    try {
+      const page = loadPage(cwd, sessionId)
+      // 已结算（老文本与新文本一致）的投影没有净变化可审：留着会顶掉同路径的官方待审记录，
+      // 让差异栏选中一条 Keep 不可用的条目，表现为「按钮亮着却点不动」。
+      return page.items.some((item) => item.settled === true)
+        ? { ...page, items: page.items.filter((item) => item.settled !== true) }
+        : page
+    } catch { return { items: [], pending: 0, nextCursor: null, gaps: [] } }
   }
 
   return {
     'edrv.review.list': async (args) => {
-      const cwd = await workspace(args.sessionId)
+      const { cwd } = await scopeOf(args.sessionId)
+      // 批量通道要的是一次性完整快照：分页口径的 pending 只是页内展示计数，不能当完整性不变式
+      if (args.all && !args.history && args.path === undefined) {
+        return batchSnapshot(cwd, pendingPageOf(cwd, args.sessionId))
+      }
       const official = reviewPage(cwd, args.cursor, args.history, args.path)
       const pending = pendingPageOf(cwd, args.sessionId)
       // 历史快照只属于官方通道；待审条目没有轮次历史，混进去会造出假的「轮次 0」。
@@ -66,43 +153,69 @@ export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandler
         return { ok: true, page: { ...official, items: [...own, ...history] } }
       }
       // 待审投影就位后由它承接被覆盖路径，官方旧行让位，同一路径只保留一个权威
-      return { ok: true, page: mergedPage(official, pending, cwd) }
+      const merged = mergedPage(official, pending, cwd)
+      log.debug(`[review] list live=${liveOf(args.sessionId) ? 1 : 0} path=${args.path ?? '(all)'}`
+        + ` items=${merged.items.length} pending=${merged.pending} covered=${merged.overview?.coveredPaths.length ?? -1}`)
+      return { ok: true, page: merged }
     },
     'edrv.review.detail': async (args) => {
-      const cwd = await workspace(args.sessionId)
+      const scope = await scopeOf(args.sessionId)
+      const cwd = scope.cwd
       if (args.id.startsWith(PENDING_PREFIX)) {
         const detail = loadDetail(cwd, args.id.slice(PENDING_PREFIX.length))
         if (!detail) return { ok: false, error: '待审条目不存在' }
-        return { ok: true, detail: pendingDetailOf(detail, new Date(detail.item.updatedAt).toISOString(), cwd) }
+
+        const mapped = pendingDetailOf(detail, new Date(detail.item.updatedAt).toISOString(), cwd)
+        // 待审判定走本地待审库，跨端会与另一端 agent 的写入抢同一份 JSON，故冷端一律关闭
+        return { ok: true, detail: { ...mapped, capability: liveCapabilityOf(mapped.capability, scope.live, true) } }
       }
+
       const detail = reviewDetail(cwd, args.id)
-      return detail ? { ok: true, detail } : { ok: false, error: '官方审查记录不存在' }
+      if (!detail) {
+        log.debug(`[review] detail live=${scope.live ? 1 : 0} id=${args.id} found=0`)
+        return { ok: false, error: '官方审查记录不存在' }
+      }
+      // Keep 只写共享库，冷端放行；Undo 依赖会话证据与源文件写回，冷端关闭
+      const capability = liveCapabilityOf(detail.capability, scope.live, false)
+      log.debug(`[review] detail live=${scope.live ? 1 : 0} id=${args.id} found=1`
+        + ` keep=${capability.keep ? 1 : 0} undo=${capability.undo ? 1 : 0}`)
+      return { ok: true, detail: { ...detail, capability } }
     },
     'edrv.review.decide': async (args) => {
-      // 写类操作要求 live 会话：避免两端并发写同一工作区审查库，回滚也依赖本端会话内容
-      const cwd = await liveWorkspace(args.sessionId)
-      if (args.id.startsWith(PENDING_PREFIX)) {
-        // 待审条目走累计基线：Keep 零写盘，Revert 写回并读回校验
-        const result = await applyDecide(ctx.get('fs'), cwd, {
-          sessionId: args.sessionId,
-          id: args.id.slice(PENDING_PREFIX.length),
-          revision: args.revision,
-          operationId: args.operationId,
-          decision: args.decision,
-          scope: args.scope === 'hunk' ? 'block' : 'file',
-          ...(args.blockId === undefined ? {} : { blockId: args.blockId }),
-        })
-        if (!result.ok) return { ok: false, error: result.reason }
-        return { ok: true, revision: result.flags.revision }
-      }
+      // Keep 只写共享审查库（CAS + operationId 幂等 + WAL），冷端也放行；
+      // Undo 与待审判定依赖本端会话内容或本地待审库，冷端返回可读原因而不是 500。
       try {
-        const result = args.decision === 'rejected'
-          ? await undoReview(ctx, sessionOf(ctx, args.sessionId), cwd, args)
-          : decideReview(cwd, args)
+        const scope = await scopeOf(args.sessionId)
+        if (args.id.startsWith(PENDING_PREFIX)) {
+          if (!scope.live) return { ok: false, error: PENDING_NEEDS_LIVE }
+          // 待审条目走累计基线：Keep 零写盘，Revert 写回并读回校验
+          const result = await applyDecide(ctx.get('fs'), scope.cwd, {
+            sessionId: args.sessionId,
+            id: args.id.slice(PENDING_PREFIX.length),
+            revision: args.revision,
+            operationId: args.operationId,
+            decision: args.decision,
+            scope: args.scope === 'hunk' ? 'block' : 'file',
+            ...(args.blockId === undefined ? {} : { blockId: args.blockId }),
+          })
+          if (!result.ok) return { ok: false, error: result.reason }
+          return { ok: true, revision: result.flags.revision }
+        }
+
+        if (args.decision === 'rejected') {
+          if (!scope.live) return { ok: false, error: UNDO_NEEDS_LIVE }
+          const result = await undoReview(ctx, sessionOf(ctx, args.sessionId), scope.cwd, args)
+          return { ok: true, ...result }
+        }
+
+        const result = decideReview(scope.cwd, args)
+        if (!scope.live) log.info(`[review] 冷端 Keep 官方记录 ${args.id}`)
         return { ok: true, ...result }
       } catch (error) {
         // Guard failures are review results, not transport failures: preserve their reason.
-        return { ok: false, error: error instanceof Error ? error.message : String(error) }
+        const message = error instanceof Error ? error.message : String(error)
+        log.warn(`[review] decide 失败 id=${args.id} decision=${args.decision}: ${message}`)
+        return { ok: false, error: message }
       }
     },
   }

package/src/shared/review.ts

@@ -56,7 +56,8 @@ export interface ReviewDetail {
   diff: OfficialDiff
   capturedAt: string
   blocks: import('./reviewRegions.js').ReviewBlockState[]
-  capability: { keep: boolean; undo: boolean; reason: string }
+  /** live 缺省视为未知：只有 host 明确给出 false 时才代表会话不在本端活跃。 */
+  capability: { keep: boolean; undo: boolean; reason: string; live?: boolean }
 }
 export interface CaptureGap {
   sessionId: string