dsh-config-manager 0.1.76 → 0.1.77

package/lib/core/rollback-point.js

@@ -72,6 +72,7 @@ import { EXCLUDED_DEP_DIR_NAMES } from '../utils/recursive-walk.js';
 import { diffLines } from '../utils/line-diff.js';
 import { projectKeyOf } from './session-select.js';
 import { ignoreRelativePath, ignoreRuleMatches, loadIgnoreRules } from './rollback-ignore-rules.js';
+import { mergeThreeWay } from './rollback-merge.js';
 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';
@@ -853,6 +854,8 @@ export class RollbackPointEngine {
     ledgerSnapshotCache = null;
     /** 台账存储层（v3：清单 + 单条记录 + 内容寻址载荷；issue #89） */
     ledger;
+    /** 写入归属（2026-10-17 定案 B）。undefined = 没有归属信息 ⇒ 预览不标 foreign */
+    attribution;
     ledgerBytesBudget;
     /**
      * 工作区捕获的挂钟时间预算（毫秒；见 ROLLBACK_DEFAULT_CAPTURE_BUDGET_MS）。**可变**：
@@ -908,6 +911,7 @@ export class RollbackPointEngine {
         this.maxGuards = options.maxGuards ?? ROLLBACK_MAX_GUARDS;
         this.guardPolicy = options.guardPolicy ?? 'warn';
         this.probe = options.storage;
+        this.attribution = options.attribution;
         this.forkSeam = options.fork;
         this.writeSeam = options.writeFile;
         this.readSeam = options.readFile;
@@ -2793,6 +2797,27 @@ export class RollbackPointEngine {
             return previewCountsUnavailable();
         return { added: counts.added, removed: counts.removed, truncated: false };
     }
+    /**
+     * **合并结果**的逐文件行级统计（与 `previewFileCounts` 同一套预算与降级判据）。
+     *
+     * 为什么单独一份：合并后要写进去的内容既不是记录里的原文（ours），也不是磁盘现状（theirs）——
+     * 预览若照旧拿 ours 算差异，就会把「其实会被保留的对方改动」显示成「会被删掉」。
+     */
+    async previewMergeCounts(targetBytes, current, budget) {
+        if (targetBytes.byteLength > this.previewDiffMaxFileBytes || current.byteLength > this.previewDiffMaxFileBytes) {
+            return previewCountsUnavailable();
+        }
+        if (budget.bytes + targetBytes.byteLength + current.byteLength > this.previewDiffMaxTotalBytes) {
+            return previewCountsUnavailable();
+        }
+        budget.bytes += targetBytes.byteLength + current.byteLength;
+        if (looksBinary(targetBytes) || looksBinary(current))
+            return previewCountsUnavailable();
+        const counts = lineDiffCounts(splitDiffLines(DIFF_TEXT_DECODER.decode(current)), splitDiffLines(DIFF_TEXT_DECODER.decode(targetBytes)), this.previewDiffMaxWork, this.previewDiffTotalWork, budget);
+        if (counts === null)
+            return previewCountsUnavailable();
+        return { added: counts.added, removed: counts.removed, truncated: false };
+    }
     /** 只读预览：零写入（不过确认门、不拍 guard、不写任何字节）。 */
     async preview(id) {
         const storage = await this.storageStatus();
@@ -2848,8 +2873,24 @@ export class RollbackPointEngine {
             let missing = 0;
             // E1：逐文件行级统计 —— **只列会被改动的文件**（内容已一致的一个都不列）
             const changedFiles = [];
+            // 写入归属（2026-10-17 定案 B）：只有**确知**最后写入者是别的会话、且写入发生在留点**之后**时，
+            // 才敢标 foreign。缺归属 / 归属就是本会话 / 写入早于留点 ⇒ 一律不标
+            // （未判定 ≠ 别的会话写的；宁可少标一次，也不误判一次）。
+            const foreignWriterOf = (target) => {
+                const writer = this.attribution?.writerOf(target);
+                if (writer === undefined)
+                    return undefined;
+                if (writer.sessionId === record.sessionId)
+                    return undefined;
+                if (writer.at <= wsTrack.capturedAt)
+                    return undefined;
+                return writer;
+            };
             // 单张预览共享的比对预算（字节 + 步数）；只有真的会被改动的条目才消耗它
             const diffBudget = { bytes: 0, work: 0 };
+            /** 合并判定的会话身份与 base 缓存（与执行端同一判据：拿目标点的会话当「本会话」） */
+            const previewIsolationSessionId = typeof record.sessionId === 'string' && record.sessionId !== '' ? record.sessionId : null;
+            const previewBaseCache = new Map();
             // T10：stat 的三种结局分开表达 —— 「不存在（ENOENT）」与「存在性未知（其它 errno）」绝不混为一谈
             const previewFiles = wsPayload.files;
             // 阶段 A（**并发**）：逐条一次 bigint lstat + 身份快路径。大仓库这里是预览的大头：
@@ -2885,7 +2926,12 @@ export class RollbackPointEngine {
                     // 计入 different 的理由：回退一定会尝试写它（restoreWorkspace 里「已一致」判定失败即视为需要写），
                     // 这样 overwrite = 已一致 + different + missing 的算术仍然成立。
                     different += 1;
-                    changedFiles.push({ path: file.path, status: 'overwrite', ...previewCountsUnavailable() });
+                    const foreignMissing = foreignWriterOf(file.path);
+                    changedFiles.push({
+                        path: file.path, status: 'overwrite',
+                        ...(foreignMissing === undefined ? {} : { foreign: true, foreignSessionId: foreignMissing.sessionId, foreignAt: foreignMissing.at }),
+                        ...previewCountsUnavailable(),
+                    });
                     continue;
                 }
                 // 身份快路径已证明「与记录一致」⇒ 一个字段都不改（内容一致的文件不列进列表）
@@ -2907,10 +2953,43 @@ export class RollbackPointEngine {
                 }
                 if (sizeMatches && current !== null && sha256Hex(current) === file.sha256)
                     continue;
+                // **合并判定与执行同口径**（2026-10-17 修）：预览必须说清「这次到底会写成什么」。
+                // 之前预览只按「覆盖回记录版本」算差异，而执行端会先做三方合并 ⇒ 预览把对方后来的行
+                // 也算成「会被删掉」，用户据此以为会丢别人的改动（真机：两行描述都显示要删，实际只删 A 那行）。
+                const decision = await (async () => {
+                    if (current === null || previewIsolationSessionId === null)
+                        return { mode: 'overwrite' };
+                    let baseText = previewBaseCache.get(pathKey(file.path));
+                    if (baseText === undefined) {
+                        baseText = await this.baseVersionFor(file.path, wsTrack.capturedAt, previewIsolationSessionId);
+                        previewBaseCache.set(pathKey(file.path), baseText);
+                    }
+                    const writer = this.attribution?.writerOf(file.path);
+                    const foreignEvidence = writer !== undefined && writer.sessionId !== previewIsolationSessionId && writer.at > wsTrack.capturedAt;
+                    if (baseText === null && !foreignEvidence)
+                        return { mode: 'overwrite' };
+                    const outcome = await this.mergeForeignRecord(file, baseText, foreignEvidence);
+                    if (outcome.kind === 'write')
+                        return { mode: 'merged', bytes: outcome.bytes };
+                    if (outcome.kind === 'unchanged')
+                        return { mode: 'unchanged' };
+                    if (outcome.kind === 'blocked')
+                        return { mode: 'skip', reason: outcome.reason };
+                    return { mode: 'overwrite' };
+                })();
+                // 合并结论是「保持现状」⇒ 它不会被改动，不该出现在「会被改动」的清单里
+                if (decision.mode === 'unchanged')
+                    continue;
                 different += 1;
+                const foreignWriter = foreignWriterOf(file.path);
                 changedFiles.push({
                     path: file.path, status: 'overwrite',
-                    ...(await this.previewFileCounts(file, current, 'overwrite', diffBudget)),
+                    ...(foreignWriter === undefined ? {} : { foreign: true, foreignSessionId: foreignWriter.sessionId, foreignAt: foreignWriter.at }),
+                    ...(decision.mode === 'skip'
+                        ? { skipped: true, mergeReason: decision.reason, ...previewCountsUnavailable() }
+                        : decision.mode === 'merged' && decision.bytes !== undefined && current !== null
+                            ? await this.previewMergeCounts(decision.bytes, current, diffBudget)
+                            : await this.previewFileCounts(file, current, 'overwrite', diffBudget)),
                 });
             }
             const sink = { skipped: [], excludedDirs: [], ignoredDirs: [], ignoredDirCount: 0, unreadableDirs: [], skippedCount: 0, skippedTruncated: false };
@@ -3068,6 +3147,37 @@ export class RollbackPointEngine {
             else
                 currentUnreadable = true;
         }
+        // **合并判定与执行同口径**（2026-10-17 修）：「回退后」一侧必须显示这次**真正会写进去**的内容。
+        // 以前它恒定显示记录里的原文（= 整文件覆盖的样子），于是预览列表写着「+0 −2」，点开「查看差异」
+        // 却还是「−1,4 +1,1」—— 同一件事两个说法（真机 2026-10-17 用户当场发现）。
+        let mergedAfter = null;
+        /** true 只表示「after 侧真的是合并算出来的」——「不会改动」时 after 也是现状，但不算合并 */
+        let mergedFlag = false;
+        let mergeSkippedReason = null;
+        const isolationSessionId = typeof record.sessionId === 'string' && record.sessionId !== '' ? record.sessionId : null;
+        if (current !== null && snapshot !== null && isolationSessionId !== null) {
+            const baseText = await this.baseVersionFor(file.path, record.workspace.capturedAt, isolationSessionId);
+            const writer = this.attribution?.writerOf(file.path);
+            const foreignEvidence = writer !== undefined && writer.sessionId !== isolationSessionId && writer.at > record.workspace.capturedAt;
+            if (baseText !== null || foreignEvidence) {
+                const outcome = await this.mergeForeignRecord(file, baseText, foreignEvidence);
+                if (outcome.kind === 'write') {
+                    mergedAfter = outcome.bytes;
+                    mergedFlag = true;
+                }
+                // 合并结论 = 保持现状 ⇒ 「回退后」就是当前内容（该文件根本不会被写）
+                else if (outcome.kind === 'unchanged')
+                    mergedAfter = current;
+                else if (outcome.kind === 'blocked') {
+                    // 冲突 / 无法安全合并 ⇒ 这次**不会写**它：「回退后」就是现状（两侧相同），
+                    // 界面据此说「不会改动」，绝不显示成「会被覆盖成记录原文」。
+                    mergeSkippedReason = outcome.reason;
+                    mergedAfter = current;
+                }
+            }
+        }
+        /** 回退后一侧的字节：合并结果优先，其次才是记录里的原文 */
+        const afterBytes = mergedAfter ?? snapshot;
         const before = {
             exists: currentExists, bytes: currentBytes, lines: null,
             binary: false, oversized: currentOversized, unreadable: currentUnreadable,
@@ -3077,17 +3187,19 @@ export class RollbackPointEngine {
             before.lines = before.binary ? null : splitDiffLines(DIFF_TEXT_DECODER.decode(current)).length;
         }
         const after = {
-            exists: snapshot !== null, bytes: snapshot?.byteLength ?? file.bytes, lines: null,
+            exists: afterBytes !== null, bytes: afterBytes?.byteLength ?? file.bytes, lines: null,
             binary: false, oversized: snapshotOversized,
-            unreadable: snapshot === null && !snapshotOversized,
+            unreadable: afterBytes === null && !snapshotOversized,
         };
-        if (snapshot !== null) {
-            after.binary = looksBinary(snapshot);
-            after.lines = after.binary ? null : splitDiffLines(DIFF_TEXT_DECODER.decode(snapshot)).length;
+        if (afterBytes !== null) {
+            after.binary = looksBinary(afterBytes);
+            after.lines = after.binary ? null : splitDiffLines(DIFF_TEXT_DECODER.decode(afterBytes)).length;
         }
         const view = {
             ...base, ok: true, code: 'ok', path: file.path,
             status: currentExists ? 'overwrite' : 'create', before, after,
+            ...(mergedFlag ? { merged: true } : {}),
+            ...(mergeSkippedReason === null ? {} : { mergeSkipped: true, mergeReason: mergeSkippedReason }),
         };
         // 结构性不可比对：逐条给出原因（有原因 ⇒ hunks 恒为空，绝不给半截差异）
         if (snapshotOversized)
@@ -3100,7 +3212,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, maxD: ROLLBACK_FILE_DIFF_LIMITS.maxD });
+        const result = diffLines(current === null ? '' : DIFF_TEXT_DECODER.decode(current), afterBytes === null ? '' : DIFF_TEXT_DECODER.decode(afterBytes), { context: ROLLBACK_FILE_DIFF_LIMITS.context, maxD: ROLLBACK_FILE_DIFF_LIMITS.maxD });
         return {
             ...view,
             hunks: result.hunks, added: result.added, removed: result.removed,
@@ -3214,7 +3326,10 @@ export class RollbackPointEngine {
                 continue;
             }
             const segment = state === 'workspace'
-                ? await this.restoreWorkspace(record.workspace, { removeCreated: input.removeCreated === true })
+                // 路径级选择（2026-10-17 定案 A）只在显式给出时透传 —— 缺省口径一字不变
+                ? await this.restoreWorkspace(record.workspace, input.onlyPaths === undefined
+                    ? { removeCreated: input.removeCreated === true, sessionId: record.sessionId ?? '' }
+                    : { removeCreated: input.removeCreated === true, onlyPaths: input.onlyPaths, sessionId: record.sessionId ?? '' })
                 : await this.restoreSession(record.session);
             segments.push(segment);
             if (segment.childSessionId !== undefined)
@@ -3303,6 +3418,158 @@ export class RollbackPointEngine {
             return 'excluded-dir';
         return null;
     }
+    /**
+     * 把一条「留点之后被**别的会话**写过」的记录做成三方合并结果（2026-10-17 跨对话安全回退）。
+     *
+     * 三方：`ours` = 记录里的内容（回退目标）、`base` = 目标点之后**最早**那份中间版本、
+     * `theirs` = 当前磁盘。结果是「撤销本会话那次改动 + 保留对方后来的改动」。
+     *
+     * 返回：`write`（合并干净且确实要写，带目标哈希 + 期望的当前哈希）、
+     * `unchanged`（合并结果就是当前内容 —— 对方没动这一处，本来就不需要写）、
+     * `blocked`（不能安全处理：冲突 / 没有中间版本 / 二进制 / 差异被降级 / 对方改成了不存在 / 读不出）。
+     */
+    async mergeForeignRecord(file, baseText, foreignEvidence) {
+        let oursBytes;
+        try {
+            oursBytes = await this.readObject(file.object);
+            if (sha256Hex(oursBytes) !== file.sha256)
+                return { kind: 'blocked', reason: 'ours-unreadable' };
+        }
+        catch {
+            return { kind: 'blocked', reason: 'ours-unreadable' };
+        }
+        let theirsBytes;
+        try {
+            theirsBytes = await fs.readFile(file.path);
+        }
+        catch (error) {
+            return { kind: 'blocked', reason: error.code === 'ENOENT' ? 'theirs-missing' : 'theirs-unreadable' };
+        }
+        const oursText = Buffer.from(oursBytes).toString('utf8');
+        // **base 必须真的携带「本会话改动之后」的信息**：若它与 ours（回退目标）逐字相同，说明它
+        // 提供不了任何「本会话改了什么」的知识 —— 拿它当共同祖先会让合并结论变成「保持当前」，
+        // 于是「回退到该点」成了「什么都不做」（真机 R-25 就是这个形态被抓出来的：guard 之后
+        // 那个点的内容与目标点相同）。
+        if (baseText === null || baseText === oursText) {
+            // 有「别人写过」的旁证却没有可用祖先 ⇒ 无法安全撤销，宁可不动它并如实报告；
+            // 两样都没有 ⇒ 退回旧口径（整文件覆盖回目标版本）—— 那正是「纯本会话回退」的常见形态。
+            if (foreignEvidence)
+                return { kind: 'blocked', reason: 'no-base' };
+            return { kind: 'fallback' };
+        }
+        // 二进制：任何一侧含 NUL 就绝不按文本合并（三方合并算法只对文本有定义）
+        if (oursBytes.includes(0) || theirsBytes.includes(0) || baseText.includes('\u0000'))
+            return { kind: 'blocked', reason: 'binary' };
+        const theirsText = Buffer.from(theirsBytes).toString('utf8');
+        const result = mergeThreeWay(oursText, baseText, theirsText);
+        if (!result.ok) {
+            return { kind: 'blocked', reason: result.reason === 'conflict' ? 'conflict' : result.reason === 'degraded' ? 'degraded' : 'binary' };
+        }
+        // 调用方只在「当前内容 ≠ 记录内容」时才会走到这里 ⇒ `ours === theirs` 只可能是内容恰好相同
+        if (oursText === theirsText)
+            return { kind: 'unchanged' };
+        if (result.text === theirsText) {
+            // **合并结论 = 保持现状**：这次回退对工作区什么也做不了 —— 但 ours 与 theirs 明明不同
+            //（否则上面那条就返回了）。真机 2026-10-17 的形状：base 取到了目标点**之后**的另一份快照
+            //（里面已经含有「要撤销的那部分改动」），于是「应用对方的改动到 ours」恰好又变回现状。
+            // 绝不能把它当成「无需改动」静默跳过 —— 那会让「回退」整个失效、界面上还看不到任何痕迹
+            //（预览报 0 个文件、执行返回 nothing-to-restore）。这里按**无法安全撤销**如实处理：
+            // 一个字节都不写，让用户看到并自己决定。
+            return { kind: 'blocked', reason: 'ambiguous' };
+        }
+        const bytes = Buffer.from(result.text, 'utf8');
+        return { kind: 'write', bytes, sha256: sha256Hex(bytes), expectedCurrent: sha256Hex(theirsBytes) };
+    }
+    /**
+     * 三方合并的 **base**：目标点之后**最早**那份仍含该路径的中间版本（共同祖先）。
+     *
+     * 为什么这么取：回滚点的「工作区态」是回合开始前拍的 ⇒ 别的会话那个回合的点，
+     * 正好是「本会话改动之后、对方改动之前」的版本 —— 标准三方合并的共同祖先。
+     * 取**最早**而不是最近是刻意选安全方向：宁可少撤销，也绝不把对方更晚的改动算进 ours 侧。
+     *
+     * 排除四类：目标点自己（`createdAt > afterAt`）、**救援点 guard**（它在执行回退那一刻拍，
+     * 内容 ≈ 当前磁盘，拿它当 base 会让合并结果直接等于 ours = 整文件覆盖，正是本机制要消灭的形态）、
+     * **本会话的点**（见上）、以及内容读不出来的点（继续往后找 —— 找不到 ⇒ 调用方按「无法安全撤销」
+     * 处理，绝不用近似值代替）。
+     */
+    async baseVersionFor(target, afterAt, excludeSessionId) {
+        const ledger = await this.readManifest();
+        const key = pathKey(target);
+        const candidates = ledger.entries
+            .filter((entry) => entry.createdAt > afterAt
+            && entry.kind !== 'guard'
+            // 只认**别的会话**的点：本会话后续回合的点当作 base，会把「本会话后续改动」也一并保留下来，
+            // 那与「回退到该点之前」的直觉冲突；而别人的点正好是「本会话改动之后、对方改动之前」的版本。
+            && (excludeSessionId === null || entry.sessionId !== excludeSessionId))
+            .sort((left, right) => (left.createdAt < right.createdAt ? -1 : left.createdAt > right.createdAt ? 1 : 0));
+        for (const entry of candidates) {
+            const resolved = await this.readFullRecord(entry.id);
+            const payload = resolved.record?.workspace.payload;
+            if (payload === null || payload === undefined)
+                continue;
+            const hit = payload.files.find((item) => pathKey(item.path) === key);
+            if (hit === undefined)
+                continue;
+            try {
+                const bytes = await this.readObject(hit.object);
+                if (sha256Hex(bytes) !== hit.sha256)
+                    continue;
+                return Buffer.from(bytes).toString('utf8');
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    /**
+     * **别的会话的回合点里记录过的路径集合** —— 删除集保护的第二种证据（不依赖归属台账）。
+     *
+     * 为什么需要第二证据：归属可能整条缺失（工具不在白名单 / 另一个 DSH 进程把 attribution.json
+     * 整体覆盖写 / 采集时机错过），而「别人的点里出现过这个路径」是**点台账本身**记录的事实 ——
+     * 它足以证明「这条路径在留点之后被别的会话所在的回合捕获过」，因此删它就是销毁别人的工作。
+     *
+     * 有界：只扫目标点之后**最早**的 `limit` 个别的会话的点（按时间升序），且只读路径不读内容。
+     * 扫不完不影响安全方向（少保护也会被归属那条兜一部分），但绝不因此声称「已扫全」。
+     */
+    async foreignRecordedPaths(afterAt, excludeSessionId, limit = 10) {
+        const out = new Set();
+        const ledger = await this.readManifest();
+        const candidates = ledger.entries
+            .filter((entry) => entry.createdAt > afterAt
+            && entry.kind !== 'guard'
+            && (excludeSessionId === null || entry.sessionId !== excludeSessionId))
+            .sort((left, right) => (left.createdAt < right.createdAt ? -1 : left.createdAt > right.createdAt ? 1 : 0))
+            .slice(0, Math.max(1, limit));
+        for (const entry of candidates) {
+            const resolved = await this.readFullRecord(entry.id);
+            const payload = resolved.record?.workspace.payload;
+            if (payload === null || payload === undefined)
+                continue;
+            const files = payload.files;
+            if (Array.isArray(files)) {
+                for (const item of files) {
+                    const target = item.path;
+                    if (typeof target === 'string' && target !== '')
+                        out.add(pathKey(target));
+                }
+                continue;
+            }
+            const delta = payload.delta;
+            if (delta === null || delta === undefined)
+                continue;
+            for (const bucket of [delta.added, delta.removed]) {
+                if (!Array.isArray(bucket))
+                    continue;
+                for (const item of bucket) {
+                    const target = typeof item === 'string' ? item : item?.path;
+                    if (typeof target === 'string' && target !== '')
+                        out.add(pathKey(target));
+                }
+            }
+        }
+        return out;
+    }
     async restoreWorkspace(track, options = {}) {
         const payload = track.payload;
         if (!track.ok || payload === null) {
@@ -3314,11 +3581,80 @@ export class RollbackPointEngine {
         if (payload.files.length === 0)
             return this.noopSegment('workspace', 'no-recorded-files', 'files=0 nothingToDo=true');
         const detail = [];
+        // 路径级选择性恢复（2026-10-17 定案 A）：null = 全量（旧口径，行为一字不变）。
+        const selection = options.onlyPaths === undefined ? null : new Set(options.onlyPaths.map((target) => pathKey(target)));
+        /** 因用户没勾选而跳过的记录条目数（只作事实回传，不参与任何安全判据） */
+        let selectionSkipped = 0;
+        /**
+         * 归属隔离（2026-10-17 定案 B）：**没有显式点名**时，把「留点之后被别的会话写过」的记录条目
+         * 自动跳过（上层据此如实报告）。只有 attribution 在、且这次回退知道自己属于哪个会话时才可能生效；
+         * 缺任何一样 ⇒ 退化成旧口径（照常恢复）—— **未判定绝不当作别的会话写的**。
+         */
+        let foreignSkipped = 0;
+        const isolationSessionId = typeof options.sessionId === 'string' && options.sessionId !== '' ? options.sessionId : null;
+        /**
+         * **合并保护**（2026-10-17 修）：触发条件**不看归属**，只看「有没有共同祖先可用」。
+         *
+         * 为什么必须这样：归属台账是**旁证**而不是判据 —— 对方的写入可能因为工具不在白名单、
+         * 或另一个 DSH 进程把 attribution.json 整体覆盖写而**没被记到**。真机 2026-10-17：
+         * 两个对话各给 README 加了一行描述，回退其中一个之后**两行都没了**，根因正是
+         * 「归属里只有本会话那次编辑」⇒ 不认为有第三方 ⇒ 退回整文件覆盖。
+         * 只要目标点之后**存在别的会话的回合点**，那它就是共同祖先 ⇒ 必须走三方合并。
+         */
+        const mergeGuardEnabled = selection === null && isolationSessionId !== null;
+        /** 同一路径的 base 只查一次（合并判定在「确认需要写」之后，命中数很少） */
+        const baseCache = new Map();
+        const sink = { skipped: [], excludedDirs: [], ignoredDirs: [], ignoredDirCount: 0, unreadableDirs: [], skippedCount: 0, skippedTruncated: false };
+        // 删除集与**预览**共用同一份规划（planCreatedRemovals）⇒「预览说会删的」= 「实际删的」。
+        // 为什么提到文件循环**之前**：选择模式要拿它当「合法路径」的第二来源（新建候选也允许被点名），
+        // 而校验必须在**任何写入之前**完成。它是只读走查，提前算不会写任何东西。
+        const plan = await this.planCreatedRemovals(payload, sink);
+        if (selection !== null) {
+            const legal = new Set();
+            for (const file of payload.files)
+                legal.add(pathKey(file.path));
+            for (const target of plan.all)
+                legal.add(pathKey(target));
+            const unknown = [...selection].filter((key) => !legal.has(key));
+            if (unknown.length > 0) {
+                // 点名了一个「既未记录、也不在删除候选」里的路径 ⇒ fail-closed：零写入失败，
+                // 绝不把「用户打错一个路径」变成「静默少恢复几个文件」。
+                pushDetail(detail, 'selection-unknown-path ' + unknown[0] + ' unknown=' + String(unknown.length) + ' zeroWrites=true');
+                return {
+                    state: 'workspace', status: 'failed', reasonCode: 'invalid-input', detail,
+                    restored: 0, failed: unknown.length,
+                    leftovers: plan.all.slice(0, ROLLBACK_LEFTOVER_LIST_LIMIT), leftoversTruncated: plan.truncated,
+                };
+            }
+        }
+        /**
+         * 待写条目。`sha256` / `expectedCurrent` **只被三方合并路径**使用：
+         *  · `sha256` = 这次真正要写进去的内容哈希（普通路径恒等于记录里的 `file.sha256`）；
+         *  · `expectedCurrent` = 合并时读到的「当前磁盘」哈希 —— 写入前必须仍是它，否则说明
+         *    文件在预览/合并之后又被改过 ⇒ **放弃写入**（并发保护：绝不覆盖比我们更新的内容）。
+         */
         const writable = [];
         let failed = 0;
         // 「已与记录一致」的条目数（身份快路径证明）—— 后面「0 变更」的文案与统计要用
         let unchanged = 0;
+        /** 三方合并成功、写回「撤销本会话 + 保留对方改动」结果的条目数 */
+        let mergedCount = 0;
+        /** 冲突：两侧改到同一处 ⇒ 绝不自动选边，交给用户 */
+        let conflictCount = 0;
+        /** 无法安全撤销：没有中间版本 / 二进制 / 差异被降级 / 对方把它改成了不存在 */
+        let unavailableCount = 0;
+        /** 写入前发现文件又被改过（并发）⇒ 放弃写入 */
+        let concurrentCount = 0;
+        const mergedPaths = [];
+        const conflictPaths = [];
+        const unavailablePaths = [];
+        const concurrentPaths = [];
         for (const file of payload.files) {
+            // 路径级选择：没被点名的记录条目**不写**（用户自己的选择，不是安全判据）
+            if (selection !== null && !selection.has(pathKey(file.path))) {
+                selectionSkipped += 1;
+                continue;
+            }
             // 门：记录里的路径必须落在记录里的分块内（记录不可成为写原语）
             const inChunk = payload.chunks.some((chunk) => path.isAbsolute(chunk) && isInsidePath(file.path, chunk));
             if (!path.isAbsolute(file.path) || !inChunk || isInsidePath(file.path, this.root)) {
@@ -3344,6 +3680,55 @@ export class RollbackPointEngine {
                     pushDetail(detail, 'object-hash-mismatch ' + file.path);
                     continue;
                 }
+                // **合并保护**（2026-10-17 修）：到这里才确认「这个文件确实需要写」，也才值得去查共同祖先。
+                // 触发不吃归属：只要目标点之后存在**别的会话**的回合点（那它就是共同祖先），就走三方合并。
+                if (mergeGuardEnabled) {
+                    let base;
+                    const cached = baseCache.get(pathKey(file.path));
+                    if (cached === undefined) {
+                        base = await this.baseVersionFor(file.path, track.capturedAt, isolationSessionId);
+                        baseCache.set(pathKey(file.path), base);
+                    }
+                    else {
+                        base = cached;
+                    }
+                    const foreignWriter = this.attribution?.writerOf(file.path);
+                    const foreignEvidence = foreignWriter !== undefined
+                        && foreignWriter.sessionId !== isolationSessionId
+                        && foreignWriter.at > track.capturedAt;
+                    if (base !== null || foreignEvidence) {
+                        const outcome = await this.mergeForeignRecord(file, base, foreignEvidence);
+                        if (outcome.kind === 'fallback') {
+                            // 没有可用祖先、也没有别人的旁证 ⇒ 落到下面的旧口径（整文件覆盖回目标版本）
+                        }
+                        else {
+                            if (outcome.kind === 'write') {
+                                writable.push({ file, bytes: outcome.bytes, sha256: outcome.sha256, expectedCurrent: outcome.expectedCurrent });
+                                mergedCount += 1;
+                                if (mergedPaths.length < ROLLBACK_LEFTOVER_LIST_LIMIT)
+                                    mergedPaths.push(file.path);
+                                continue;
+                            }
+                            if (outcome.kind === 'unchanged') {
+                                unchanged += 1;
+                                continue;
+                            }
+                            foreignSkipped += 1;
+                            if (outcome.reason === 'conflict') {
+                                conflictCount += 1;
+                                if (conflictPaths.length < ROLLBACK_LEFTOVER_LIST_LIMIT)
+                                    conflictPaths.push(file.path);
+                            }
+                            else {
+                                unavailableCount += 1;
+                                if (unavailablePaths.length < ROLLBACK_LEFTOVER_LIST_LIMIT)
+                                    unavailablePaths.push(file.path);
+                            }
+                            pushDetail(detail, 'foreign-' + outcome.reason + ' ' + file.path + ' zeroWrites=true');
+                            continue;
+                        }
+                    }
+                }
                 writable.push({ file, bytes });
             }
             catch (error) {
@@ -3351,10 +3736,20 @@ export class RollbackPointEngine {
                 pushDetail(detail, 'object-missing ' + file.path + ' ' + errorDetail(error));
             }
         }
-        const sink = { skipped: [], excludedDirs: [], ignoredDirs: [], ignoredDirCount: 0, unreadableDirs: [], skippedCount: 0, skippedTruncated: false };
-        // 删除集与**预览**共用同一份规划（planCreatedRemovals）⇒「预览说会删的」= 「实际删的」。
-        // 清单先算全，超上限整套拒绝（绝不删一半）。
-        const plan = await this.planCreatedRemovals(payload, sink);
+        if (selectionSkipped > 0) {
+            pushDetail(detail, 'selection-skipped=' + String(selectionSkipped) + ' selection=' + String(selection?.size ?? 0));
+        }
+        if (foreignSkipped > 0) {
+            pushDetail(detail, 'foreign-skipped=' + String(foreignSkipped) + ' (records written by other sessions after this point; not overwritten)');
+        }
+        if (mergedCount > 0)
+            pushDetail(detail, 'foreign-merged=' + String(mergedCount) + ' (reverted this session, kept the other side)');
+        if (conflictCount > 0)
+            pushDetail(detail, 'foreign-conflict=' + String(conflictCount) + ' (both sides changed the same place; needs a human)');
+        if (unavailableCount > 0)
+            pushDetail(detail, 'foreign-unavailable=' + String(unavailableCount) + ' (no safe way to revert; left untouched)');
+        if (concurrentCount > 0)
+            pushDetail(detail, 'concurrent-change=' + String(concurrentCount) + ' (changed again after the merge; left untouched)');
         const leftovers = {
             leftovers: plan.all.slice(0, ROLLBACK_LEFTOVER_LIST_LIMIT),
             truncated: plan.truncated,
@@ -3362,9 +3757,34 @@ export class RollbackPointEngine {
         };
         // 用户 2026-10-11 定案 A：把「回退点之后新建」的路径也退回去（删除）。
         // removeCreated !== true ⇒ 只报告（paths 清空）；判据仍是同一份 plan。
-        const removal = options.removeCreated === true
+        // 归属保护同样作用于**删除集**（2026-10-17 跨对话安全回退）：某路径若在留点之后被**别的会话**
+        // 写过，删它同样是在销毁别人的工作 ⇒ 拒删（进 createdSkipped；预览与执行共用同一份规划，
+        // 所以界面看到的「不会删」与执行端的「真的没删」仍然一致）。
+        const removalPlan = options.removeCreated === true
             ? { paths: plan.paths, skipped: plan.skipped, truncated: plan.truncated, refused: plan.refused }
             : { paths: [], skipped: [], truncated: false, refused: null };
+        const protectedRemovals = [];
+        if (mergeGuardEnabled && removalPlan.paths.length > 0) {
+            // 两类证据（任一成立就保护）：① 归属表明别的会话写过它；② **别的会话的回合点里记录过该路径**。
+            // 后者不依赖归属（归属可能因工具白名单 / 跨进程整体覆盖 / 采集时机而缺失，见 mergeGuardEnabled 的说明）。
+            const foreignPaths = await this.foreignRecordedPaths(track.capturedAt, isolationSessionId);
+            const keep = [];
+            for (const target of removalPlan.paths) {
+                const writer = this.attribution?.writerOf(target);
+                const byWriter = writer !== undefined && writer.sessionId !== isolationSessionId && writer.at > track.capturedAt;
+                if (byWriter || foreignPaths.has(pathKey(target))) {
+                    protectedRemovals.push(target);
+                    removalPlan.skipped.push(target);
+                    continue;
+                }
+                keep.push(target);
+            }
+            removalPlan.paths = keep;
+        }
+        const removal = removalPlan;
+        if (protectedRemovals.length > 0) {
+            pushDetail(detail, 'foreign-removal-protected=' + String(protectedRemovals.length) + ' (written by other sessions; not deleted)');
+        }
         if (removal.paths.length > ROLLBACK_MAX_CREATED_REMOVALS) {
             detail.push('created-removals=' + String(removal.paths.length) + ' limit=' + String(ROLLBACK_MAX_CREATED_REMOVALS) + ' zeroWrites=true');
             return {
@@ -3389,11 +3809,30 @@ export class RollbackPointEngine {
         // （否则工作区已与该点一致时也会重写全部文件，白耗 I/O 并抖动 mtime）。
         const needed = [];
         for (const item of writable) {
+            const targetSha = item.sha256 ?? item.file.sha256;
+            // 合并路径的**并发闸门**：写入前必须确认磁盘上仍是合并时读到的那一份
+            if (item.expectedCurrent !== undefined) {
+                let current = null;
+                try {
+                    current = sha256Hex(await fs.readFile(item.file.path));
+                }
+                catch {
+                    current = null;
+                }
+                if (current !== item.expectedCurrent) {
+                    concurrentCount += 1;
+                    if (concurrentPaths.length < ROLLBACK_LEFTOVER_LIST_LIMIT)
+                        concurrentPaths.push(item.file.path);
+                    pushDetail(detail, 'concurrent-change ' + item.file.path + ' zeroWrites=true');
+                    continue;
+                }
+            }
             let identical = false;
             try {
                 const stat = await fs.stat(item.file.path);
-                if (stat.isFile() && stat.size === item.file.bytes) {
-                    identical = sha256Hex(await fs.readFile(item.file.path)) === item.file.sha256;
+                // 长度比的是**这次要写进去的那份内容**（合并路径下它与记录里的原文长度不一定相同）
+                if (stat.isFile() && stat.size === item.bytes.byteLength) {
+                    identical = sha256Hex(await fs.readFile(item.file.path)) === targetSha;
                 }
             }
             catch {
@@ -3415,6 +3854,26 @@ export class RollbackPointEngine {
             noop.createdSkippedTruncated = removal.truncated || removal.skipped.length > ROLLBACK_LEFTOVER_LIST_LIMIT;
             if (removal.refused !== null)
                 noop.createdRefusedReason = removal.refused;
+            if (selectionSkipped > 0)
+                noop.selectionSkipped = selectionSkipped;
+            if (foreignSkipped > 0)
+                noop.foreignSkipped = foreignSkipped;
+            if (mergedCount > 0) {
+                noop.mergedCount = mergedCount;
+                noop.mergedPaths = mergedPaths;
+            }
+            if (conflictCount > 0) {
+                noop.conflictCount = conflictCount;
+                noop.conflictPaths = conflictPaths;
+            }
+            if (unavailableCount > 0) {
+                noop.unavailableCount = unavailableCount;
+                noop.unavailablePaths = unavailablePaths;
+            }
+            if (concurrentCount > 0) {
+                noop.concurrentCount = concurrentCount;
+                noop.concurrentPaths = concurrentPaths;
+            }
             return noop;
         }
         // 前像（**字节落盘、索引随栈**）：失败时要能整体回到恢复前状态 —— 只覆盖**真会被写**的文件。
@@ -3430,6 +3889,35 @@ export class RollbackPointEngine {
                 leftovers: leftovers.leftovers, leftoversTruncated: leftovers.truncated,
             };
         }
+        // **最终并发校验**（紧邻写入之前）：合并/预览之后文件可能又被改过。前一刻的 needed 判定与
+        // 真正写入之间还隔着前像暂存，所以这里再确认一次；不符的条目直接摘掉 ——
+        // 绝不覆盖比我们更新的内容。
+        if (needed.some((item) => item.expectedCurrent !== undefined)) {
+            const keep = [];
+            for (const item of needed) {
+                if (item.expectedCurrent === undefined) {
+                    keep.push(item);
+                    continue;
+                }
+                let current = null;
+                try {
+                    current = sha256Hex(await fs.readFile(item.file.path));
+                }
+                catch {
+                    current = null;
+                }
+                if (current !== item.expectedCurrent) {
+                    concurrentCount += 1;
+                    if (concurrentPaths.length < ROLLBACK_LEFTOVER_LIST_LIMIT)
+                        concurrentPaths.push(item.file.path);
+                    pushDetail(detail, 'concurrent-change ' + item.file.path + ' zeroWrites=true');
+                    continue;
+                }
+                keep.push(item);
+            }
+            needed.length = 0;
+            needed.push(...keep);
+        }
         const preCount = needed.length;
         for (const item of needed) {
             let bytes = null;
@@ -3487,7 +3975,8 @@ export class RollbackPointEngine {
             for (const item of needed) {
                 try {
                     const current = await this.readFileBytes(item.file.path);
-                    if (sha256Hex(current) !== item.file.sha256)
+                    // 合并路径写入的不是记录里的原文，而是合并结果 ⇒ 复核必须比**这次真正写进去的那份**
+                    if (sha256Hex(current) !== (item.sha256 ?? item.file.sha256))
                         mismatched.push(item.file.path);
                 }
                 catch {
@@ -3573,6 +4062,26 @@ export class RollbackPointEngine {
             createdSkippedTruncated: removal.truncated || removal.skipped.length > ROLLBACK_LEFTOVER_LIST_LIMIT,
             writtenBytes,
         };
+        if (selectionSkipped > 0)
+            segment.selectionSkipped = selectionSkipped;
+        if (foreignSkipped > 0)
+            segment.foreignSkipped = foreignSkipped;
+        if (mergedCount > 0) {
+            segment.mergedCount = mergedCount;
+            segment.mergedPaths = mergedPaths;
+        }
+        if (conflictCount > 0) {
+            segment.conflictCount = conflictCount;
+            segment.conflictPaths = conflictPaths;
+        }
+        if (unavailableCount > 0) {
+            segment.unavailableCount = unavailableCount;
+            segment.unavailablePaths = unavailablePaths;
+        }
+        if (concurrentCount > 0) {
+            segment.concurrentCount = concurrentCount;
+            segment.concurrentPaths = concurrentPaths;
+        }
         // 捕获不完整 ⇒ 一条都没删：如实回报原因（界面据此说「因为捕获不完整，一条都没动」）
         if (removal.refused !== null)
             segment.createdRefusedReason = removal.refused;
@@ -3918,6 +4427,7 @@ export class RollbackAutoTracker {
     pollIntervalMs;
     log;
     statSessionLog;
+    attribution;
     bindings = new Map();
     open = new Map();
     /**
@@ -3938,6 +4448,7 @@ export class RollbackAutoTracker {
         this.pollIntervalMs = Math.min(options.pollIntervalMs ?? ROLLBACK_DEFAULT_POLL_INTERVAL_MS, ROLLBACK_DEFAULT_POLL_INTERVAL_MS);
         this.log = options.log;
         this.statSessionLog = options.statSessionLog;
+        this.attribution = options.attribution;
     }
     /** 实际采用的留点机制（output / 诊断用） */
     get mechanismKind() {
@@ -4033,6 +4544,12 @@ export class RollbackAutoTracker {
                     endSeq: null,
                 });
             }
+            if (event.type === 'tool/call') {
+                // 写入归属（2026-10-17 定案 B）：**只记，不改任何留点行为**，也不 await 落盘
+                // （落盘由 attribution 自己 debounce；tool/call 洪峰不该在这里等 I/O）。
+                this.attribution?.noteToolCall(event.sessionId, event.data);
+                return { captured: false };
+            }
             if (event.type !== 'turn/end')
                 return { captured: false };
             // 回合结束只为「缺省边界」留个记号（轮询/无边界回退用它），不再拍点。