dsh-config-manager 0.1.73 → 0.1.76

package/src/core/rollback-point.ts

@@ -83,10 +83,18 @@ import {
   RollbackLedger,
   type RollbackLedgerManifestEntry,
   type RollbackLedgerMigration,
+  type RollbackLedgerPrepared,
 } from './rollback-ledger.ts'
 
 /* ------------------------------------------------------------------ 常量 */
 
+/** 增量链的最大长度：到顶就落一个**全量锚点**（重建最多读 1 份全量 + 几份小增量） */
+const ROLLBACK_DELTA_CHAIN_LIMIT = 8
+/** path → 基准摘要键（sha256/bytes/chunk 拼成，只用于判「这条与基准逐条相同」） */
+type RollbackDeltaDigest = { hash: string; chain: string[]; chunks: string[]; entries: Map<string, string> }
+/** 增量视图只有在小于全量的这个比例时才采用（否则直接全量，简单可靠） */
+const ROLLBACK_DELTA_MAX_RATIO = 0.6
+
 export const ROLLBACK_SCHEMA_VERSION = 2
 /** 回滚点库目录名（dataDir/rollback-points）——路由族 /recovery/rollback-points/* 同源 */
 export const ROLLBACK_POINTS_DIR_NAME = 'rollback-points'
@@ -194,6 +202,53 @@ export const ROLLBACK_LEFTOVER_LIST_LIMIT = 20
  * `truncated` 置真 ⇒ 删除集自动 fail-closed（证明名单不完整就一条都不删）。
  */
 export const ROLLBACK_DEFAULT_CAPTURE_BUDGET_MS = 30_000
+/**
+ * 自适应预算区间（见 RollbackEngineOptions.captureBudgetMs）：上一次留点被截断 ⇒ 下次 ×2，
+ * 上一次只用掉不到 1/4 ⇒ 下次 ÷2。区间外不再调整（避免无限拉长 / 缩到不可用）。
+ */
+export const ROLLBACK_MIN_CAPTURE_BUDGET_MS = 10_000
+export const ROLLBACK_MAX_CAPTURE_BUDGET_MS = 120_000
+/**
+ * 捕获期「读内容 + 写对象仓」的并发上限。
+ *
+ * 为什么必须并发：真机实测（34k 文件 / 512 MiB）一次全量捕获 175 s，其中 **148 s 花在
+ * 31,702 次对象写**（一次 4.7 ms：temp + fsync + rename），而走查本身只要 0.66 s。
+ * 对象写入是纯 I/O，串行做等于把预算全花在等待上 ⇒ 覆盖永远只有一小半。
+ * 并发上限与**在飞字节闸门**共同限流（在飞内容上界 = `captureInFlightBytes`）。
+ */
+export const ROLLBACK_DEFAULT_CAPTURE_CONCURRENCY = 16
+/**
+ * 捕获期**读入内存、尚未落对象仓**的内容字节上限（真正的内存闸门）。
+ *
+ * 为什么必须独立于 `maxFileBytes`（0.1.74 真机闪退事故，2026-10-16）：
+ *  `maxFileBytes` 的缺省是**总量预算** `maxBytes`（512 MiB）。并发捕获把闸门接到它上面，
+ *  于是「同时在飞的内容」可以到 ~512 MiB —— 串行实现的上界是「一份文件」，并发实现的
+ *  上界是「闸门限额」，两者差着两三个数量级。真机表现：发出消息后 1–2 s（= `turn/start`
+ *  开始留点）DSH Desktop 宿主被系统终止 ⇒ 桌面闪退（无 JS 栈、插件零错误、
+ *  退出码是「被外部终止」形状）。这里取一个小常量当闸门；要放宽只能显式传
+ *  `captureInFlightBytes`，且被 `maxBytes` 夹住。
+ */
+export const ROLLBACK_DEFAULT_CAPTURE_INFLIGHT_BYTES = 32 * 1024 * 1024
+/** 对象写遇到这些码视为「瞬时占用」，有界退避重试（判据同 atomic-write 的 isRetryableLockCode） */
+const OBJECT_WRITE_RETRY_CODES = ['EPERM', 'EBUSY', 'EACCES', 'ENOTEMPTY']
+/** 捕获阶段①的 stat 批大小：判定仍严格按顺序，只是 stat 并发取（真机 34k 次 stat 从 5 s → <1 s） */
+export const ROLLBACK_CAPTURE_STAT_BATCH = 128
+/**
+ * 捕获期**候选名单**上限（不是入点上限）：必须显著大于 maxFiles，否则「缺口优先」排序作用不到
+ * 那些排在遍历顺序尾部、上一回合没覆盖到的文件（它们连候选都进不了 ⇒ 覆盖率永远不收敛）。
+ * 走查本来就会把每条路径记进 walked（路径索引的来源），这里多留的只是候选数组本身。
+ */
+export const ROLLBACK_CAPTURE_LIST_LIMIT = 200_000
+/** 捕获阶段①的 stat 结果（一次 bigint stat 拿到大小 / mtime / 身份；失败时带原始 detail） */
+interface RollbackFileStat {
+  isFile: boolean
+  size: number
+  mtimeMs: number
+  identity: string | null
+  error?: string
+}
+/** 走查中断时逐条记下的「没进去的子树」上限；超出即放弃精确范围，退回全局 fail-closed */
+export const ROLLBACK_UNWALKED_DIRS_LIMIT = 200
 
 /**
  * 「删除回退点之后新建的路径」的**整套上限**（用户 2026-10-11 定案 A）。
@@ -227,6 +282,14 @@ export const ROLLBACK_PREVIEW_DIFF_TOTAL_WORK = 32_000_000
 export const ROLLBACK_FILE_DIFF_LIMITS = {
   maxFileBytes: ROLLBACK_PREVIEW_DIFF_MAX_FILE_BYTES,
   context: 3,
+  /**
+   * Myers 编辑距离上限（2026-10-15 用户：不该动辄出现「已按整块替换展示」）。
+   * 实测（本仓 rollback-point.ts 的 4983 行 × 2492 行版本对）：D 在 3000~4000 就能拿到
+   * 最小编辑脚本 —— 耗时 ≤70 ms；代价是回溯的 V 快照 O(D²)，RSS 峰值 +~100 MB。
+   * 缺省那档 400 会让几千行里的普通改动一律退化成「整块替换」，那正是用户看到的那条提示；
+   * 单文件是**按需点开**的一屏，这点内存换「真差异」划算。再大就换算法，不加预算。
+   */
+  maxD: 4000,
 } as const
 
 /** 恢复顺序（工作区在前；工作区失败即中止后面的会话段） */
@@ -359,7 +422,8 @@ export interface RollbackSkippedEntry {
   /**
    * link（符号链接/junction，不跟随）/ missing / not-a-file / self-store /
    * dep-dir（运行时依赖目录，整棵忽略）/ ignored（用户忽略规则命中）/ too-large（超单文件上限）/
-   * budget-bytes（加它会超总量预算）/ budget-files（文件数预算用尽）
+   * budget-bytes（加它会超总量预算）/ budget-files（文件数预算用尽）/
+   * asar-container（含 `.asar` 段的路径：宿主会把它当容器解析、畸形夹具能带走宿主，因此绝不碰）
    */
   reason: string
 }
@@ -383,7 +447,28 @@ export interface RollbackPathIndex {
 export interface RollbackWorkspacePayload {
   /** 显式路径分块：恢复只在这些分块内覆盖 */
   chunks: string[]
+  /**
+   * 记录在案的**文件条目数**。**必须自带**（不能再用 `files.length`）：增量视图下 `files` 只是
+   * 「相对基准新增/改写的子集」，而摘要（界面上的条数 / 可恢复判定）要的是全量条数。
+   */
+  fileCount?: number
   files: RollbackWorkspaceFile[]
+  /**
+   * **存盘专用**：这份载荷是「相对某个基准载荷的增量」（见 rollback-ledger 的 resolvePayload）。
+   * 只在写盘那一刻存在 —— 任何读路径（readRecord / 预览 / 回退 / 对象回收）拿到的都是**物化后**
+   * 的完整 `files`（`delta` 已被抹掉）。**绝不把带 delta 的对象交给消费者**：它看起来像一份
+   * 「只有这几条记录」的完整清单，拿去规划删除会删掉其它全部文件。
+   */
+  delta?: {
+    /** 基准载荷的内容寻址哈希（必须在 prune/回收时一并保活） */
+    base: string
+    /** 基准自己的依赖链（深→浅，含基准），保活用 */
+    baseChain: string[]
+    /** 相对基准**不再存在**的路径（逐字，与捕获产出的绝对路径同形） */
+    removed: string[]
+    /** 相对基准**新增 / 改写**的条目（`files` 在增量视图下为 null） */
+    added?: RollbackWorkspaceFile[]
+  }
   skipped: RollbackSkippedEntry[]
   /**
    * 整棵跳过的「运行时依赖目录」（忽略规则 = 全仓唯一来源 EXCLUDED_DEP_DIR_NAMES，当前 node_modules）。
@@ -422,6 +507,12 @@ export interface RollbackWorkspacePayload {
    * 老台账（本字段诞生前写下的点）一律没有它：按「名单完整」处理（与旧行为一致）。
    */
   walkIncomplete?: boolean
+  /**
+   * 走查被中断时**栈里还没进去的子树**（精确到目录）。有它 ⇒ 拒删只覆盖这些子树
+   * （分子树 fail-closed），而不是把整个工作区的删除全关掉；缺它（老台账 / 栈太深被截断）
+   * ⇒ 退回全局拒删。与 walkIncomplete 一起看：后者是「安全判据」，本字段是「精确范围」。
+   */
+  unwalkedDirs?: string[]
   /** 命中文件数 / 字节上限（内容未全部进来，已如实留痕） */
   truncated: boolean
   bytes: number
@@ -942,8 +1033,25 @@ export interface RollbackEngineOptions {
   /**
    * 工作区捕获的挂钟时间预算（毫秒，缺省 ROLLBACK_DEFAULT_CAPTURE_BUDGET_MS）。
    * 超时留**部分点**，不拒绝留点；见该常量的说明。
+   *
+   * 运行期**自适应**：被截断 ⇒ 下次翻倍；用得很少 ⇒ 下次减半（区间见
+   * ROLLBACK_MIN/MAX_CAPTURE_BUDGET_MS）。回退期走查的预算见 rewindBudgetMs。
    */
   captureBudgetMs?: number
+  /** 自适应区间下界（缺省 ROLLBACK_MIN_CAPTURE_BUDGET_MS；测试可注入更小值） */
+  captureBudgetMinMs?: number
+  /** 自适应区间上界（缺省 ROLLBACK_MAX_CAPTURE_BUDGET_MS；测试可注入更小值） */
+  captureBudgetMaxMs?: number
+  /** 回退期走查的时间预算（缺省 = captureBudgetMs 初值；**不参与自适应**） */
+  rewindBudgetMs?: number
+  /** 捕获期读 + 写并发上限（缺省 ROLLBACK_DEFAULT_CAPTURE_CONCURRENCY，1..64） */
+  captureConcurrency?: number
+  /**
+   * 捕获期**在飞内容字节**上限（缺省 ROLLBACK_DEFAULT_CAPTURE_INFLIGHT_BYTES = 32 MiB，
+   * 有效范围 1..maxBytes）。与 `maxFileBytes`（单文件「要不要读」的判据）是两件事：
+   * **这个才是并发的内存闸门**。
+   */
+  captureInFlightBytes?: number
   guardPolicy?: RollbackGuardPolicy
   /** 存储栈探针（缺省 = 真实磁盘探测）；注入失败探针可测「缺失时仍可挂载」 */
   storage?: RollbackStorageProbe
@@ -977,6 +1085,24 @@ function win32Fold(value: string): string {
   return process.platform === 'win32' ? value.toLowerCase() : value
 }
 
+/**
+ * 路径里是否存在以 `.asar` 结尾的段（**捕获 / 走查期一律不碰这类路径**）。
+ *
+ * 为什么（真机事故，0.1.76）：Electron 宿主对任何含 `.asar` 段的路径**启用了 asar 虚拟化** ——
+ * 即使那只是个普通文件，`fs.stat`/`readdir`/`read` 也会被接管去当容器解析。工作区里只要躺着一枚
+ * **畸形** `.asar`（测试夹具、被打断的打包残留），宿主进程就会被原生层带走：crashpad
+ * `not connected`、退出码 4294930435 ⇒ DSH Desktop 闪退（无 JS 栈、插件零错误）。
+ * 实测（本仓真机捕获、同一份输入）：`.tmp` 下 19 枚 `.asar` 夹具在场 → Electron 进程死；
+ * 全部改名后 → 同一趟捕获 9 s 跑完、退出码 0。
+ * `.asar.unpacked` 是**真目录**（段名不以 `.asar` 结尾）⇒ 不拦。
+ */
+export function hasAsarSegment(target: string): boolean {
+  for (const segment of target.split(/[\\/]+/)) {
+    if (segment.length > '.asar'.length && win32Fold(segment).endsWith('.asar')) return true
+  }
+  return false
+}
+
 /** child 是否等于 parent 或位于其下（win32 折叠大小写；段边界判定） */
 export function isInsidePath(child: string, parent: string): boolean {
   const c = win32Fold(path.resolve(child))
@@ -989,6 +1115,87 @@ function pathKey(value: string): string {
   return win32Fold(path.resolve(value))
 }
 
+/** 两个分块列表是否逐个相同（增量基准必须作用于同一批分块） */
+function sameChunks(a: readonly string[], b: readonly string[]): boolean {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false
+  return true
+}
+
+/**
+ * **存盘视图**：条目里的 `object` 恒等于 `sha256`（内容寻址的名字就是内容哈希）⇒ 落盘时不写这个字段，
+ * 读取时按 `sha256` 补回（见 ledger 的 `withObjectRefs`）。每条约省 1/5 字节。
+ */
+function compactPayloadForStorage(payload: RollbackWorkspacePayload): RollbackWorkspacePayload {
+  const strip = (list: RollbackWorkspaceFile[] | null | undefined): RollbackWorkspaceFile[] | null | undefined => {
+    if (!Array.isArray(list)) return list
+    return list.map((file) => {
+      const copy: Record<string, unknown> = { ...file }
+      delete copy['object']
+      return copy as unknown as RollbackWorkspaceFile
+    })
+  }
+  const delta = payload.delta
+  return {
+    ...payload,
+    files: strip(payload.files) as RollbackWorkspaceFile[],
+    ...(delta === undefined
+      ? {}
+      : { delta: { ...delta, ...(delta.added === undefined ? {} : { added: strip(delta.added) as RollbackWorkspaceFile[] }) } }),
+  }
+}
+
+/**
+ * 构造「相对基准的增量视图」；不划算（≥ 全量 × {@link ROLLBACK_DELTA_MAX_RATIO}）时返回 null。
+ *
+ * 条目**逐字比较**：路径、sha、字节数、mtimeMs、所属分块任一不同 ⇒ 进 `added`；基准里不再存在的路径进 `removed`。
+ * 重建 = 基准 − removed，再用 added 覆盖/追加，最后按路径排序（与全量捕获同序）。
+ */
+/** 基准摘要键：内容 + 字节数 + 所属分块（`mtimeMs` 不参与 —— 只被触摸、内容没变的文件不必进增量） */
+function digestKeyOf(file: RollbackWorkspaceFile): string {
+  return String(file.sha256) + ':' + String(file.bytes) + ':' + String(file.chunk)
+}
+
+/** 相对**内存基准摘要**的条目差异（新增/改写 / 不再存在）；路径逐字比较，不读任何文件 */
+function payloadDiffAgainstDigest(
+  payload: RollbackWorkspacePayload,
+  baseEntries: ReadonlyMap<string, string>,
+): { added: RollbackWorkspaceFile[]; removed: string[] } {
+  const added: RollbackWorkspaceFile[] = []
+  const nextPaths = new Set<string>()
+  for (const file of payload.files) {
+    nextPaths.add(file.path)
+    const prev = baseEntries.get(file.path)
+    if (prev === undefined || prev !== digestKeyOf(file)) added.push(file)
+  }
+  const removed: string[] = []
+  for (const path of baseEntries.keys()) if (!nextPaths.has(path)) removed.push(path)
+  return { added, removed }
+}
+
+
+/**
+ * 构造「相对基准的增量视图」；不划算（≥ 全量 × {@link ROLLBACK_DELTA_MAX_RATIO}）时返回 null。
+ * 重建 = 基准 − removed，再用 added 覆盖/追加，最后按路径排序（与全量捕获同序）。
+ */
+function buildPayloadDelta(
+  payload: RollbackWorkspacePayload,
+  baseHash: string,
+  baseChain: readonly string[],
+  diff: { added: RollbackWorkspaceFile[]; removed: string[] },
+): RollbackWorkspacePayload | null {
+  if (baseHash === '') return null
+  const delta: RollbackWorkspacePayload = {
+    ...payload,
+    // **故意不是数组**：不认识 `delta` 的旧读取器会在形状校验这一步**拒绝这个点**（fail-closed），
+    // 而不是把「增量那几条」当成完整清单去规划删除 —— 那会把留点时存在的文件全判成新建、全部删掉。
+    files: null as unknown as RollbackWorkspaceFile[],
+    delta: { base: baseHash, baseChain: [...baseChain], removed: diff.removed, added: diff.added },
+  }
+  if (JSON.stringify(delta).length >= JSON.stringify(payload).length * ROLLBACK_DELTA_MAX_RATIO) return null
+  return delta
+}
+
 function errorDetail(error: unknown): string {
   if (error instanceof Error) {
     const code = (error as { code?: unknown }).code
@@ -1223,6 +1430,16 @@ export function resolveTurnBoundary(
   return { ok: true, boundarySeq: boundary.boundarySeq, endSeq: boundary.endSeq }
 }
 
+/**
+ * 记录在案的文件条目数：优先用载荷自带的 `fileCount`（增量视图下 `files` 可能只是子集），
+ * 老载荷没有该字段才回落到 `files.length`。
+ */
+export function workspaceFileCount(payload: RollbackWorkspacePayload | null): number {
+  if (payload === null) return 0
+  if (typeof payload.fileCount === 'number' && Number.isFinite(payload.fileCount)) return payload.fileCount
+  return payload.files.length
+}
+
 export function summarizeRollbackPoint(record: RollbackPointRecord): RollbackPointSummary {
   const workspace = record.workspace.payload
   const session = record.session.payload
@@ -1262,7 +1479,16 @@ export function summarizeRollbackPoint(record: RollbackPointRecord): RollbackPoi
     note: record.note,
     spreadMs: record.spreadMs,
     segments: [
-      segment('workspace', record.workspace, workspace?.files.length ?? 0, workspace?.bytes ?? 0, null, (workspace?.files.length ?? 0) > 0, workspace?.skippedCount ?? 0, workspace?.truncated ?? false),
+      segment(
+        'workspace',
+        record.workspace,
+        workspaceFileCount(workspace),
+        workspace?.bytes ?? 0,
+        null,
+        workspaceFileCount(workspace) > 0,
+        workspace?.skippedCount ?? 0,
+        workspace?.truncated ?? false,
+      ),
       segment(
         'session',
         record.session,
@@ -1451,6 +1677,59 @@ class UndoStager {
   }
 }
 
+/**
+ * 单文件字节闸门：保证「同时在飞（已读入、尚未落仓）的内容字节」≤ limit。
+ *
+ * 与 captureConcurrency 一起构成捕获期的内存上界：并发只放大**同时**驻留的量，而它被
+ * `captureInFlightBytes` 钉死（缺省 32 MiB）。**不能**用 maxFileBytes 当限额 —— 它缺省 =
+ * 总量预算 512 MiB，「一份文件」与「整个点的预算」不是同一个量级（0.1.74 闪退根因）。
+ */
+/**
+ * 路径身份键：dev:ino:size:mtimeNs:ctimeNs:mode（全 BigInt 字符串化）。必须 BigInt：ino / mtimeNs /
+ * ctimeNs 在 64 位 inode 文件系统上超出 Number 安全整数范围，用 Number 会静默丢精度（把两次不同的
+ * 写当成同一个身份）。单一来源：fileStatOf 与 pathIdentityOf 都用它。
+ */
+function fileIdentityOf(stat: { dev: bigint; ino: bigint; size: bigint; mtimeNs: bigint; ctimeNs: bigint; mode: bigint }): string {
+  return [
+    String(stat.dev),
+    String(stat.ino),
+    String(stat.size),
+    String(stat.mtimeNs),
+    String(stat.ctimeNs),
+    String(stat.mode & 0o777n),
+  ].join(':')
+}
+
+/** 预览的逐条判定（阶段 A 并发产出；阶段 B 按记录顺序装配，语义与旧串行实现逐条一致） */
+type PreviewScanResult =
+  | { kind: 'ok'; size: number; regular: boolean; unchanged: boolean }
+  | { kind: 'missing' }
+  | { kind: 'unavailable' }
+
+class ByteGate {
+  private used = 0
+  private readonly waiters: (() => void)[] = []
+  private readonly limit: number
+
+  constructor(limit: number) {
+    this.limit = limit
+  }
+
+  async acquire(bytes: number): Promise<void> {
+    const need = Math.max(0, Math.min(bytes, this.limit))
+    while (this.used + need > this.limit && this.used > 0) {
+      await new Promise<void>((resolve) => { this.waiters.push(resolve) })
+    }
+    this.used += need
+  }
+
+  release(bytes: number): void {
+    this.used = Math.max(0, this.used - Math.max(0, Math.min(bytes, this.limit)))
+    const next = this.waiters.shift()
+    if (next !== undefined) next()
+  }
+}
+
 export class RollbackPointEngine {
   private readonly dataDir: string
   private readonly homeDir: string
@@ -1462,6 +1741,7 @@ export class RollbackPointEngine {
   private readonly maxFiles: number
   private readonly maxBytes: number
   private readonly maxFileBytes: number
+  private readonly captureInFlightBytes: number
   private readonly maxSkippedEntries: number
   private readonly sessionMaxBytes: number
   private readonly sessionQuiescentMs: number
@@ -1493,14 +1773,42 @@ export class RollbackPointEngine {
   private forkLinksAt = 0
   private forkLinksComplete = true
   /** 会话日志头缓存（mtime + size 失效；只服务 fork 链扫描） */
+  /**
+   * **本进程**最近一次成功留点的工作区摘要（清单增量化的基准）。
+   *
+   * 为什么是内存而不是读盘：一次留点只准读清单（L-08 / issue #89）—— 读上一份 12 MB 载荷去算差异
+   * 正是那条被消灭的路。内存量 ≈ 每文件一个 `sha:bytes:chunk` 串（3.4 万文件约几 MB），
+   * 与已有的身份缓存（`pathCache`）同量级；进程重启后第一次留点落全量锚点，随后继续链。
+   */
+  private deltaBase: RollbackDeltaDigest | null = null
+
   private readonly forkHeaderCache = new Map<string, { mtimeMs: number; size: number; header: SessionForkHeader | null }>()
   /** 继承判据用的台账快照（TTL 缓存；只缓存**清单条目**，绝不缓存完整记录） */
   private ledgerSnapshotCache: { at: number; entries: RollbackLedgerManifestEntry[] } | null = null
   /** 台账存储层（v3：清单 + 单条记录 + 内容寻址载荷；issue #89） */
   private readonly ledger: RollbackLedger
   private readonly ledgerBytesBudget: number
-  /** 工作区捕获的挂钟时间预算（毫秒；见 ROLLBACK_DEFAULT_CAPTURE_BUDGET_MS） */
-  private readonly captureBudgetMs: number
+  /**
+   * 工作区捕获的挂钟时间预算（毫秒；见 ROLLBACK_DEFAULT_CAPTURE_BUDGET_MS）。**可变**：
+   * 每次留点后按「是否被截断 / 用掉多少」自适应（见 ROLLBACK_MIN/MAX_CAPTURE_BUDGET_MS）。
+   */
+  private captureBudgetMs: number
+  /** 自适应区间下界 / 上界（构造期定死，运行期只调 captureBudgetMs） */
+  private readonly captureBudgetMinMs: number
+  private readonly captureBudgetMaxMs: number
+  /** 回退期走查的时间预算（与捕获预算分开：自适应不该顺手拉长回退期的走查） */
+  private readonly rewindBudgetMs: number
+  /** 捕获期读 + 写并发上限 */
+  private readonly captureConcurrency: number
+  /** 对象仓目录已确认存在（省掉每个对象一次 mkdir） */
+  private objectsDirReady = false
+  /**
+   * 本回合对象名单快照（一次 readdir 顶掉「每个候选一次 fs.access」；真机 34k 次 access ≈ 3.7 s）。
+   * null = 读不到名单（首次还没建目录/异常）⇒ 回落逐条 objectExists。
+   * 只保证「写进去的立刻可见」：捕获期间被**并发删除**的对象可能仍被判为存在 —— 那一路由
+   * 读取侧（readObject + 哈希校验）响亮失败，不会静默给出错误的 before 内容。
+   */
+  private captureObjectNames: Set<string> | null = null
   /**
    * 启动期一次性初始化（流式迁移 v2 -> v3 + 孤儿 tmp 清理）的惰性单飞。
    * 为什么惰取而不是构造时同步跑：构造发生在每个请求路径上，同步扫盘/迁移会把请求卡死；
@@ -1522,6 +1830,10 @@ export class RollbackPointEngine {
     this.maxBytes = options.maxBytes ?? ROLLBACK_DEFAULT_MAX_BYTES
     // 单文件上限缺省 = 总量预算（一个文件不可能比整个点的预算更大）
     this.maxFileBytes = options.maxFileBytes ?? this.maxBytes
+    // **内存闸门与单文件上限分开**：拿 maxFileBytes 当闸门 = 允许把整个点的预算同时驻留
+    // （0.1.74 真机闪退的根因），见 ROLLBACK_DEFAULT_CAPTURE_INFLIGHT_BYTES。
+    const inFlight = options.captureInFlightBytes ?? ROLLBACK_DEFAULT_CAPTURE_INFLIGHT_BYTES
+    this.captureInFlightBytes = Math.max(1, Math.min(this.maxBytes, Math.floor(inFlight)))
     this.maxSkippedEntries = options.maxSkippedEntries ?? ROLLBACK_SKIPPED_LIST_LIMIT
     this.sessionMaxBytes = options.sessionMaxBytes ?? ROLLBACK_DEFAULT_SESSION_MAX_BYTES
     this.sessionQuiescentMs = options.sessionQuiescentMs ?? ROLLBACK_DEFAULT_SESSION_QUIESCENT_MS
@@ -1541,6 +1853,10 @@ export class RollbackPointEngine {
     this.log = options.log
     this.ledgerBytesBudget = options.ledgerBytesBudget ?? ROLLBACK_DEFAULT_LEDGER_BYTES
     this.captureBudgetMs = options.captureBudgetMs ?? ROLLBACK_DEFAULT_CAPTURE_BUDGET_MS
+    this.captureBudgetMinMs = options.captureBudgetMinMs ?? ROLLBACK_MIN_CAPTURE_BUDGET_MS
+    this.captureBudgetMaxMs = options.captureBudgetMaxMs ?? ROLLBACK_MAX_CAPTURE_BUDGET_MS
+    this.rewindBudgetMs = options.rewindBudgetMs ?? this.captureBudgetMs
+    this.captureConcurrency = Math.max(1, Math.min(64, Math.floor(options.captureConcurrency ?? ROLLBACK_DEFAULT_CAPTURE_CONCURRENCY)))
     this.ledger = new RollbackLedger({
       root: this.root,
       bytesBudget: this.ledgerBytesBudget,
@@ -1711,17 +2027,47 @@ export class RollbackPointEngine {
 
   /* -------------------------------------------------------------- 对象仓 */
 
+  /** 对象仓目录只 mkdir 一次（每个对象各 mkdir 一次是纯白花的 syscall） */
+  private async ensureObjectsDir(): Promise<void> {
+    if (this.objectsDirReady) return
+    await fs.mkdir(this.objectsDir, { recursive: true })
+    this.objectsDirReady = true
+  }
+
+  /**
+   * 写内容寻址对象（对象文件名 = 内容 SHA-256）。
+   *
+   * **为什么这里不用 atomicWriteFile**：那是给「可写配置文件」用的强原子写（同目录 tmp → fsync →
+   * rename），真机实测一次约 4.7 ms —— 34k 文件的工作区一次全量捕获 148 s 全花在它上面（走查本身
+   * 只要 0.66 s）。对象仓的正确性要求不同：文件名即内容哈希 ⇒
+   *   · 用 'wx' **独占创建最终名**本身已是原子的（不覆盖已有对象；并发同写只有一方成功）；
+   *   · 半截 / 被篡改的内容在读取侧必然过不了哈希校验（readObject + sha256Hex）⇒ 按「读不出」
+   *     处理并 fail-closed，绝不会冒充有效前像；
+   *   · 不做 fsync：回滚点是尽力而为的本地快照，不为掉电持久性付出每文件一次 fsync 的代价。
+   */
   private async writeObjectWithHash(bytes: Uint8Array, sha: string): Promise<string> {
     if (!OBJECT_KEY_RE.test(sha)) throw new Error('rollback object key invalid')
     const target = path.join(this.objectsDir, sha)
     if (!isInsidePath(target, this.objectsDir)) throw new Error('rollback object path escapes store')
-    await fs.mkdir(this.objectsDir, { recursive: true })
-    try {
-      await fs.access(target)
-      return sha
-    } catch { /* 不存在才写（内容寻址天然去重） */ }
-    await atomicWriteFile(target, bytes)
-    return sha
+    await this.ensureObjectsDir()
+    let delay = 10
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        await fs.writeFile(target, bytes, { flag: 'wx' })
+        this.captureObjectNames?.add(sha)
+        return sha
+      } catch (error) {
+        const code = (error as { code?: unknown }).code
+        if (code === 'EEXIST') return sha // 已有同内容对象（去重 / 并发竞写）
+        // 杀软 / 句柄瞬时占用：有界退避重试（与 atomic-write 的判据同族）
+        if (OBJECT_WRITE_RETRY_CODES.includes(code as string) && attempt < 3) {
+          await new Promise<void>((resolve) => setTimeout(resolve, delay))
+          delay *= 2
+          continue
+        }
+        throw error
+      }
+    }
   }
 
   /** 对象仓里是否真有这个 blob（缓存命中时校验；任何异常一律按「没有」处理） */
@@ -1840,6 +2186,10 @@ export class RollbackPointEngine {
   /**
    * 列出一个显式分块内的候选文件（不跟随符号链接 / junction；跳过与读不到都留痕）。
    * 返回 null = 该分块本身不可用（不存在 / 是链接 / 非常规文件），细节已写进 sink。
+   *
+   * `truncated` 与 `walkAborted` 是**两件事**：前者只说「本次列表不完整」（文件数上限 / 提交上限），
+   * 后者说「走查被预算或取消打断，栈里还有没进去的子树」—— 只有后者才意味着那些路径
+   * **一条都没进任何名单**，调用方必须据此让删除集 fail-closed。
    */
   private async listChunkFiles(
     chunk: string,
@@ -1853,10 +2203,16 @@ export class RollbackPointEngine {
     ignore?: IgnoreRules,
     /**
      * 停止判据（捕获期传时间/取消预算；回退期的走查不传）—— 返回 true 立即停止遍历，
-     * 已走查的部分照常返回并置 truncated（证明名单因此不完整 ⇒ 删除集 fail-closed）。
+     * 已走查的部分照常返回并置 truncated + walkAborted（栈里剩余的子树从未进门 ⇒ 由调用方据此 fail-closed；
+     * 回退期不传它，故 walkAborted 恒 false）。
      */
     shouldStop?: () => boolean,
-  ): Promise<{ files: string[]; truncated: boolean } | null> {
+  ): Promise<{ files: string[]; truncated: boolean; walkAborted: boolean; unwalkedDirs: string[] } | null> {
+    // 分块根本身就是 `.asar` 段 ⇒ 一次 fs 调用都不发（见 hasAsarSegment）
+    if (hasAsarSegment(chunk)) {
+      this.recordSkip(sink, 'skipped', { path: chunk, reason: 'asar-container' })
+      return null
+    }
     let stat
     try {
       stat = await fs.lstat(chunk)
@@ -1868,16 +2224,25 @@ export class RollbackPointEngine {
       this.recordSkip(sink, 'skipped', { path: chunk, reason: 'link' })
       return null
     }
-    if (stat.isFile()) return { files: [chunk], truncated: false }
+    if (stat.isFile()) return { files: [chunk], truncated: false, walkAborted: false, unwalkedDirs: [] }
     if (!stat.isDirectory()) {
       this.recordSkip(sink, 'skipped', { path: chunk, reason: 'not-a-file' })
       return null
     }
     const out: string[] = []
     let truncated = false
+    // 走查**被预算 / 取消打断**：栈里还压着没进去的子树 —— 那些路径一条都没进任何名单
+    let walkAborted = false
+    // 中断时把**还没进去的子树**如实带出去 ⇒ 调用方可以只对这几棵子树 fail-closed（精确范围）
+    let unwalkedDirs: string[] = []
     const stack: { dir: string; depth: number }[] = [{ dir: chunk, depth: 0 }]
     while (stack.length > 0) {
-      if (shouldStop?.() === true) { truncated = true; break }
+      if (shouldStop?.() === true) {
+        truncated = true
+        walkAborted = true
+        unwalkedDirs = stack.length > ROLLBACK_UNWALKED_DIRS_LIMIT ? [] : stack.map((item) => item.dir)
+        break
+      }
       const item = stack.pop()
       if (item === undefined) break
       if (item.depth >= MAX_WALK_DEPTH) {
@@ -1893,6 +2258,13 @@ export class RollbackPointEngine {
       }
       for (const entry of entries) {
         const full = path.join(item.dir, entry.name)
+        // **绝不把含 `.asar` 段的路径交给 fs**（见 hasAsarSegment：宿主里这一步是原生解析，
+        // 畸形夹具会让整个宿主进程消失）。留痕进 skipped —— 它是**证明名单**的一员，
+        // 因此该路径绝不会被当成「留点后新建」删掉。
+        if (hasAsarSegment(full)) {
+          this.recordSkip(sink, 'skipped', { path: full, reason: 'asar-container' })
+          continue
+        }
         if (entry.isSymbolicLink()) {
           this.recordSkip(sink, 'skipped', { path: full, reason: 'link' })
           continue
@@ -1940,7 +2312,7 @@ export class RollbackPointEngine {
       }
     }
     out.sort()
-    return { files: out, truncated }
+    return { files: out, truncated, walkAborted, unwalkedDirs }
   }
 
   private async captureWorkspace(
@@ -1954,6 +2326,8 @@ export class RollbackPointEngine {
     // 自动落成 capture-truncated，UI 走既有的 degraded 提示路径（零新增文案）。
     const deadline = capturedAt + this.captureBudgetMs
     const outOfBudget = (): boolean => signal?.aborted === true || this.stamp() >= deadline
+    // 对象名单快照按回合重建（一次 readdir 换掉每个候选一次 fs.access）
+    this.captureObjectNames = null
     const payload: RollbackWorkspacePayload = {
       chunks: [...chunks],
       files: [],
@@ -1973,115 +2347,58 @@ export class RollbackPointEngine {
     let sawChunk = false
     // 走查过的**全部**文件路径（含被预算 / 单文件上限挡下的）—— 路径索引的来源（方向 B）
     const walked: string[] = []
+    // 走查中断时**没进去的子树**（精确到目录）—— 供删除集做分子树 fail-closed
+    const unwalked: string[] = []
     for (const chunk of chunks) {
       if (outOfBudget()) {
         // 分块之间就超预算：不再开新分块，并如实留痕（该分块的条目一条都没被走查）
-        // walkIncomplete 是**安全判据**（删除集 fail-closed），漏了它会删掉未走查子树里的文件
+        // walkIncomplete 是**安全判据**（删除集 fail-closed）；这里能精确给出「没进去的是哪个分块」
+        // ⇒ 删除只拒这棵子树，不再把整个工作区的新建文件一起放弃。
         payload.walkIncomplete = true
         payload.truncated = true
+        unwalked.push(chunk)
         this.recordSkip(payload, 'skipped', { path: chunk, reason: 'budget-time' })
         break
       }
       if (!path.isAbsolute(chunk)) return this.emptyTrack('workspace', capturedAt, 'chunk-not-absolute', chunk)
       const resolved = path.resolve(chunk)
       // 文件数预算还剩多少就收多少；+1 只用于让遍历器发现「还有溢出」——溢出条目逐条记 skipped
-      const listed = await this.listChunkFiles(resolved, payload, Math.max(0, this.maxFiles - read) + 1, walked, await loadIgnoreRules(resolved), outOfBudget)
+      // 候选名单上限取 ROLLBACK_CAPTURE_LIST_LIMIT（而不是 maxFiles）：入点上限由阶段①的 slots
+      // 把关，这里若提前截断，缺口优先排序就够不到尾部文件 ⇒ 覆盖率不收敛
+      const listed = await this.listChunkFiles(resolved, payload, ROLLBACK_CAPTURE_LIST_LIMIT, walked, await loadIgnoreRules(resolved), outOfBudget)
       if (listed === null) continue
       sawChunk = true
       if (listed.truncated) payload.truncated = true
-      for (const file of listed.files) {
-        if (outOfBudget()) {
-          // 同上：中断 = 剩余路径从未进任何名单 ⇒ 必须让删除集 fail-closed
-          payload.walkIncomplete = true
-          payload.truncated = true
-          this.recordSkip(payload, 'skipped', { path: file, reason: 'budget-time' })
-          break
-        }
-        if (read >= this.maxFiles) {
-          // 文件数预算耗尽：其后每一条都如实留痕（不再 break 静默丢弃）
-          payload.truncated = true
-          this.recordSkip(payload, 'skipped', { path: file, reason: 'budget-files' })
-          continue
-        }
-        if (isInsidePath(file, this.root)) {
-          this.recordSkip(payload, 'skipped', { path: file, reason: 'self-store' })
-          continue
-        }
-        // **先 stat 判大小、再决定读不读**：单文件超限或加上它会超总量 → 跳过并如实留痕
-        // （旧实现的 `read > 0` 短路让**首个**文件完全不设上限，会被整份读进内存 —— t5-F1）
-        let stat
-        try {
-          stat = await fs.stat(file)
-        } catch (error) {
-          payload.unreadableFiles.push({ path: file, reason: errorDetail(error) })
-          continue
-        }
-        if (!stat.isFile()) {
-          this.recordSkip(payload, 'skipped', { path: file, reason: 'not-a-file' })
-          continue
-        }
-        if (stat.size > this.maxFileBytes) {
-          payload.truncated = true
-          this.recordSkip(payload, 'skipped', { path: file, reason: 'too-large' })
-          continue
-        }
-        if (payload.bytes + stat.size > this.maxBytes) {
-          payload.truncated = true
-          this.recordSkip(payload, 'skipped', { path: file, reason: 'budget-bytes' })
-          continue
-        }
-        try {
-          // 路径身份缓存：身份（dev:ino:size:mtimeNs:ctimeNs:mode）未变 ⇒ 复用已存 sha256，**不重读**
-          const identity = await this.pathIdentityOf(file)
-          const candidate = identity === null ? null : await this.lookupCachedFile(identity, file)
-          // **F-2（t12 修复）**：缓存命中也要确认对象仓里真有那个 blob —— 对象被外部清掉后
-          // 若直接复用 sha256，新点会「零对象却 canRestore=true」，预览骗人（执行才响亮失败）。
-          // 对象不在 ⇒ 当作未命中：真读 + 重写对象（缓存因此自愈）。
-          const cached = candidate === null || !(await this.objectExists(candidate.sha256)) ? null : candidate
-          const data = cached === null ? await this.readFileBytes(file) : null
-          const size = cached === null ? (data?.byteLength ?? 0) : cached.bytes
-          if (cached === null && data !== null && data.byteLength !== size) {
-            payload.truncated = true
-            this.recordSkip(payload, 'skipped', { path: file, reason: 'budget-bytes' })
-            continue
-          }
-          if (cached !== null) {
-            payload.files.push({ path: file, chunk: resolved, bytes: cached.bytes, sha256: cached.sha256, mtimeMs: stat.mtimeMs, object: cached.sha256 })
-            payload.bytes += cached.bytes
-            read += 1
-            continue
-          }
-          if (data === null) {
-            payload.unreadableFiles.push({ path: file, reason: 'read-failed' })
-            continue
-          }
-          // stat 与 read 之间文件可能变化：真读到的字节数仍必须服从总量预算（不猜、不静默）
-          if (payload.bytes + data.byteLength > this.maxBytes) {
-            payload.truncated = true
-            this.recordSkip(payload, 'skipped', { path: file, reason: 'budget-bytes' })
-            continue
-          }
-          const sha = sha256Hex(data)
-          await this.writeObjectWithHash(data, sha)
-          if (identity !== null) this.rememberCachedFile(identity, file, sha, data.byteLength)
-          payload.files.push({ path: file, chunk: resolved, bytes: data.byteLength, sha256: sha, mtimeMs: stat.mtimeMs, object: sha })
-          payload.bytes += data.byteLength
-          read += 1
-        } catch (error) {
-          payload.unreadableFiles.push({ path: file, reason: errorDetail(error) })
-        }
+      // 走查本身被打断 ⇒ 栈里还有没进去的子树（那些路径从未进任何名单）⇒ fail-closed。
+      // **区别于**下面「走查已结束、只是读到一半超时」：后者的路径全在 walked 里，
+      // 由文件末尾的覆盖自检补进证明名单（补不齐才拒删），不该整体拒删。
+      if (listed.walkAborted) {
+        payload.walkIncomplete = true
+        for (const dir of listed.unwalkedDirs) unwalked.push(dir)
       }
+      read += await this.captureChunkCandidates(resolved, listed.files, Math.max(0, this.maxFiles - read), payload, outOfBudget)
     }
+    // 精确的「没进去的子树」：有 ⇒ 删除集只在这些子树里 fail-closed；没有（老台账 / 栈被截断）
+    // ⇒ 退回全局拒删（见 planCreatedRemovals）
+    if (unwalked.length > 0) payload.unwalkedDirs = [...new Set(unwalked)].sort()
+
     // `truncated` 为真时**不能**判 chunk-not-found：那是「分块确实存在、只是没来得及走查完」
     // （时间预算 / 取消信号）—— 报成「找不到分块」会让用户以为工作区配错了。
     if (!sawChunk && payload.files.length === 0 && !payload.truncated) {
       return this.emptyTrack('workspace', capturedAt, 'chunk-not-found', chunks.join(' '))
     }
-    // **方向 B**：逐条跳过名单被记录上限截断（skippedTruncated）时，把走查过的全部路径另存成
-    // 路径索引对象 —— 「未记录」与「留点时就存在」只有在名单完整时才可区分。
-    // 只有这一种情形需要它：未截断时 files ∪ skipped 本身就是完整名单（零额外成本）。
-    // 写失败绝不改判留点成败：skippedTruncated 仍为 true ⇒ 回退侧 fail-closed 一条都不删（R-05f）。
-    if (payload.skippedTruncated) {
+    // **方向 B**：把走查过的全部路径另存成路径索引对象 —— 「未记录」与「留点时就存在」只有在
+    // 证明名单完整时才可区分。触发条件是**覆盖自检**（不是「跳过名单被截断」这一种特例）：
+    //  · 逐条跳过名单被记录上限截断（skippedTruncated）；或
+    //  · 读到一半被时间预算 / 取消打断 —— 本分块剩余文件进了 walked、却一条都没进任何名单。
+    // 覆盖完整时不必写（未截断时 files ∪ skipped 本身就是完整名单，零额外成本）。
+    // 写失败 ⇒ 证明名单补不齐 ⇒ 必须整体拒删（安全方向；R-05f）。
+    const proven = new Set<string>()
+    for (const file of payload.files) proven.add(pathKey(file.path))
+    for (const entry of payload.skipped) proven.add(pathKey(entry.path))
+    for (const entry of payload.unreadableFiles) proven.add(pathKey(entry.path))
+    const uncovered = walked.some((item) => !proven.has(pathKey(item)))
+    if (uncovered) {
       try {
         const paths = [...new Set(walked)].sort()
         const gz = gzipSync(Buffer.from(paths.join('\n'), 'utf8'))
@@ -2090,6 +2407,8 @@ export class RollbackPointEngine {
         payload.pathIndex = { object, count: paths.length, bytes: gz.byteLength }
       } catch (error) {
         this.warn('rollback path index failed: ' + errorDetail(error))
+        // 走查过、却没进名单的路径无法被证明 ⇒ 删除集整体拒绝（绝不「删一半」）
+        payload.walkIncomplete = true
       }
     }
     // 用户忽略的整目录 ⇒ 证明名单不完整（删除集整体拒绝；见 planCreatedRemovals）。
@@ -2098,6 +2417,8 @@ export class RollbackPointEngine {
     payload.ignoreIncomplete = payload.ignoredDirCount > 0
     // 路径身份缓存落盘（best-effort：写不进去只意味着下次全量读，绝不影响留点成败）
     await this.persistPathCache()
+    // 落点列表排序：并发读让入点顺序不定，契约必须是「按路径有序」（预览 / 对账 / 指纹都靠它）
+    payload.files.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))
     // 留痕列表也排序：跨分块 / 依赖 readdir 顺序时输出仍确定（测试与对账都能逐条比）
     payload.skipped.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))
     payload.excludedDirs.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))
@@ -2105,9 +2426,24 @@ export class RollbackPointEngine {
     const canonical = [...payload.files]
       .sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))
       .map((f) => [f.path, f.bytes, f.sha256])
+    payload.fileCount = payload.files.length
     const fingerprint = sha256Hex(JSON.stringify({ chunks: [...payload.chunks].sort(), files: canonical }))
+    // 自适应预算（见 ROLLBACK_MIN/MAX_CAPTURE_BUDGET_MS）：被截断 ⇒ 下次翻倍（上限）；
+    // 用得很少 ⇒ 下次减半（下限）。大仓库第一次撞上限后自动拿到更大预算，小仓库自动回落，
+    // 不会每回合白等。回退期的走查预算（rewindBudgetMs）**不参与**这套调整。
+    if (payload.truncated || payload.walkIncomplete === true) {
+      this.captureBudgetMs = Math.min(this.captureBudgetMaxMs, this.captureBudgetMs * 2)
+    } else if (this.stamp() - capturedAt < this.captureBudgetMs / 4) {
+      this.captureBudgetMs = Math.max(this.captureBudgetMinMs, Math.floor(this.captureBudgetMs / 2))
+    }
+    // 「降级（留得不完整）」只由**真的缺内容**触发：
+    //  ① truncated —— 文件数 / 总字节 / 单文件上限 / 时间预算挡下的内容；
+    //  ② unreadableDirs / unreadableFiles —— 读不出来或捕获竞态（内容不可信）。
+    // **不再用 skippedCount**：那里的条目大多是**设计内**的跳过（符号链接不跟随、文件级忽略、
+    // 自身数据区、读之前就消失），既不缺内容也无法回退 —— 旧口径让「工作区里有任何一个符号链接」
+    // 的仓库每个点都挂「回退可能不完整」，真出问题时反而被噪声淹没（真机 2026-10-15：10 个 link
+    // 跳过 ⇒ 每个点 degraded=true）。条目与计数仍逐条留痕（skippedCount / skipped 列表不变）。
     const degraded = payload.truncated
-      || payload.skippedCount > 0
       || payload.unreadableDirs.length > 0
       || payload.unreadableFiles.length > 0
     return {
@@ -2125,6 +2461,202 @@ export class RollbackPointEngine {
   /* ---------------------------------------------------------- 忽略规则 / 路径身份缓存 */
 
   /** 用户忽略规则是否命中该路径（只认「相对分块根」的斜杠路径） */
+  /**
+   * 处理一个分块的候选文件（**两阶段**）。
+   *
+   *  ① **顺序判定**（与旧的串行实现逐条一致，保证预算 / 计数 / 字节上限完全确定）：
+   *     文件数上限、时间预算、自身数据区、stat、单文件上限、总量上限、身份缓存 + 对象存在性
+   *     → 得出「当场入点（缓存命中）」还是「要真读」，该跳过的**当场**按原有 reason 逐条留痕。
+   *     stat 按**有序批**并发取（判定仍严格按顺序），并用「一次 readdir 的对象名单快照」代替
+   *     每个文件一次 fs.access —— 这两处是稳态成本的大头（真机实测各占 ~5 s / ~3.7 s）。
+   *  ② **并发读 + 哈希 + 落对象仓**：这是捕获耗时的**唯一大头**（真机 148 s / 31,702 个对象，
+   *     96% 的时间），用 captureConcurrency 个 worker 并发跑；并用**在飞字节闸门**保证
+   *     「同时在飞的内容字节 ≤ captureInFlightBytes」。**不是** maxFileBytes —— 它缺省 =
+   *     总量预算（512 MiB），拿它当闸门等于允许把整个点的预算同时驻留（0.1.74 闪退根因）。
+   *
+   * 返回本分块**真正入点**的文件数（调用方据此推进 maxFiles 预算）。
+   * 没判到 / 没读完的条目一律逐条进 skipped(budget-time)，绝不静默丢弃。
+   */
+  private async captureChunkCandidates(
+    chunk: string,
+    candidates: readonly string[],
+    slots: number,
+    payload: RollbackWorkspacePayload,
+    outOfBudget: () => boolean,
+  ): Promise<number> {
+    // 缺口优先：身份缓存里还没有的路径排前面 ⇒ 每个点都在补上次没覆盖的部分（见 orderByCoverage）
+    const ordered = await this.orderByCoverage(candidates)
+    const decided = new Array<boolean>(ordered.length).fill(false)
+    interface ReadPlan { path: string; size: number; mtimeMs: number; identity: string | null }
+    const plans: ReadPlan[] = []
+    let captured = 0
+    let newReads = 0
+    // 字节预算必须在**准入那一刻**按 stat.size 预留：真正入点发生在并发的第二阶段，
+    // 若拿 payload.bytes 当判据，同一个分块里后面的文件会全部误判成「还有额度」
+    let accounted = payload.bytes
+    // 对象名单快照：一次 readdir 顶掉「每个候选一次 fs.access」（读不到则回落逐条判断）
+    const names = await this.objectNamesSnapshot()
+
+    let cursor = 0
+    while (cursor < ordered.length) {
+      if (outOfBudget()) break // 剩余条目由收尾循环逐条记 budget-time（不预取 stat）
+      const window = ordered.slice(cursor, cursor + ROLLBACK_CAPTURE_STAT_BATCH)
+      const stats = await Promise.all(window.map((file) => this.fileStatOf(file)))
+      let broke = false
+      for (let offset = 0; offset < window.length; offset += 1) {
+        const file = window[offset] ?? ''
+        const info: RollbackFileStat = stats[offset] ?? { isFile: false, size: 0, mtimeMs: 0, identity: null, error: 'stat-missing' }
+        const index = cursor + offset
+        if (outOfBudget()) { broke = true; break }
+        decided[index] = true
+        if (isInsidePath(file, this.root)) {
+          this.recordSkip(payload, 'skipped', { path: file, reason: 'self-store' })
+          continue
+        }
+        // **先 stat 判大小、再决定读不读**：单文件超限或加上它会超总量 → 跳过并如实留痕
+        // （旧实现的 read > 0 短路让**首个**文件完全不设上限，会被整份读进内存 —— t5-F1）
+        if (info.error !== undefined) {
+          payload.unreadableFiles.push({ path: file, reason: info.error })
+          continue
+        }
+        if (!info.isFile) {
+          this.recordSkip(payload, 'skipped', { path: file, reason: 'not-a-file' })
+          continue
+        }
+        if (info.size > this.maxFileBytes) {
+          payload.truncated = true
+          this.recordSkip(payload, 'skipped', { path: file, reason: 'too-large' })
+          continue
+        }
+        // 路径身份缓存：身份（dev:ino:size:mtimeNs:ctimeNs:mode）未变 ⇒ 复用已存 sha256，**不重读**
+        const candidate = info.identity === null ? null : await this.lookupCachedFile(info.identity, file)
+        // **F-2（t12 修复）**：缓存命中也要确认对象仓里真有那个 blob —— 对象被外部清掉后
+        // 若直接复用 sha256，新点会「零对象却 canRestore=true」，预览骗人（执行才响亮失败）。
+        // 对象不在 ⇒ 当作未命中：真读 + 重写对象（缓存因此自愈）。
+        const objectPresent = candidate === null
+          ? false
+          : names !== null ? names.has(candidate.sha256) : await this.objectExists(candidate.sha256)
+        if (candidate !== null && objectPresent) {
+          // 身份未变 ⇒ 内容必然与缓存一致：零 I/O 直接入点（稳态成本与仓库大小无关的来源）。
+          // **不占读预算**：maxFiles / maxBytes 约束的是「这回合新读进来的内容」，不是「记录多少条」
+          // —— 否则大仓库每个点都只能记下前 N 条，滚回某点时会漏掉其余文件（覆盖率永远不收敛）。
+          payload.files.push({
+            path: file, chunk, bytes: candidate.bytes, sha256: candidate.sha256, mtimeMs: info.mtimeMs, object: candidate.sha256,
+          })
+          payload.bytes += candidate.bytes
+          captured += 1
+          continue
+        }
+        // 只有**要真读的新内容**才受每回合的规模预算约束（判定仍严格按顺序 ⇒ 结果确定）
+        if (newReads >= slots) {
+          payload.truncated = true
+          this.recordSkip(payload, 'skipped', { path: file, reason: 'budget-files' })
+          continue
+        }
+        if (accounted + info.size > this.maxBytes) {
+          payload.truncated = true
+          this.recordSkip(payload, 'skipped', { path: file, reason: 'budget-bytes' })
+          continue
+        }
+        accounted += info.size
+        newReads += 1
+        plans.push({ path: file, size: info.size, mtimeMs: info.mtimeMs, identity: info.identity })
+      }
+      cursor += window.length
+      if (broke) break
+    }
+
+    if (plans.length > 0) {
+      // ② 并发读 + 落对象仓。outOfBudget 一命中就**不再开新条目**（在飞的照常收尾），
+      //    未开工的条目在循环外逐条记 budget-time —— 与串行版「中断处逐条留痕」同一诚实口径。
+      const gate = new ByteGate(this.captureInFlightBytes)
+      const done: boolean[] = new Array<boolean>(plans.length).fill(false)
+      let planCursor = 0
+      let stopped = false
+      const workers = Array.from({ length: Math.min(this.captureConcurrency, plans.length) }, async () => {
+        for (;;) {
+          if (stopped) return
+          const index = planCursor
+          planCursor += 1
+          if (index >= plans.length) return
+          const item = plans[index] as ReadPlan
+          if (outOfBudget()) { stopped = true; return }
+          await gate.acquire(item.size)
+          try {
+            if (outOfBudget()) { stopped = true; return }
+            const data = await this.readFileBytes(item.path)
+            if (data.byteLength !== item.size) {
+              // stat 与 read 之间文件变了（旧口径：budget-bytes）—— 绝不按旧字节数记账
+              payload.truncated = true
+              this.recordSkip(payload, 'skipped', { path: item.path, reason: 'budget-bytes' })
+              done[index] = true
+              continue
+            }
+            // **捕获竞态**：读之前拿到的身份若在读完时已变，说明这次读到的内容未必是「留点时刻」
+            // 的内容（回合与留点并发）⇒ 不当作前像，只如实进 unreadableFiles（它本身是**证明名单**
+            // 的一员：证明「留点时存在」，因此绝不会被当成新建删掉）。
+            const after = item.identity === null ? null : await this.pathIdentityOf(item.path)
+            if (item.identity !== null && after !== item.identity) {
+              payload.unreadableFiles.push({ path: item.path, reason: 'changed-during-read' })
+              done[index] = true
+              continue
+            }
+            const sha = sha256Hex(data)
+            await this.writeObjectWithHash(data, sha)
+            if (item.identity !== null) this.rememberCachedFile(item.identity, item.path, sha, data.byteLength)
+            payload.files.push({
+              path: item.path, chunk, bytes: data.byteLength, sha256: sha, mtimeMs: item.mtimeMs, object: sha,
+            })
+            payload.bytes += data.byteLength
+            captured += 1
+            done[index] = true
+          } catch (error) {
+            payload.unreadableFiles.push({ path: item.path, reason: errorDetail(error) })
+            done[index] = true
+          } finally {
+            gate.release(item.size)
+          }
+        }
+      })
+      await Promise.all(workers)
+      for (let index = 0; index < plans.length; index += 1) {
+        if (done[index] === true) continue
+        payload.truncated = true
+        this.recordSkip(payload, 'skipped', { path: (plans[index] as ReadPlan).path, reason: 'budget-time' })
+      }
+    }
+
+    // 阶段 ① 里没判定到的（时间预算打断）同样逐条留痕 —— 覆盖自检因此仍认为名单完整
+    for (let index = 0; index < ordered.length; index += 1) {
+      if (decided[index] === true) continue
+      payload.truncated = true
+      this.recordSkip(payload, 'skipped', { path: ordered[index] ?? '', reason: 'budget-time' })
+    }
+    // 返回值 = 本分块消耗掉的**读槽位**（缓存命中不占槽位；调用方据此推进 maxFiles）
+    return newReads
+  }
+
+  /**
+   * 缺口优先排序：身份缓存里**没有**的路径排前面。
+   *
+   * 为什么：预算固定时按目录顺序走查，同一个「已覆盖且便宜」的前缀每回合都会吃掉全部预算，
+   * 尾部永远进不来（真机：34k 文件每次只覆盖 1/5，且五次都是同一批 outputs/ 前缀）。
+   * 未覆盖的排前面 ⇒ 每个点都在补上一次的缺口，覆盖率随回合**单调收敛**到 100%。
+   * 组内保持走查顺序（稳定），因此同一输入下的结果仍然确定。
+   */
+  private async orderByCoverage(candidates: readonly string[]): Promise<string[]> {
+    if (candidates.length <= 1) return [...candidates]
+    const cache = await this.loadPathCache()
+    if (cache.size === 0) return [...candidates]
+    const covered = new Set<string>()
+    for (const entry of cache.values()) covered.add(pathKey(entry.path))
+    if (covered.size === 0) return [...candidates]
+    const cold: string[] = []
+    const hot: string[] = []
+    for (const file of candidates) (covered.has(pathKey(file)) ? hot : cold).push(file)
+    return cold.length === 0 ? hot : [...cold, ...hot]
+  }
+
   private ignoredByRules(rules: IgnoreRules, target: string, isDir: boolean): boolean {
     const rel = ignoreRelativePath(rules.root, target)
     return rel === null ? false : ignoreRuleMatches(rules, rel, isDir)
@@ -2143,18 +2675,41 @@ export class RollbackPointEngine {
    * 用毫秒换算同样不行：会把「同一毫秒内的两次写」当成同一个身份。
    * 读不到身份（文件消失 / 权限 / 平台不支持 bigint stat）→ null ⇒ 回落全量真读。
    */
+  /**
+   * 一次 bigint stat 拿到阶段①需要的**全部**东西（是否文件 / 大小 / mtime / 身份）。
+   * 旧实现「fs.stat + pathIdentityOf」每文件 stat 两次，真机 34k 文件白花约 5 s。
+   */
+  private async fileStatOf(target: string): Promise<RollbackFileStat> {
+    try {
+      const stat = await fs.stat(target, { bigint: true })
+      const isFile = stat.isFile()
+      return {
+        isFile,
+        size: Number(stat.size),
+        mtimeMs: Number(stat.mtimeMs),
+        identity: isFile ? fileIdentityOf(stat) : null,
+      }
+    } catch (error) {
+      return { isFile: false, size: 0, mtimeMs: 0, identity: null, error: errorDetail(error) }
+    }
+  }
+
+  /** 对象名单快照（每个捕获回合一次 readdir）；读不到则返回 null ⇒ 调用方回落逐条判断 */
+  private async objectNamesSnapshot(): Promise<Set<string> | null> {
+    if (this.captureObjectNames !== null) return this.captureObjectNames
+    try {
+      this.captureObjectNames = new Set(await fs.readdir(this.objectsDir))
+    } catch {
+      this.captureObjectNames = null
+    }
+    return this.captureObjectNames
+  }
+
   private async pathIdentityOf(target: string): Promise<string | null> {
     try {
       const stat = await fs.stat(target, { bigint: true })
       if (!stat.isFile()) return null
-      return [
-        String(stat.dev),
-        String(stat.ino),
-        String(stat.size),
-        String(stat.mtimeNs),
-        String(stat.ctimeNs),
-        String(stat.mode & 0o777n),
-      ].join(':')
+      return fileIdentityOf(stat)
     } catch {
       return null
     }
@@ -2193,6 +2748,25 @@ export class RollbackPointEngine {
   }
 
   /** 缓存命中：身份键存在、且路径逐字相同（身份被复用也绝不认）。 */
+  /**
+   * 「这条记录的当前内容**仍然是它**吗」的身份快路径 —— **预览与执行共用同一条判据**
+   * （否则「预览说会改的 = 实际会改的」这条不变式会被打破）。
+   *
+   * 判据：路径身份（dev:ino:size:mtimeNs:ctimeNs:mode）命中**身份缓存**，且缓存里的 sha/bytes 与记录一致。
+   * 身份未变 ⇒ 内容未变：缓存里的 sha 就是**这份内容**在留点那一次真读出来的哈希（身份含 size/mtimeNs/
+   * ctimeNs/ino/dev/mode，改内容必动 mtime/ctime，Windows 上 user 代码改不了 ctime）。
+   * 任何一环拿不到（读不到身份 / 缓存没有该身份 / sha 或 bytes 不同）⇒ false，调用方回落「真读 + 哈希」。
+   *
+   * 为什么必须有它：大仓库一次预览/回退要判 3 万+ 条目，逐个真读等于把整个工作区读两遍
+   * （真机 34k 文件 / 609 MiB：预览 14.2 s 里 13 s 全在这，回退 60 s+ 同理）。**记录的指纹被篡改**
+   * 时本判据必然不成立（缓存的 sha 是真算出来的）⇒ 仍走真读 + 哈希的旧路径，护栏不退化。
+   */
+  private async unchangedByIdentity(file: RollbackWorkspaceFile, identity: string | null): Promise<boolean> {
+    if (identity === null) return false
+    const cached = await this.lookupCachedFile(identity, file.path)
+    return cached !== null && cached.sha256 === file.sha256 && cached.bytes === file.bytes
+  }
+
   private async lookupCachedFile(identity: string, target: string): Promise<{ sha256: string; bytes: number } | null> {
     const cache = await this.loadPathCache()
     const hit = cache.get(identity)
@@ -2444,6 +3018,71 @@ export class RollbackPointEngine {
    * 诚实的边界：检测与写入之间仍有极小窗口，无跨进程锁时无法彻底消除 —— 这里保证的是
    * 「不静默覆盖 + 尽量合并」，不是原子性。
    */
+  /**
+   * 把工作区载荷改写成**增量视图**（相对最近一个同分块的点）——清单增量化，省的是磁盘，不是语义。
+   *
+   * 判据与安全边界（逐条）：
+   *  · 基准 = 清单里最近一个 `workspace.payload` 非空、**分块完全相同**的点（只试最近几个，代价有界）；
+   *  · 增量 = 「相对基准新增 / 改写的条目」+「基准里不再存在的路径」，条目**逐字比较**（同形绝对路径）；
+   *  · 只有增量明显更小（< 全量的 60%）才用；否则原样全量落盘；
+   *  · 读路径由 ledger 物化（`resolvePayload`）⇒ 预览 / 回退 / 回收看到的永远是完整清单；
+   *  · 基准读不出来 / 分块对不上 / 任何异常 ⇒ 原样全量（绝不因为省字节而让点不可用）；
+   *  · 基准载荷的保活由 ledger 的 `payloadChain` 负责（淘汰时不会把基准删掉）。
+   */
+  private async storagePlanFor(
+    record: RollbackPointRecord,
+    entries: readonly RollbackLedgerManifestEntry[],
+  ): Promise<{ record: RollbackPointRecord; reuse: { hash: string; bytes: number; chain: string[] } | null }> {
+    const full = { record, reuse: null }
+    const payload = record.workspace.payload
+    if (payload === null || record.workspace.ok !== true || payload.files.length === 0) return full
+    if (payload.delta !== undefined) return full
+    // 基准 = **本进程上一次成功留点**的内存摘要（绝不读别人的载荷/记录文件：L-08 / issue #89）。
+    // 没有摘要（进程刚起 / 分块变了）⇒ 这一次落**全量锚点**，随后由摘要继续链下去。
+    const base = this.deltaBase
+    if (base !== null && sameChunks(base.chunks, payload.chunks)) {
+      const diff = payloadDiffAgainstDigest(payload, base.entries)
+      if (diff.added.length === 0 && diff.removed.length === 0) {
+        // 工作区与该点**逐条相同** ⇒ 直接复用它的载荷文件（零额外字节、链不增长）
+        const entry = entries.find((candidate) => candidate.workspace.payload === base.hash)
+        if (entry !== undefined && (await this.ledger.hasPayload(base.hash))) {
+          return { record, reuse: { hash: base.hash, bytes: entry.workspace.payloadBytes, chain: [...base.chain] } }
+        }
+      } else if (base.chain.length < ROLLBACK_DELTA_CHAIN_LIMIT) {
+        const delta = buildPayloadDelta(payload, base.hash, base.chain, diff)
+        if (delta !== null) {
+          return {
+            record: { ...record, workspace: { ...record.workspace, payload: compactPayloadForStorage(delta) } },
+            reuse: null,
+          }
+        }
+      }
+    }
+    // 没有可用基准 / 分块不同 / 增量不划算 ⇒ 全量落盘（仍省掉冗余的 object 字段）
+    return {
+      record: { ...record, workspace: { ...record.workspace, payload: compactPayloadForStorage(payload) } },
+      reuse: null,
+    }
+  }
+
+  /** 记下这份点作为下一次留点的增量基准（内存摘要，见 {@link deltaBase}） */
+  private rememberDeltaBase(record: RollbackPointRecord, prepared: RollbackLedgerPrepared): void {
+    const payload = record.workspace.payload
+    const hash = prepared.payloadHash
+    if (payload === null || hash === null) {
+      this.deltaBase = null
+      return
+    }
+    const entries = new Map<string, string>()
+    for (const file of payload.files) entries.set(file.path, digestKeyOf(file))
+    this.deltaBase = {
+      hash,
+      chain: prepared.entry.workspace.payloadChain ?? [hash],
+      chunks: [...payload.chunks],
+      entries,
+    }
+  }
+
   private async appendRecord(record: RollbackPointRecord): Promise<{ ok: boolean; detail?: string }> {
     for (let attempt = 0; attempt < 3; attempt += 1) {
       const result = await this.appendRecordOnce(record)
@@ -2474,7 +3113,10 @@ export class RollbackPointEngine {
           return { ok: false, detail: 'ledger unreadable: ' + manifest.error }
         }
       }
-      const prepared = this.ledger.prepareRecord(record)
+      // 清单增量化：能省就把这份载荷改写成「相对最近一个同分块载荷的增量」（读路径由 ledger 物化回来）。
+      // 失败 / 不划算 / 没有可用基准一律**原样返回** —— 增量只影响磁盘占用，绝不参与正确性判断。
+      const storage = await this.storagePlanFor(record, manifest.entries)
+      const prepared = this.ledger.prepareRecord(storage.record, storage.reuse ?? undefined)
       const merged = [prepared.entry, ...manifest.entries.filter((r) => r.id !== record.id)]
       const pruned = this.selectPruneEntries(merged)
       // 本次新增字节：记录文件 + **首次落盘**的载荷（同一工作区态已存在 ⇒ 零额外字节）
@@ -2503,6 +3145,8 @@ export class RollbackPointEngine {
         await this.ledger.prunePayloads(manifest.entries)
         return { ok: false, detail: errorDetail(error) }
       }
+      // 记下「这次留点」作为下一次的增量基准（只在真正写成功后；失败不更新 ⇒ 链只跨成功落盘的点）
+      this.rememberDeltaBase(record, prepared)
       const keptIds = new Set(kept.map((entry) => entry.id))
       const dropped = merged.filter((entry) => !keptIds.has(entry.id)).map((entry) => entry.id)
       await this.ledger.deleteRecords(dropped)
@@ -2791,6 +3435,26 @@ export class RollbackPointEngine {
 
   /* -------------------------------------------------------------- 预览 */
 
+  /**
+   * 预览的**单条只读判定**（阶段 A，可并发跑）：一次 bigint lstat + 身份快路径。
+   * `unchanged = true` 表示「已证明与记录一致」（身份命中身份缓存且 sha/bytes 相同）⇒ 调用方直接跳过。
+   */
+  private async previewScan(file: RollbackWorkspaceFile): Promise<PreviewScanResult> {
+    try {
+      // **lstat，不是 stat**：写入侧用 `symlink:'reject'`（lstat 是链接即抛），预览若跟随链接就会
+      // 说「会创建 / 会覆盖」，执行却整段失败 —— 两侧必须是同一个口径。链接一律按「不可写」报。
+      const stat = await fs.lstat(file.path, { bigint: true })
+      if (stat.isSymbolicLink()) return { kind: 'unavailable' }
+      const size = Number(stat.size)
+      const regular = stat.isFile()
+      const unchanged = regular && size === file.bytes
+        && (await this.unchangedByIdentity(file, regular ? fileIdentityOf(stat) : null))
+      return { kind: 'ok', size, regular, unchanged }
+    } catch (error) {
+      return classifyPreviewStatFailure(error) === 'missing' ? { kind: 'missing' } : { kind: 'unavailable' }
+    }
+  }
+
   private trackWarnings(record: RollbackPointRecord): RollbackGuidance[] {
     const out: RollbackGuidance[] = []
     for (const track of [record.workspace, record.session]) {
@@ -2837,26 +3501,41 @@ export class RollbackPointEngine {
     for (const entry of payload.excludedDirs) proof.add(pathKey(entry.path))
     for (const entry of payload.ignoredDirs ?? []) proof.add(pathKey(entry.path))
     let refused: CreatedRemovalPlan['refused'] = null
-    if (payload.skippedTruncated) {
-      // 逐条跳过名单被记录上限截断 ⇒ 必须有路径索引，否则「未记录」≠「留点之后新建」
-      const index = payload.pathIndex ?? null
-      if (index === null) refused = 'capture-incomplete'
-      else {
-        try {
-          for (const item of await this.readPathIndex(index)) proof.add(pathKey(item))
-        } catch (error) {
-          this.warn('rollback path index unreadable: ' + errorDetail(error))
-          refused = 'capture-incomplete'
-        }
+    // 路径索引**存在即并入**证明名单：写入条件已从「跳过名单被截断」推广为「覆盖自检不完整」
+    // （读到一半被预算打断也会写索引）—— 这里只看 skippedTruncated 会漏读索引 ⇒ 把老文件当新建删掉。
+    const index = payload.pathIndex ?? null
+    if (index !== null) {
+      try {
+        for (const item of await this.readPathIndex(index)) proof.add(pathKey(item))
+      } catch (error) {
+        this.warn('rollback path index unreadable: ' + errorDetail(error))
+        refused = 'capture-incomplete'
       }
+    } else if (payload.skippedTruncated) {
+      // 逐条跳过名单被记录上限截断、又没有索引 ⇒ 「未记录」≠「留点之后新建」，证明不了
+      refused = 'capture-incomplete'
+    }
+    // —— 分子树拒删范围 ——
+    // 忽略目录 / 读不出的目录 / 走查没进去的子树：这三类的共同点是「其下内容在留点时刻未知」，
+    // 但它们**各自只影响自己那棵子树**。旧口径一律全局拒删，代价是「忽略一个 outputs/ 就让整个
+    // 工作区的新建文件一条都不删」；现在只拒这几棵子树，范围之外由证明名单照常判。
+    // 走查中断且拿不到精确子树列表（老台账 / 栈被截断）时才退回全局。
+    // 范围**说得清**才敢分子树拒删：忽略目录的逐条列表可能被记录上限截断（ignoredDirCount 是恒增
+    // 计数），走查中断也可能拿不到子树列表（老台账 / 栈太深）。任一「说不清」⇒ 退回全局拒删。
+    const ignoredKnown = (payload.ignoredDirs ?? []).length >= (payload.ignoredDirCount ?? 0)
+    const unwalkedKnown = (payload.unwalkedDirs ?? []).length > 0 || payload.walkIncomplete !== true
+    const scopesKnown = ignoredKnown && unwalkedKnown
+    const refusalScopes: string[] = scopesKnown
+      ? [
+        ...(payload.ignoredDirs ?? []).map((entry) => entry.path),
+        ...payload.unreadableDirs,
+        ...(payload.unwalkedDirs ?? []),
+      ]
+      : []
+    if (refused === null && !scopesKnown) {
+      // 证明名单不完整、且**说不出**不完整的确切范围 ⇒ 整个工作区一条都不删（安全方向）
+      refused = 'capture-incomplete'
     }
-    // 读不出的目录：目录内容在留点时刻**未知**（路径索引只含走查过的路径）⇒ 同样证明不了
-    if (refused === null && payload.unreadableDirs.length > 0) refused = 'capture-incomplete'
-    // 用户忽略的整目录 ⇒ 其下内容在留点时刻未知 ⇒ 证明名单不完整（fail-closed）
-    if (refused === null && payload.ignoreIncomplete === true) refused = 'capture-incomplete'
-    // 走查被时间预算 / 取消信号中断 ⇒ 剩余子树**一条都没进任何名单** ⇒ 同样证明不了
-    // （这是 `truncated` 之外的第四种「名单不完整」：其余三种截断都会逐条留痕）
-    if (refused === null && payload.walkIncomplete === true) refused = 'capture-incomplete'
     const chunks = payload.chunks
     // 走查上限 = 全树：候选的**准入**由证明名单负责，条数上限不再是安全阀
     //（旧上限 maxFiles*4 会在巨型工作区里静默漏掉真正的新建文件 —— 那是「删一半」，不是 fail-closed）
@@ -2864,7 +3543,7 @@ export class RollbackPointEngine {
     // **时间预算**：回退期的走查同样不能无限跑（分块 = 会话 cwd，家目录 / 大仓库会走很久，
     // 而捕获侧早就有 30 s 预算 —— 只修一侧等于把 OOM 形态从留点搬到了回退）。
     // 中断只会让候选**变少**（安全方向），但必须如实置 truncated（绝不静默漏删、也不谎报完整）。
-    const deadline = this.stamp() + this.captureBudgetMs
+    const deadline = this.stamp() + this.rewindBudgetMs
     const outOfBudget = (): boolean => this.stamp() >= deadline
     const candidates: string[] = []
     let truncated = false
@@ -2880,13 +3559,20 @@ export class RollbackPointEngine {
         candidates.push(file)
       }
     }
-    const refusalWarnings = this.createdRefusalWarnings(payload)
+    // 警告只在**全局拒绝**时给：分子树拒绝由 createdSkipped 逐条说明（那句「本次不删除任何
+    // 『留点后新建』的路径」在分子树拒绝下是假话 —— 文案诚实要求按真实范围分派）。
+    const refusalWarnings = refused === null ? [] : this.createdRefusalWarnings(payload)
     const all: string[] = []
     const paths: string[] = []
     const skipped: string[] = []
     for (const file of candidates) {
       all.push(file)
       // 拒删的也留在「未记录」清单里（如实报告），但绝不进删除集合
+      // 分子树拒删（忽略目录 / 读不出的目录 / 没走查到的子树）：只拒这几棵子树里的候选
+      if (refusalScopes.length > 0 && refusalScopes.some((dir) => isInsidePath(file, dir))) {
+        skipped.push(file)
+        continue
+      }
       if (this.createdRemovalRefusal(file, chunks) !== null) { skipped.push(file); continue }
       let stat
       try {
@@ -3037,22 +3723,28 @@ export class RollbackPointEngine {
       // 单张预览共享的比对预算（字节 + 步数）；只有真的会被改动的条目才消耗它
       const diffBudget = { bytes: 0, work: 0 }
       // T10：stat 的三种结局分开表达 —— 「不存在（ENOENT）」与「存在性未知（其它 errno）」绝不混为一谈
-      type PreviewStatOutcome =
-        | { kind: 'ok'; size: number; regular: boolean }
-        | { kind: 'missing' }
-        | { kind: 'unavailable' }
-      for (const file of wsPayload.files) {
-        let outcome: PreviewStatOutcome
-        try {
-          // **lstat，不是 stat**：写入侧用 `symlink:'reject'`（lstat 是链接即抛），预览若跟随链接就会
-          // 说「会创建 / 会覆盖」，执行却整段失败 —— 两侧必须是同一个口径。链接一律按「不可写」报。
-          const stat = await fs.lstat(file.path)
-          outcome = stat.isSymbolicLink()
-            ? { kind: 'unavailable' }
-            : { kind: 'ok', size: stat.size, regular: stat.isFile() }
-        } catch (error) {
-          outcome = classifyPreviewStatFailure(error) === 'missing' ? { kind: 'missing' } : { kind: 'unavailable' }
-        }
+      const previewFiles = wsPayload.files
+      // 阶段 A（**并发**）：逐条一次 bigint lstat + 身份快路径。大仓库这里是预览的大头：
+      // 真机 34k 条实测 —— 串行 lstat ≈ 6 s、串行真读 ≈ 13 s；并发后降到亚秒级 + 只读真正变了的那几条。
+      const scans = new Array<PreviewScanResult>(previewFiles.length)
+      let scanCursor = 0
+      const scanWorkers = Array.from(
+        { length: Math.min(this.captureConcurrency, Math.max(1, previewFiles.length)) },
+        async () => {
+          for (;;) {
+            const index = scanCursor
+            scanCursor += 1
+            if (index >= previewFiles.length) return
+            scans[index] = await this.previewScan(previewFiles[index] as RollbackWorkspaceFile)
+          }
+        },
+      )
+      await Promise.all(scanWorkers)
+      // 阶段 B（**顺序**）：只对「变了 / 没了 / 不可写」的条目按记录顺序装配 —— 列表顺序与行级 diff 的
+      // 共享预算因此仍**完全确定**（与并发前逐条一致，测试可逐字对账）。
+      for (let index = 0; index < previewFiles.length; index += 1) {
+        const file = previewFiles[index] as RollbackWorkspaceFile
+        const outcome: PreviewScanResult = scans[index] ?? { kind: 'unavailable' }
         if (outcome.kind === 'missing') {
           // **只有 ENOENT** 才算「当前确实不存在」⇒ 回退会重新创建它
           missing += 1
@@ -3070,6 +3762,8 @@ export class RollbackPointEngine {
           changedFiles.push({ path: file.path, status: 'overwrite', ...previewCountsUnavailable() })
           continue
         }
+        // 身份快路径已证明「与记录一致」⇒ 一个字段都不改（内容一致的文件不列进列表）
+        if (outcome.unchanged) continue
         const { size, regular } = outcome
         const sizeMatches = regular && size === file.bytes
         const withinCaps = file.bytes <= this.previewDiffMaxFileBytes && size <= this.previewDiffMaxFileBytes
@@ -3078,7 +3772,7 @@ export class RollbackPointEngine {
         // ② 大小不一致时也得读一次才能给行级统计（超限的大文件不白读）。
         if (regular && (sizeMatches || withinCaps)) {
           try {
-            current = await fs.readFile(file.path)
+            current = await this.readFileBytes(file.path)
           } catch {
             current = null
           }
@@ -3265,7 +3959,7 @@ export class RollbackPointEngine {
     const result = diffLines(
       current === null ? '' : DIFF_TEXT_DECODER.decode(current),
       DIFF_TEXT_DECODER.decode(snapshot),
-      { context: ROLLBACK_FILE_DIFF_LIMITS.context },
+      { context: ROLLBACK_FILE_DIFF_LIMITS.context, maxD: ROLLBACK_FILE_DIFF_LIMITS.maxD },
     )
     return {
       ...view,
@@ -3470,6 +4164,8 @@ export class RollbackPointEngine {
     const detail: string[] = []
     const writable: { file: RollbackWorkspaceFile; bytes: Uint8Array }[] = []
     let failed = 0
+    // 「已与记录一致」的条目数（身份快路径证明）—— 后面「0 变更」的文案与统计要用
+    let unchanged = 0
     for (const file of payload.files) {
       // 门：记录里的路径必须落在记录里的分块内（记录不可成为写原语）
       const inChunk = payload.chunks.some((chunk) => path.isAbsolute(chunk) && isInsidePath(file.path, chunk))
@@ -3478,6 +4174,17 @@ export class RollbackPointEngine {
         pushDetail(detail, 'invalid-path ' + file.path)
         continue
       }
+      // **身份快路径**：身份（dev:ino:size:mtimeNs:ctimeNs:mode）命中身份缓存、且缓存的 sha/bytes 与记录
+      // 一致 ⇒ 这个文件当前就是留点时刻的内容，**它根本不会被写** ⇒ 连对象都不必读。
+      // 大仓库实测：旧口径下阶段 1 会把 34k 个对象（609 MiB）全读一遍 + 哈希一遍（回退 60 s+ 全在这）。
+      // 语义变化（有意、且更准）：阶段 1 的对象校验只对**真要写**的条目做 —— 一个用不到的对象坏掉，
+      // 不该中止整次回退；真要用它时（该文件确实变了）照样会 `object-missing` / `object-hash-mismatch` 硬失败。
+      const info = await this.fileStatOf(file.path)
+      if (info.error === undefined && info.isFile && info.size === file.bytes
+        && (await this.unchangedByIdentity(file, info.identity))) {
+        unchanged += 1
+        continue
+      }
       try {
         const bytes = await this.readObject(file.object)
         if (sha256Hex(bytes) !== file.sha256) {
@@ -3528,7 +4235,6 @@ export class RollbackPointEngine {
     // E1：内容已与快照一致的条目**不再写** —— 「0 变更」就要是真的 0 次写入
     // （否则工作区已与该点一致时也会重写全部文件，白耗 I/O 并抖动 mtime）。
     const needed: { file: RollbackWorkspaceFile; bytes: Uint8Array }[] = []
-    let unchanged = 0
     for (const item of writable) {
       let identical = false
       try {
@@ -3574,7 +4280,7 @@ export class RollbackPointEngine {
       let bytes: Uint8Array | null = null
       let unreadable: string | null = null
       try {
-        bytes = await fs.readFile(item.file.path)
+        bytes = await this.readFileBytes(item.file.path)
       } catch (error) {
         // **只认 ENOENT = 当时确实不存在**。其它 errno（EACCES / EMFILE / EBUSY…）是
         // 「读不出来」而不是「没有」—— 折成 null 会让回滚阶段把这个**存在**的文件删掉
@@ -3621,7 +4327,7 @@ export class RollbackPointEngine {
     if (failed === 0) {
       for (const item of needed) {
         try {
-          const current = await fs.readFile(item.file.path)
+          const current = await this.readFileBytes(item.file.path)
           if (sha256Hex(current) !== item.file.sha256) mismatched.push(item.file.path)
         } catch {
           mismatched.push(item.file.path)