dsh-vscode-mode 0.25.1 → 0.26.0

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) }

package/src/reviewDb.ts

@@ -285,6 +285,38 @@ export function reviewDetail(cwd: string, id: string): ReviewDetail | null {
         : '该记录缺少可验证的原始字节或受控写回能力；仍可显示差异和 Keep，不能猜测历史全文执行 Undo。' } }
 }
 
+/**
+ * @private
+ * @author ddj 2026年11月03号
+ * @description: 把一个文件的待处理差异块整体置为目标决策，块级判定仍走 changeBlocks 的 hunk 分支。
+ * @param db 判定事务连接
+ * @param id 文件身份
+ * @param decision 目标决策
+ * @returns 无
+ */
+function markBlocks(db: DatabaseSync, id: string, decision: DecideReview['decision']): void {
+  db.prepare("UPDATE review_blocks SET decision=? WHERE file_id=? AND decision='pending'").run(decision, id)
+}
+
+/**
+ * @private
+ * @author ddj 2026年11月03号
+ * @description: 按块决定聚合回写文件决定：仍含 pending 即 pending，多值即 mixed，单一值取该值。
+ * @param db 判定事务连接
+ * @param id 文件身份
+ * @param fallback 没有任何块时的兜底决策
+ * @returns 无
+ */
+function aggregateDecision(db: DatabaseSync, id: string, fallback: string): void {
+  const states = db.prepare('SELECT DISTINCT decision FROM review_blocks WHERE file_id=?').all(id) as Row[]
+  const decisions = states.map((row) => String(row.decision))
+  let aggregate = fallback
+  if (decisions.includes('pending')) aggregate = 'pending'
+  else if (decisions.length > 1) aggregate = 'mixed'
+  else if (decisions.length === 1) aggregate = decisions[0]
+  db.prepare('UPDATE review_files SET decision=? WHERE id=?').run(aggregate, id)
+}
+
 /** @public @author ddj 2026年10月27号 @param db Active decision transaction. @param request File or block action. Updates aggregate without losing mixed decisions. @throws Invalid or already-decided block. */
 export function changeBlocks(db: DatabaseSync, request: DecideReview): void {
   if (request.scope === 'hunk') {
@@ -292,15 +324,9 @@ export function changeBlocks(db: DatabaseSync, request: DecideReview): void {
       .run(request.decision, request.id, request.blockId ?? '')
     if (changed.changes !== 1) throw new Error('差异块不存在或已处理')
   } else {
-    db.prepare("UPDATE review_blocks SET decision=? WHERE file_id=? AND decision='pending'").run(request.decision, request.id)
+    markBlocks(db, request.id, request.decision)
   }
-  const states = db.prepare('SELECT DISTINCT decision FROM review_blocks WHERE file_id=?').all(request.id) as Row[]
-  const decisions = states.map((row) => String(row.decision))
-  let aggregate = request.decision as string
-  if (decisions.includes('pending')) aggregate = 'pending'
-  else if (decisions.length > 1) aggregate = 'mixed'
-  else if (decisions.length === 1) aggregate = decisions[0]
-  db.prepare('UPDATE review_files SET decision=? WHERE id=?').run(aggregate, request.id)
+  aggregateDecision(db, request.id, request.decision)
 }
 
 /** @public @author ddj 2026年10月26号 @param cwd Workspace. @param request Frozen identity/revision. @returns Idempotent decision; rejection never guesses a target. */
@@ -334,3 +360,88 @@ export function decideReview(cwd: string, request: DecideReview): { revision: nu
     throw error
   }
 }
+
+/** 官方批量 Keep 的一条目标：id/seq 参与幂等编码，revision 只用于审计。 */
+export interface OfficialKeepItem {
+  id: string
+  seq: number
+  revision: number
+  operationId: string
+}
+/** 官方批量 Keep 的结果；skipped 只记录条目级原因，段级异常由调用方捕获。 */
+export interface OfficialKeepOutcome {
+  paths: string[]
+  skipped: { id: string; reason: string }[]
+}
+
+/**
+ * @private
+ * @author ddj 2026年11月03号
+ * @description: 取当前仍待审的官方记录摘要，作为批量写入的权威依据（不用客户端快照值）。
+ * @param db 判定事务连接
+ * @returns id → 库内 seq/revision/identity
+ */
+function pendingRows(db: DatabaseSync): Map<string, { seq: number; revision: number; identity: string }> {
+  const rows = db.prepare("SELECT id,seq,revision,identity FROM review_files WHERE current=1 AND decision='pending'").all() as Row[]
+  const map = new Map<string, { seq: number; revision: number; identity: string }>()
+  for (const row of rows) map.set(String(row.id), { seq: Number(row.seq), revision: Number(row.revision), identity: String(row.identity) })
+  return map
+}
+
+/**
+ * @public
+ * @author ddj 2026年11月03号
+ * @description: 一次事务内批量保留官方待审记录。写入条件取库内当前 revision，客户端的 seq/revision 只用于派生操作号，
+ * 因此快照漂移不会让整批中止；已结案、有尚待核对 Undo、操作号冲突的条目只跳过自己。
+ * @param cwd 工作区
+ * @param items 待保留条目（含派生好的 operationId）
+ * @returns 成功保留的 identity 列表与跳过明细
+ * @throws 事务级异常（SQL/程序错误）整体回滚后抛出
+ */
+export function keepOfficialAll(cwd: string, items: OfficialKeepItem[]): OfficialKeepOutcome {
+  const db = reviewDb(cwd)
+  const rows = pendingRows(db)
+  const outcome: OfficialKeepOutcome = { paths: [], skipped: [] }
+  const keep = db.prepare(`UPDATE review_files SET decision='accepted',revision=revision+1
+    WHERE id=? AND seq=? AND revision=? AND current=1 AND decision='pending'`)
+  const prepared = db.prepare("SELECT 1 FROM review_ops WHERE state='prepared' AND json_extract(request,'$.id')=?")
+
+  db.exec('BEGIN IMMEDIATE')
+  try {
+    for (const item of items) {
+      const encoded = JSON.stringify({ id: item.id, seq: item.seq })
+      const previous = db.prepare('SELECT request,result FROM review_ops WHERE operation_id=?').get(item.operationId) as Row | undefined
+
+      // 同一批次重放（客户端重试）按操作号幂等返回，不重复推进 revision
+      if (previous) {
+        if (previous.request !== encoded || !previous.result) outcome.skipped.push({ id: item.id, reason: '该条目已由其他操作处理' })
+        else outcome.paths.push(String((JSON.parse(String(previous.result)) as { identity: string }).identity))
+        continue
+      }
+
+      const row = rows.get(item.id)
+      if (!row || prepared.get(item.id)) {
+        outcome.skipped.push({ id: item.id, reason: row ? '该文件有尚待核对的 Undo，暂不能 Keep' : '已结案或不再是待审记录' })
+        continue
+      }
+
+      // 权威条件用库内 revision：客户端没看见的中间版本也能安全保留，落笔后仍由 CAS 兜住并发
+      if (keep.run(item.id, row.seq, row.revision).changes !== 1) {
+        outcome.skipped.push({ id: item.id, reason: '审查版本冲突，请刷新后重试' })
+        continue
+      }
+
+      markBlocks(db, item.id, 'accepted')
+      aggregateDecision(db, item.id, 'accepted')
+      db.prepare("INSERT INTO review_ops VALUES(?,?,'committed',?,NULL)")
+        .run(item.operationId, encoded, JSON.stringify({ identity: row.identity }))
+      outcome.paths.push(row.identity)
+      rows.delete(item.id)
+    }
+    db.exec('COMMIT')
+    return outcome
+  } catch (error) {
+    if (db.isTransaction) db.exec('ROLLBACK')
+    throw error
+  }
+}

package/src/reviewRpc.ts

@@ -1,10 +1,11 @@
 /** Session-scoped official review RPC. @author ddj 2026年10月26号 */
+import { createHash } from 'node:crypto'
 import type { RpcHandlerMap } from './shared/rpc.js'
-import type { ReviewDetail, ReviewItem, ReviewPage } from './shared/review.js'
+import type { KeepAllItem, KeepAllResult, ReviewDetail, ReviewItem, ReviewPage } from './shared/review.js'
 import type { PendingPage } from './shared/pendingReview.js'
-import { addedFiles, decideReview, reviewDetail, reviewPage } from './reviewDb.js'
+import { addedFiles, decideReview, keepOfficialAll, reviewDetail, reviewPage } from './reviewDb.js'
 import { undoReview } from './reviewUndo.js'
-import { applyDecide, loadDetail, loadPage } from './pending/store.js'
+import { applyDecide, keepAll, loadDetail, loadPage } from './pending/store.js'
 import { PENDING_PREFIX, mergedPage, pendingDetailOf, pendingItemOf, pendingSamePath } from './pendingCompat.js'
 import { bucketOf, resolveScope, sessionOf } from './registry.js'
 import type { Registry } from './registry.js'
@@ -164,6 +165,88 @@ export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandler
     } catch { return { items: [], pending: 0, nextCursor: null, gaps: [] } }
   }
 
+  /**
+   * @private
+   * @author ddj 2026年11月03号
+   * @description: 按批次与条目派生幂等操作号：同一批次重放复用同一结果，不重复推进 revision。
+   * @param batchId 客户端批次身份
+   * @param id 条目身份
+   * @param seq 事件序号
+   * @returns 64 位 hex 操作号
+   */
+  function operationOf(batchId: string, id: string, seq: number): string {
+    return createHash('sha256').update(`${batchId}|${id}|${seq}`).digest('hex')
+  }
+
+  /**
+   * @private
+   * @author ddj 2026年11月03号
+   * @description: 取条目展示名，缺失时退回身份本身。
+   * @param items 本批条目
+   * @param id 条目身份
+   * @returns 展示名
+   */
+  function displayOf(items: KeepAllItem[], id: string): string {
+    return items.find((item) => item.id === id)?.display ?? id
+  }
+
+  /**
+   * @private
+   * @author ddj 2026年11月03号
+   * @description: 官方段的批量保留。段级异常只记进 result.error，不取消待审段。
+   * @param cwd 工作区
+   * @param batchId 批次身份
+   * @param items 官方条目
+   * @param result 汇总结果
+   * @returns 无
+   */
+  function keepOfficialStage(cwd: string, batchId: string, items: KeepAllItem[], result: KeepAllResult): void {
+    try {
+      const outcome = keepOfficialAll(cwd, items.map((item) => ({
+        id: item.id, seq: item.seq, revision: item.revision, operationId: operationOf(batchId, item.id, item.seq),
+      })))
+      result.completed += outcome.paths.length
+      result.paths.push(...outcome.paths)
+      for (const skip of outcome.skipped) result.skipped.push({ id: skip.id, display: displayOf(items, skip.id), reason: skip.reason })
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      log.warn(`[review] keepAll 官方段失败: ${message}`)
+      if (!result.error) result.error = message
+    }
+  }
+
+  /**
+   * @private
+   * @author ddj 2026年11月03号
+   * @description: 待审段的批量保留。冷端只跳过待审条目（判定需要活跃会话），官方条目不受影响。
+   * @param scope 已解析作用域
+   * @param batchId 批次身份
+   * @param items 待审条目（带 pending 前缀）
+   * @param result 汇总结果
+   * @returns 无
+   */
+  async function keepPendingStage(
+    scope: { cwd: string; live: boolean }, batchId: string, items: KeepAllItem[], result: KeepAllResult,
+  ): Promise<void> {
+    if (!scope.live) {
+      for (const item of items) result.skipped.push({ id: item.id, display: item.display, reason: '待审条目需要在会话活跃的一端判定' })
+      return
+    }
+    const targets = items.map((item) => ({
+      id: item.id.slice(PENDING_PREFIX.length), display: item.display, operationId: operationOf(batchId, item.id, item.seq),
+    }))
+    try {
+      const outcome = await keepAll(scope.cwd, targets)
+      result.completed += outcome.kept.length
+      for (const entry of outcome.kept) result.paths.push(entry.path)
+      for (const skip of outcome.skipped) result.skipped.push({ id: PENDING_PREFIX + skip.id, display: skip.display, reason: skip.reason })
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      log.warn(`[review] keepAll 待审段失败: ${message}`)
+      if (!result.error) result.error = message
+    }
+  }
+
   return {
     'edrv.review.list': async (args) => {
       const { cwd } = await scopeOf(args.sessionId)
@@ -252,5 +335,29 @@ export function reviewHandlers(ctx: Ctx, registry: Registry): Partial<RpcHandler
         return { ok: false, error: message }
       }
     },
+    'edrv.review.keepAll': async (args) => {
+      // 批量 Keep 只写共享审查库与待审库，不写源文件；冷端只影响待审条目，官方条目照常保留。
+      try {
+        const scope = await scopeOf(args.sessionId)
+        const items = Array.isArray(args.items) ? args.items : []
+        if (!items.length) return { ok: false, error: '没有可保留的待审记录' }
+        if (items.length > BATCH_LIMIT) {
+          return { ok: false, error: `待审记录过多（${items.length} 条，上限 ${BATCH_LIMIT}），请先分批处理后重试` }
+        }
+
+        const result: KeepAllResult = { completed: 0, total: items.length, paths: [], skipped: [], error: '' }
+        const official = items.filter((item) => !item.id.startsWith(PENDING_PREFIX))
+        const pending = items.filter((item) => item.id.startsWith(PENDING_PREFIX))
+        if (official.length) keepOfficialStage(scope.cwd, args.batchId, official, result)
+        if (pending.length) await keepPendingStage(scope, args.batchId, pending, result)
+        log.info(`[review] keepAll live=${scope.live ? 1 : 0} total=${result.total}`
+          + ` kept=${result.completed} skipped=${result.skipped.length}`)
+        return { ok: true, result }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        log.warn(`[review] keepAll 失败: ${message}`)
+        return { ok: false, error: message }
+      }
+    },
   }
 }

package/src/rpc.ts

@@ -15,6 +15,7 @@ import {
   archiveRecords,
   archiveCanceled,
   autoArchiveStale,
+  retireCovered,
   policyOf,
   resolveTarget,
   resolveTargetIn,
@@ -108,15 +109,16 @@ function recView(record: DiffRecord, ws: RemoteWs | null = null): RecordView {
 }
 
 /**
- * 旧写入口守卫：路径已由待审累计基线接管时一律拒绝，避免两套权威同时写同一文件。
- * @author ddj 2026年10月29号
- * @param cwd 工作区
+ * 旧写入口守卫：本会话可见的待审累计基线接管了该路径时一律拒绝，避免两套权威同时写同一文件。
+ * 只按会话可见范围判定：别的会话在管、本会话看不见的条目不能拦人，否则用户无从处理。
+ * @author ddj 2026年11月3号
+ * @param sc 会话与工作区
  * @param path 请求涉及的路径（可为空表示无法定位）
  * @returns 拒绝原因，未接管时为 null
  */
-function legacyBlocked(cwd: string, path: string | undefined): string | null {
+function legacyBlocked(sc: { session: Session; cwd: string }, path: string | undefined): string | null {
   if (!path) return null
-  if (!pendingCovers(cwd, path)) return null
+  if (!pendingCovers(sc.cwd, path, sc.session.id)) return null
   return '该文件已由待审累计基线接管，请使用面板 Keep/Revert（edrv.review.decide）'
 }
 
@@ -645,6 +647,8 @@ export function buildHandlers(
           // #endregion
           await autoArchiveStale(ctx, sc.session, sc.cwd, bucket)
           await archiveCanceled(ctx, sc.session, sc.cwd, bucket)
+          // 已被待审累计基线接管的路径：旧记录直接结案归档，旧通道的 Keep/Undo 随之从界面消失
+          await retireCovered(ctx, sc.session, sc.cwd, bucket)
           // #region debug log
           staleMs = performance.now() - staleStart
           // #endregion
@@ -706,7 +710,7 @@ export function buildHandlers(
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const bucket = await bucketOf(registry, ctx, sc.cwd)
-      const blocked = legacyBlocked(sc.cwd, bucket.get(args.callId)?.path)
+      const blocked = legacyBlocked(sc, bucket.get(args.callId)?.path)
       if (blocked) return { ok: false, error: blocked }
       const results = await applyDecisions(ctx, sc.session, sc.cwd, bucket, [{ callId: args.callId, scope: args.scope, hunkIndex: args.hunkIndex, decision: 'accepted' }])
       const item = results[0]
@@ -717,7 +721,7 @@ export function buildHandlers(
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
       const bucket = await bucketOf(registry, ctx, sc.cwd)
-      const blocked = legacyBlocked(sc.cwd, bucket.get(args.callId)?.path)
+      const blocked = legacyBlocked(sc, bucket.get(args.callId)?.path)
       if (blocked) return { ok: false, error: blocked }
       const results = await applyDecisions(ctx, sc.session, sc.cwd, bucket, [{ callId: args.callId, scope: args.scope, hunkIndex: args.hunkIndex, decision: 'rejected' }])
       const item = results[0]
@@ -727,7 +731,7 @@ export function buildHandlers(
     'edrv.missingReview': async (args) => {
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
-      const blocked = legacyBlocked(sc.cwd, args.path)
+      const blocked = legacyBlocked(sc, args.path)
       if (blocked) return { ok: false, error: blocked }
       try {
         const bucket = await bucketOf(registry, ctx, sc.cwd)
@@ -742,7 +746,7 @@ export function buildHandlers(
     'edrv.missingDecide': async (args) => {
       const sc = await requireSession(ctx, args.sessionId)
       if ('err' in sc) return { ok: false, error: sc.err }
-      const blocked = legacyBlocked(sc.cwd, missingPath(args.token))
+      const blocked = legacyBlocked(sc, missingPath(args.token))
       if (blocked) return { ok: false, error: blocked }
       try {
         const bucket = await bucketOf(registry, ctx, sc.cwd)
@@ -754,7 +758,7 @@ export function buildHandlers(
       if ('err' in sc) return { ok: false, error: sc.err }
       const bucket = await bucketOf(registry, ctx, sc.cwd)
       const items = Array.isArray(args.items) ? args.items : []
-      const blocked = items.map((item) => legacyBlocked(sc.cwd, bucket.get(item.callId)?.path)).find((reason) => reason !== null)
+      const blocked = items.map((item) => legacyBlocked(sc, bucket.get(item.callId)?.path)).find((reason) => reason !== null)
       if (blocked) return { ok: false, error: blocked }
       const results = await applyDecisions(ctx, sc.session, sc.cwd, bucket, items)
       return { ok: true, results }

package/src/shared/review.ts

@@ -94,3 +94,24 @@ export interface DecideReview extends ReviewRequest {
   decision: 'accepted' | 'rejected'
 }
 export type ReviewResult<T> = ({ ok: true } & T) | { ok: false; error: string }
+/** 批量 Keep 的一条目标：seq/revision 只参与操作幂等与审计，写入条件以库内此刻状态为准。 */
+export interface KeepAllItem {
+  id: string
+  display: string
+  seq: number
+  revision: number
+}
+/** 批量 Keep 中被跳过的条目：跳过不是失败，条目仍留在待审列表里。 */
+export interface KeepAllSkip {
+  id: string
+  display: string
+  reason: string
+}
+/** 批量 Keep 的结果：completed/paths 只计真正落库的条目，error 只记录段级异常。 */
+export interface KeepAllResult {
+  completed: number
+  total: number
+  paths: string[]
+  skipped: KeepAllSkip[]
+  error: string
+}

package/src/shared/rpc.ts

@@ -27,7 +27,7 @@ import { DAP_ACTIONS } from './dap.js'
 import { transportUrl } from './remoteChannel.js'
 import type { LoggerLevel } from './logger.js'
 import type { SvnViewRequest, SvnViewPayload } from './svnExplorer.js'
-import type { DecideReview, ReviewDetail, ReviewPage, ReviewRequest } from './review.js'
+import type { DecideReview, KeepAllItem, KeepAllResult, ReviewDetail, ReviewPage, ReviewRequest } from './review.js'
 import type {
   PendingDecide, PendingDetail, PendingHistoryMove, PendingImport,
   PendingItem, PendingPage, PendingRemove, PendingRequest,
@@ -378,6 +378,7 @@ export interface RpcRequestMap {
   'edrv.review.list': ReviewRequest & { cursor?: number; history?: boolean; path?: string; all?: boolean }
   'edrv.review.detail': ReviewRequest & { id: string }
   'edrv.review.decide': DecideReview
+  'edrv.review.keepAll': ReviewRequest & { batchId: string; items: KeepAllItem[] }
   'edrv.pending.list': PendingRequest
   'edrv.pending.detail': PendingRequest & { id: string }
   'edrv.pending.decide': PendingDecide
@@ -563,6 +564,7 @@ export interface RpcOkMap {
   'edrv.review.list': { page: ReviewPage }
   'edrv.review.detail': { detail: ReviewDetail }
   'edrv.review.decide': { revision: number }
+  'edrv.review.keepAll': { result: KeepAllResult }
   'edrv.pending.list': { page: PendingPage }
   'edrv.pending.detail': { detail: PendingDetail }
   'edrv.pending.decide': { item: PendingItem; wrote: boolean }

package/src/store.ts

@@ -11,6 +11,8 @@ import { SIDECAR, SIDECAR_ARCHIVE } from './paths.js'
 import { log } from './log.js'
 import { debugRecord } from './debugLog.js'
 import { activeReady, appendArchive, checkActiveSource, commitActive, committedRecord, migrateActive, restoreReverts, type ActiveChange } from './archiveDb.js'
+import { pendingSamePath } from './pendingCompat.js'
+import { loadEntries } from './pending/persist.js'
 
 export { SIDECAR, SIDECAR_ARCHIVE }
 export const READ_CAP = 8 * 1024 * 1024
@@ -303,6 +305,48 @@ export async function autoArchiveStale(ctx: Ctx, session: Session, cwd: string,
   return stale.length
 }
 
+/**
+ * @public
+ * @author ddj 2026年11月3号
+ * 待审累计基线接管某路径后，旧 sidecar 记录不再有独立决策价值：标记 superseded 并归档，
+ * 连编辑器的行内 Keep/Undo 一起消失，彻底去掉"旧通道还能点、点了又被守卫拒绝"的双权威残留。
+ * 接管是文件级事实，按工作区全部待审条目判定，不跟随"本会话能否看见"漂移。
+ * @param ctx DSH 上下文
+ * @param session 当前会话
+ * @param cwd 工作区
+ * @param bucket 活跃记录桶
+ * @returns 本次结案记录数
+ * @throws 归档失败时恢复内存标志并透传错误
+ */
+export async function retireCovered(
+  ctx: Ctx, session: Session, cwd: string, bucket: Map<string, DiffRecord>,
+): Promise<number> {
+  const covers = loadEntries(cwd).flatMap((stored) => [stored.entry.path, stored.entry.id]).filter((path) => !!path)
+  if (!covers.length) return 0
+
+  const taken: DiffRecord[] = []
+  for (const rec of bucket.values()) {
+    if (rec.archived || rec.superseded === true) continue
+    if (covers.some((cover) => pendingSamePath(cover, rec.path))) taken.push(rec)
+  }
+  if (!taken.length) return 0
+
+  const original = taken.map((rec) => ({ rec, at: rec.at, superseded: rec.superseded }))
+  const at = new Date().toISOString()
+  for (const rec of taken) { rec.superseded = true; rec.at = at }
+  try {
+    await archiveRecords(ctx, session, cwd, bucket, taken, '已由待审累计基线接管，旧工具记录不再单独决策')
+  } catch (error) {
+    for (const item of original) {
+      if (item.rec.archived) continue
+      item.rec.superseded = item.superseded
+      item.rec.at = item.at
+    }
+    throw error
+  }
+  return taken.length
+}
+
 /**
  * @public
  * @author ddj 2026年10月10号