dsh-config-manager 0.1.73 → 0.1.76

package/lib/core/rollback-point.js

@@ -76,6 +76,10 @@ import { isSessionLogName } from '../utils/session-log.js';
 import { decodeZstdFrame, scanZstdFrames, zstdAvailable, ZSTD_MAGIC } from '../utils/zstd-frame.js';
 import { cleanupOrphanTempFiles, entrySummaryOf, ROLLBACK_DEFAULT_LEDGER_BYTES, ROLLBACK_UNDO_DIR_NAME, RollbackLedger, } from './rollback-ledger.js';
 /* ------------------------------------------------------------------ 常量 */
+/** 增量链的最大长度：到顶就落一个**全量锚点**（重建最多读 1 份全量 + 几份小增量） */
+const ROLLBACK_DELTA_CHAIN_LIMIT = 8;
+/** 增量视图只有在小于全量的这个比例时才采用（否则直接全量，简单可靠） */
+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';
@@ -177,6 +181,45 @@ 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;
+/** 走查中断时逐条记下的「没进去的子树」上限；超出即放弃精确范围，退回全局 fail-closed */
+export const ROLLBACK_UNWALKED_DIRS_LIMIT = 200;
 /**
  * 「删除回退点之后新建的路径」的**整套上限**（用户 2026-10-11 定案 A）。
  * 超过就整套拒绝（fail-closed），绝不删一半 —— 半套删除既没有可解释的状态，也无法整体回滚。
@@ -208,6 +251,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,
 };
 /** 恢复顺序（工作区在前；工作区失败即中止后面的会话段） */
 export const ROLLBACK_REWIND_ORDER = ['workspace', 'session'];
@@ -231,6 +282,24 @@ export const ROLLBACK_PATH_CACHE_NAME = 'path-cache.json';
 function win32Fold(value) {
     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) {
+    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, parent) {
     const c = win32Fold(path.resolve(child));
@@ -241,6 +310,82 @@ export function isInsidePath(child, parent) {
 function pathKey(value) {
     return win32Fold(path.resolve(value));
 }
+/** 两个分块列表是否逐个相同（增量基准必须作用于同一批分块） */
+function sameChunks(a, b) {
+    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) {
+    const strip = (list) => {
+        if (!Array.isArray(list))
+            return list;
+        return list.map((file) => {
+            const copy = { ...file };
+            delete copy['object'];
+            return copy;
+        });
+    };
+    const delta = payload.delta;
+    return {
+        ...payload,
+        files: strip(payload.files),
+        ...(delta === undefined
+            ? {}
+            : { delta: { ...delta, ...(delta.added === undefined ? {} : { added: strip(delta.added) }) } }),
+    };
+}
+/**
+ * 构造「相对基准的增量视图」；不划算（≥ 全量 × {@link ROLLBACK_DELTA_MAX_RATIO}）时返回 null。
+ *
+ * 条目**逐字比较**：路径、sha、字节数、mtimeMs、所属分块任一不同 ⇒ 进 `added`；基准里不再存在的路径进 `removed`。
+ * 重建 = 基准 − removed，再用 added 覆盖/追加，最后按路径排序（与全量捕获同序）。
+ */
+/** 基准摘要键：内容 + 字节数 + 所属分块（`mtimeMs` 不参与 —— 只被触摸、内容没变的文件不必进增量） */
+function digestKeyOf(file) {
+    return String(file.sha256) + ':' + String(file.bytes) + ':' + String(file.chunk);
+}
+/** 相对**内存基准摘要**的条目差异（新增/改写 / 不再存在）；路径逐字比较，不读任何文件 */
+function payloadDiffAgainstDigest(payload, baseEntries) {
+    const added = [];
+    const nextPaths = new Set();
+    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 = [];
+    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, baseHash, baseChain, diff) {
+    if (baseHash === '')
+        return null;
+    const delta = {
+        ...payload,
+        // **故意不是数组**：不认识 `delta` 的旧读取器会在形状校验这一步**拒绝这个点**（fail-closed），
+        // 而不是把「增量那几条」当成完整清单去规划删除 —— 那会把留点时存在的文件全判成新建、全部删掉。
+        files: null,
+        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) {
     if (error instanceof Error) {
         const code = error.code;
@@ -439,6 +584,17 @@ export function resolveTurnBoundary(events, turnSeq) {
     }
     return { ok: true, boundarySeq: boundary.boundarySeq, endSeq: boundary.endSeq };
 }
+/**
+ * 记录在案的文件条目数：优先用载荷自带的 `fileCount`（增量视图下 `files` 可能只是子集），
+ * 老载荷没有该字段才回落到 `files.length`。
+ */
+export function workspaceFileCount(payload) {
+    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) {
     const workspace = record.workspace.payload;
     const session = record.session.payload;
@@ -469,7 +625,7 @@ export function summarizeRollbackPoint(record) {
         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, session === null ? 0 : 1, session?.bytes ?? 0, session?.cursorBytes ?? null, session !== null && session.sessionId !== null && session.boundarySeq !== null, 0, false),
         ],
     };
@@ -600,6 +756,49 @@ 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) {
+    return [
+        String(stat.dev),
+        String(stat.ino),
+        String(stat.size),
+        String(stat.mtimeNs),
+        String(stat.ctimeNs),
+        String(stat.mode & 511n),
+    ].join(':');
+}
+class ByteGate {
+    used = 0;
+    waiters = [];
+    limit;
+    constructor(limit) {
+        this.limit = limit;
+    }
+    async acquire(bytes) {
+        const need = Math.max(0, Math.min(bytes, this.limit));
+        while (this.used + need > this.limit && this.used > 0) {
+            await new Promise((resolve) => { this.waiters.push(resolve); });
+        }
+        this.used += need;
+    }
+    release(bytes) {
+        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 {
     dataDir;
     homeDir;
@@ -611,6 +810,7 @@ export class RollbackPointEngine {
     maxFiles;
     maxBytes;
     maxFileBytes;
+    captureInFlightBytes;
     maxSkippedEntries;
     sessionMaxBytes;
     sessionQuiescentMs;
@@ -640,14 +840,41 @@ export class RollbackPointEngine {
     forkLinksAt = 0;
     forkLinksComplete = true;
     /** 会话日志头缓存（mtime + size 失效；只服务 fork 链扫描） */
+    /**
+     * **本进程**最近一次成功留点的工作区摘要（清单增量化的基准）。
+     *
+     * 为什么是内存而不是读盘：一次留点只准读清单（L-08 / issue #89）—— 读上一份 12 MB 载荷去算差异
+     * 正是那条被消灭的路。内存量 ≈ 每文件一个 `sha:bytes:chunk` 串（3.4 万文件约几 MB），
+     * 与已有的身份缓存（`pathCache`）同量级；进程重启后第一次留点落全量锚点，随后继续链。
+     */
+    deltaBase = null;
     forkHeaderCache = new Map();
     /** 继承判据用的台账快照（TTL 缓存；只缓存**清单条目**，绝不缓存完整记录） */
     ledgerSnapshotCache = null;
     /** 台账存储层（v3：清单 + 单条记录 + 内容寻址载荷；issue #89） */
     ledger;
     ledgerBytesBudget;
-    /** 工作区捕获的挂钟时间预算（毫秒；见 ROLLBACK_DEFAULT_CAPTURE_BUDGET_MS） */
+    /**
+     * 工作区捕获的挂钟时间预算（毫秒；见 ROLLBACK_DEFAULT_CAPTURE_BUDGET_MS）。**可变**：
+     * 每次留点后按「是否被截断 / 用掉多少」自适应（见 ROLLBACK_MIN/MAX_CAPTURE_BUDGET_MS）。
+     */
     captureBudgetMs;
+    /** 自适应区间下界 / 上界（构造期定死，运行期只调 captureBudgetMs） */
+    captureBudgetMinMs;
+    captureBudgetMaxMs;
+    /** 回退期走查的时间预算（与捕获预算分开：自适应不该顺手拉长回退期的走查） */
+    rewindBudgetMs;
+    /** 捕获期读 + 写并发上限 */
+    captureConcurrency;
+    /** 对象仓目录已确认存在（省掉每个对象一次 mkdir） */
+    objectsDirReady = false;
+    /**
+     * 本回合对象名单快照（一次 readdir 顶掉「每个候选一次 fs.access」；真机 34k 次 access ≈ 3.7 s）。
+     * null = 读不到名单（首次还没建目录/异常）⇒ 回落逐条 objectExists。
+     * 只保证「写进去的立刻可见」：捕获期间被**并发删除**的对象可能仍被判为存在 —— 那一路由
+     * 读取侧（readObject + 哈希校验）响亮失败，不会静默给出错误的 before 内容。
+     */
+    captureObjectNames = null;
     /**
      * 启动期一次性初始化（流式迁移 v2 -> v3 + 孤儿 tmp 清理）的惰性单飞。
      * 为什么惰取而不是构造时同步跑：构造发生在每个请求路径上，同步扫盘/迁移会把请求卡死；
@@ -668,6 +895,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;
@@ -687,6 +918,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,
@@ -858,20 +1093,51 @@ export class RollbackPointEngine {
         }
     }
     /* -------------------------------------------------------------- 对象仓 */
+    /** 对象仓目录只 mkdir 一次（每个对象各 mkdir 一次是纯白花的 syscall） */
+    async ensureObjectsDir() {
+        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 的代价。
+     */
     async writeObjectWithHash(bytes, sha) {
         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;
+        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.code;
+                if (code === 'EEXIST')
+                    return sha; // 已有同内容对象（去重 / 并发竞写）
+                // 杀软 / 句柄瞬时占用：有界退避重试（与 atomic-write 的判据同族）
+                if (OBJECT_WRITE_RETRY_CODES.includes(code) && attempt < 3) {
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    delay *= 2;
+                    continue;
+                }
+                throw error;
+            }
         }
-        catch { /* 不存在才写（内容寻址天然去重） */ }
-        await atomicWriteFile(target, bytes);
-        return sha;
     }
     /** 对象仓里是否真有这个 blob（缓存命中时校验；任何异常一律按「没有」处理） */
     async objectExists(sha) {
@@ -980,6 +1246,10 @@ export class RollbackPointEngine {
     /**
      * 列出一个显式分块内的候选文件（不跟随符号链接 / junction；跳过与读不到都留痕）。
      * 返回 null = 该分块本身不可用（不存在 / 是链接 / 非常规文件），细节已写进 sink。
+     *
+     * `truncated` 与 `walkAborted` 是**两件事**：前者只说「本次列表不完整」（文件数上限 / 提交上限），
+     * 后者说「走查被预算或取消打断，栈里还有没进去的子树」—— 只有后者才意味着那些路径
+     * **一条都没进任何名单**，调用方必须据此让删除集 fail-closed。
      */
     async listChunkFiles(chunk, sink, limit, 
     /**
@@ -989,9 +1259,15 @@ export class RollbackPointEngine {
     collect, ignore, 
     /**
      * 停止判据（捕获期传时间/取消预算；回退期的走查不传）—— 返回 true 立即停止遍历，
-     * 已走查的部分照常返回并置 truncated（证明名单因此不完整 ⇒ 删除集 fail-closed）。
+     * 已走查的部分照常返回并置 truncated + walkAborted（栈里剩余的子树从未进门 ⇒ 由调用方据此 fail-closed；
+     * 回退期不传它，故 walkAborted 恒 false）。
      */
     shouldStop) {
+        // 分块根本身就是 `.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);
@@ -1005,17 +1281,23 @@ export class RollbackPointEngine {
             return null;
         }
         if (stat.isFile())
-            return { files: [chunk], truncated: false };
+            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 = [];
         let truncated = false;
+        // 走查**被预算 / 取消打断**：栈里还压着没进去的子树 —— 那些路径一条都没进任何名单
+        let walkAborted = false;
+        // 中断时把**还没进去的子树**如实带出去 ⇒ 调用方可以只对这几棵子树 fail-closed（精确范围）
+        let unwalkedDirs = [];
         const stack = [{ dir: chunk, depth: 0 }];
         while (stack.length > 0) {
             if (shouldStop?.() === true) {
                 truncated = true;
+                walkAborted = true;
+                unwalkedDirs = stack.length > ROLLBACK_UNWALKED_DIRS_LIMIT ? [] : stack.map((item) => item.dir);
                 break;
             }
             const item = stack.pop();
@@ -1035,6 +1317,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;
@@ -1082,7 +1371,7 @@ export class RollbackPointEngine {
             }
         }
         out.sort();
-        return { files: out, truncated };
+        return { files: out, truncated, walkAborted, unwalkedDirs };
     }
     async captureWorkspace(chunks, signal) {
         const capturedAt = this.stamp();
@@ -1093,6 +1382,8 @@ export class RollbackPointEngine {
         // 自动落成 capture-truncated，UI 走既有的 degraded 提示路径（零新增文案）。
         const deadline = capturedAt + this.captureBudgetMs;
         const outOfBudget = () => signal?.aborted === true || this.stamp() >= deadline;
+        // 对象名单快照按回合重建（一次 readdir 换掉每个候选一次 fs.access）
+        this.captureObjectNames = null;
         const payload = {
             chunks: [...chunks],
             files: [],
@@ -1112,12 +1403,16 @@ export class RollbackPointEngine {
         let sawChunk = false;
         // 走查过的**全部**文件路径（含被预算 / 单文件上限挡下的）—— 路径索引的来源（方向 B）
         const walked = [];
+        // 走查中断时**没进去的子树**（精确到目录）—— 供删除集做分子树 fail-closed
+        const unwalked = [];
         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;
             }
@@ -1125,108 +1420,48 @@ export class RollbackPointEngine {
                 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();
+        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'));
@@ -1236,6 +1471,8 @@ export class RollbackPointEngine {
             }
             catch (error) {
                 this.warn('rollback path index failed: ' + errorDetail(error));
+                // 走查过、却没进名单的路径无法被证明 ⇒ 删除集整体拒绝（绝不「删一半」）
+                payload.walkIncomplete = true;
             }
         }
         // 用户忽略的整目录 ⇒ 证明名单不完整（删除集整体拒绝；见 planCreatedRemovals）。
@@ -1244,6 +1481,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));
@@ -1251,9 +1490,25 @@ 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 {
@@ -1269,6 +1524,213 @@ 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)，绝不静默丢弃。
+     */
+    async captureChunkCandidates(chunk, candidates, slots, payload, outOfBudget) {
+        // 缺口优先：身份缓存里还没有的路径排前面 ⇒ 每个点都在补上次没覆盖的部分（见 orderByCoverage）
+        const ordered = await this.orderByCoverage(candidates);
+        const decided = new Array(ordered.length).fill(false);
+        const plans = [];
+        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 = 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 = new Array(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];
+                    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].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%。
+     * 组内保持走查顺序（稳定），因此同一输入下的结果仍然确定。
+     */
+    async orderByCoverage(candidates) {
+        if (candidates.length <= 1)
+            return [...candidates];
+        const cache = await this.loadPathCache();
+        if (cache.size === 0)
+            return [...candidates];
+        const covered = new Set();
+        for (const entry of cache.values())
+            covered.add(pathKey(entry.path));
+        if (covered.size === 0)
+            return [...candidates];
+        const cold = [];
+        const hot = [];
+        for (const file of candidates)
+            (covered.has(pathKey(file)) ? hot : cold).push(file);
+        return cold.length === 0 ? hot : [...cold, ...hot];
+    }
     ignoredByRules(rules, target, isDir) {
         const rel = ignoreRelativePath(rules.root, target);
         return rel === null ? false : ignoreRuleMatches(rules, rel, isDir);
@@ -1285,19 +1747,43 @@ export class RollbackPointEngine {
      * 用毫秒换算同样不行：会把「同一毫秒内的两次写」当成同一个身份。
      * 读不到身份（文件消失 / 权限 / 平台不支持 bigint stat）→ null ⇒ 回落全量真读。
      */
+    /**
+     * 一次 bigint stat 拿到阶段①需要的**全部**东西（是否文件 / 大小 / mtime / 身份）。
+     * 旧实现「fs.stat + pathIdentityOf」每文件 stat 两次，真机 34k 文件白花约 5 s。
+     */
+    async fileStatOf(target) {
+        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 ⇒ 调用方回落逐条判断 */
+    async objectNamesSnapshot() {
+        if (this.captureObjectNames !== null)
+            return this.captureObjectNames;
+        try {
+            this.captureObjectNames = new Set(await fs.readdir(this.objectsDir));
+        }
+        catch {
+            this.captureObjectNames = null;
+        }
+        return this.captureObjectNames;
+    }
     async pathIdentityOf(target) {
         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 & 511n),
-            ].join(':');
+            return fileIdentityOf(stat);
         }
         catch {
             return null;
@@ -1342,6 +1828,25 @@ export class RollbackPointEngine {
         return map;
     }
     /** 缓存命中：身份键存在、且路径逐字相同（身份被复用也绝不认）。 */
+    /**
+     * 「这条记录的当前内容**仍然是它**吗」的身份快路径 —— **预览与执行共用同一条判据**
+     * （否则「预览说会改的 = 实际会改的」这条不变式会被打破）。
+     *
+     * 判据：路径身份（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 是真算出来的）⇒ 仍走真读 + 哈希的旧路径，护栏不退化。
+     */
+    async unchangedByIdentity(file, identity) {
+        if (identity === null)
+            return false;
+        const cached = await this.lookupCachedFile(identity, file.path);
+        return cached !== null && cached.sha256 === file.sha256 && cached.bytes === file.bytes;
+    }
     async lookupCachedFile(identity, target) {
         const cache = await this.loadPathCache();
         const hit = cache.get(identity);
@@ -1597,6 +2102,70 @@ export class RollbackPointEngine {
      * 诚实的边界：检测与写入之间仍有极小窗口，无跨进程锁时无法彻底消除 —— 这里保证的是
      * 「不静默覆盖 + 尽量合并」，不是原子性。
      */
+    /**
+     * 把工作区载荷改写成**增量视图**（相对最近一个同分块的点）——清单增量化，省的是磁盘，不是语义。
+     *
+     * 判据与安全边界（逐条）：
+     *  · 基准 = 清单里最近一个 `workspace.payload` 非空、**分块完全相同**的点（只试最近几个，代价有界）；
+     *  · 增量 = 「相对基准新增 / 改写的条目」+「基准里不再存在的路径」，条目**逐字比较**（同形绝对路径）；
+     *  · 只有增量明显更小（< 全量的 60%）才用；否则原样全量落盘；
+     *  · 读路径由 ledger 物化（`resolvePayload`）⇒ 预览 / 回退 / 回收看到的永远是完整清单；
+     *  · 基准读不出来 / 分块对不上 / 任何异常 ⇒ 原样全量（绝不因为省字节而让点不可用）；
+     *  · 基准载荷的保活由 ledger 的 `payloadChain` 负责（淘汰时不会把基准删掉）。
+     */
+    async storagePlanFor(record, entries) {
+        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}） */
+    rememberDeltaBase(record, prepared) {
+        const payload = record.workspace.payload;
+        const hash = prepared.payloadHash;
+        if (payload === null || hash === null) {
+            this.deltaBase = null;
+            return;
+        }
+        const entries = new Map();
+        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,
+        };
+    }
     async appendRecord(record) {
         for (let attempt = 0; attempt < 3; attempt += 1) {
             const result = await this.appendRecordOnce(record);
@@ -1626,7 +2195,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);
             // 本次新增字节：记录文件 + **首次落盘**的载荷（同一工作区态已存在 ⇒ 零额外字节）
@@ -1657,6 +2229,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);
@@ -1974,6 +2548,27 @@ export class RollbackPointEngine {
         return out;
     }
     /* -------------------------------------------------------------- 预览 */
+    /**
+     * 预览的**单条只读判定**（阶段 A，可并发跑）：一次 bigint lstat + 身份快路径。
+     * `unchanged = true` 表示「已证明与记录一致」（身份命中身份缓存且 sha/bytes 相同）⇒ 调用方直接跳过。
+     */
+    async previewScan(file) {
+        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' };
+        }
+    }
     trackWarnings(record) {
         const out = [];
         for (const track of [record.workspace, record.session]) {
@@ -2022,32 +2617,44 @@ export class RollbackPointEngine {
         for (const entry of payload.ignoredDirs ?? [])
             proof.add(pathKey(entry.path));
         let refused = null;
-        if (payload.skippedTruncated) {
-            // 逐条跳过名单被记录上限截断 ⇒ 必须有路径索引，否则「未记录」≠「留点之后新建」
-            const index = payload.pathIndex ?? null;
-            if (index === null)
+        // 路径索引**存在即并入**证明名单：写入条件已从「跳过名单被截断」推广为「覆盖自检不完整」
+        // （读到一半被预算打断也会写索引）—— 这里只看 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 {
-                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';
-                }
             }
         }
-        // 读不出的目录：目录内容在留点时刻**未知**（路径索引只含走查过的路径）⇒ 同样证明不了
-        if (refused === null && payload.unreadableDirs.length > 0)
+        else if (payload.skippedTruncated) {
+            // 逐条跳过名单被记录上限截断、又没有索引 ⇒ 「未记录」≠「留点之后新建」，证明不了
             refused = 'capture-incomplete';
-        // 用户忽略的整目录 ⇒ 其下内容在留点时刻未知 ⇒ 证明名单不完整（fail-closed）
-        if (refused === null && payload.ignoreIncomplete === true)
-            refused = 'capture-incomplete';
-        // 走查被时间预算 / 取消信号中断 ⇒ 剩余子树**一条都没进任何名单** ⇒ 同样证明不了
-        // （这是 `truncated` 之外的第四种「名单不完整」：其余三种截断都会逐条留痕）
-        if (refused === null && payload.walkIncomplete === true)
+        }
+        // —— 分子树拒删范围 ——
+        // 忽略目录 / 读不出的目录 / 走查没进去的子树：这三类的共同点是「其下内容在留点时刻未知」，
+        // 但它们**各自只影响自己那棵子树**。旧口径一律全局拒删，代价是「忽略一个 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 = scopesKnown
+            ? [
+                ...(payload.ignoredDirs ?? []).map((entry) => entry.path),
+                ...payload.unreadableDirs,
+                ...(payload.unwalkedDirs ?? []),
+            ]
+            : [];
+        if (refused === null && !scopesKnown) {
+            // 证明名单不完整、且**说不出**不完整的确切范围 ⇒ 整个工作区一条都不删（安全方向）
             refused = 'capture-incomplete';
+        }
         const chunks = payload.chunks;
         // 走查上限 = 全树：候选的**准入**由证明名单负责，条数上限不再是安全阀
         //（旧上限 maxFiles*4 会在巨型工作区里静默漏掉真正的新建文件 —— 那是「删一半」，不是 fail-closed）
@@ -2055,7 +2662,7 @@ export class RollbackPointEngine {
         // **时间预算**：回退期的走查同样不能无限跑（分块 = 会话 cwd，家目录 / 大仓库会走很久，
         // 而捕获侧早就有 30 s 预算 —— 只修一侧等于把 OOM 形态从留点搬到了回退）。
         // 中断只会让候选**变少**（安全方向），但必须如实置 truncated（绝不静默漏删、也不谎报完整）。
-        const deadline = this.stamp() + this.captureBudgetMs;
+        const deadline = this.stamp() + this.rewindBudgetMs;
         const outOfBudget = () => this.stamp() >= deadline;
         const candidates = [];
         let truncated = false;
@@ -2081,13 +2688,20 @@ export class RollbackPointEngine {
                 candidates.push(file);
             }
         }
-        const refusalWarnings = this.createdRefusalWarnings(payload);
+        // 警告只在**全局拒绝**时给：分子树拒绝由 createdSkipped 逐条说明（那句「本次不删除任何
+        // 『留点后新建』的路径」在分子树拒绝下是假话 —— 文案诚实要求按真实范围分派）。
+        const refusalWarnings = refused === null ? [] : this.createdRefusalWarnings(payload);
         const all = [];
         const paths = [];
         const skipped = [];
         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;
@@ -2236,19 +2850,27 @@ export class RollbackPointEngine {
             const changedFiles = [];
             // 单张预览共享的比对预算（字节 + 步数）；只有真的会被改动的条目才消耗它
             const diffBudget = { bytes: 0, work: 0 };
-            for (const file of wsPayload.files) {
-                let outcome;
-                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' };
+            // T10：stat 的三种结局分开表达 —— 「不存在（ENOENT）」与「存在性未知（其它 errno）」绝不混为一谈
+            const previewFiles = wsPayload.files;
+            // 阶段 A（**并发**）：逐条一次 bigint lstat + 身份快路径。大仓库这里是预览的大头：
+            // 真机 34k 条实测 —— 串行 lstat ≈ 6 s、串行真读 ≈ 13 s；并发后降到亚秒级 + 只读真正变了的那几条。
+            const scans = new Array(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]);
                 }
+            });
+            await Promise.all(scanWorkers);
+            // 阶段 B（**顺序**）：只对「变了 / 没了 / 不可写」的条目按记录顺序装配 —— 列表顺序与行级 diff 的
+            // 共享预算因此仍**完全确定**（与并发前逐条一致，测试可逐字对账）。
+            for (let index = 0; index < previewFiles.length; index += 1) {
+                const file = previewFiles[index];
+                const outcome = scans[index] ?? { kind: 'unavailable' };
                 if (outcome.kind === 'missing') {
                     // **只有 ENOENT** 才算「当前确实不存在」⇒ 回退会重新创建它
                     missing += 1;
@@ -2266,6 +2888,9 @@ 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;
@@ -2274,7 +2899,7 @@ export class RollbackPointEngine {
                 // ② 大小不一致时也得读一次才能给行级统计（超限的大文件不白读）。
                 if (regular && (sizeMatches || withinCaps)) {
                     try {
-                        current = await fs.readFile(file.path);
+                        current = await this.readFileBytes(file.path);
                     }
                     catch {
                         current = null;
@@ -2475,7 +3100,7 @@ export class RollbackPointEngine {
             return { ...view, reason: 'too-large' };
         if (before.binary || after.binary)
             return { ...view, reason: 'binary' };
-        const result = diffLines(current === null ? '' : DIFF_TEXT_DECODER.decode(current), DIFF_TEXT_DECODER.decode(snapshot), { context: ROLLBACK_FILE_DIFF_LIMITS.context });
+        const result = diffLines(current === null ? '' : DIFF_TEXT_DECODER.decode(current), DIFF_TEXT_DECODER.decode(snapshot), { context: ROLLBACK_FILE_DIFF_LIMITS.context, maxD: ROLLBACK_FILE_DIFF_LIMITS.maxD });
         return {
             ...view,
             hunks: result.hunks, added: result.added, removed: result.removed,
@@ -2691,6 +3316,8 @@ export class RollbackPointEngine {
         const detail = [];
         const writable = [];
         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));
@@ -2699,6 +3326,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) {
@@ -2750,7 +3388,6 @@ export class RollbackPointEngine {
         // E1：内容已与快照一致的条目**不再写** —— 「0 变更」就要是真的 0 次写入
         // （否则工作区已与该点一致时也会重写全部文件，白耗 I/O 并抖动 mtime）。
         const needed = [];
-        let unchanged = 0;
         for (const item of writable) {
             let identical = false;
             try {
@@ -2798,7 +3435,7 @@ export class RollbackPointEngine {
             let bytes = null;
             let unreadable = null;
             try {
-                bytes = await fs.readFile(item.file.path);
+                bytes = await this.readFileBytes(item.file.path);
             }
             catch (error) {
                 // **只认 ENOENT = 当时确实不存在**。其它 errno（EACCES / EMFILE / EBUSY…）是
@@ -2849,7 +3486,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);
                 }