dsh-config-manager 0.1.76 → 0.1.78

package/src/core/rollback-point.ts

@@ -73,6 +73,8 @@ import { EXCLUDED_DEP_DIR_NAMES } from '../utils/recursive-walk.ts'
 import { diffLines, type DiffHunk } from '../utils/line-diff.ts'
 import { projectKeyOf } from './session-select.ts'
 import { ignoreRelativePath, ignoreRuleMatches, loadIgnoreRules, type IgnoreRules } from './rollback-ignore-rules.ts'
+import type { RollbackWriteAttributionPort, RollbackWriteFact, RollbackWriteRecorder } from './rollback-attribution.ts'
+import { mergeThreeWay } from './rollback-merge.ts'
 import { isSessionLogName } from '../utils/session-log.ts'
 import { decodeZstdFrame, scanZstdFrames, zstdAvailable, ZSTD_MAGIC } from '../utils/zstd-frame.ts'
 import {
@@ -746,6 +748,23 @@ export interface RollbackPreviewFile {
    * **宁可说「不知道」，也绝不谎报行数。**
    */
   truncated: boolean
+  /**
+   * true = 该文件在留点**之后**是**别的会话**写的（写入归属台账证明；见 core/rollback-attribution.ts）。
+   * 界面据此默认不勾选它（用户仍可勾上）。缺字段 / false = **没有归属证据**，
+   * 而不是「本会话写的」——「未判定」与「确知是本会话」必须分开。
+   */
+  foreign?: boolean
+  /** 那些「别的会话」的会话 id（仅当 foreign 为 true） */
+  foreignSessionId?: string
+  /** 那次写入的时间（毫秒；仅当 foreign 为 true） */
+  foreignAt?: number
+  /**
+   * true = 这次回退**不会改动它**：要么与其它对话的改动冲突、要么无法安全合并（缺共同祖先 / 二进制 /
+   * 差异被降级 / 对方删了它）。行级统计一律为 null —— 「不改动」不是「0 行变化」。
+   */
+  skipped?: boolean
+  /** 不改动的机器原因（界面映射成字典键，绝不裸渲染） */
+  mergeReason?: string
 }
 
 /** 单文件差异里一侧（当前磁盘 / 回退点快照）的展示信息。 */
@@ -790,6 +809,15 @@ export interface RollbackFileDiffResult {
   degraded: boolean
   /** 无法逐行对比的原因（有值时 hunks 为空） */
   reason?: RollbackFileDiffReason
+  /** true = 「回退后」一侧显示的是**三方合并**的结果，而不是记录里的原文 */
+  merged?: boolean
+  /**
+   * true = 这次回退**不会改动**它（与其它对话的改动冲突 / 无法安全合并）—— 此时 after 与 before 相同。
+   * 界面必须把「不会改动」与「0 行变化」分开说。
+   */
+  mergeSkipped?: boolean
+  /** 不改动的机器原因（界面映射成字典键，绝不裸渲染） */
+  mergeReason?: string
   limits: typeof ROLLBACK_FILE_DIFF_LIMITS
 }
 
@@ -964,6 +992,28 @@ export interface RollbackSegmentResult {
    */
   createdRefusedReason?: 'capture-incomplete'
   writtenBytes?: number
+  /**
+   * 因路径选择（onlyPaths）而未恢复 / 未删除的条目数。
+   * 与 createdSkipped（安全拒删）**分开**：这里的原因是用户自己没勾它，不是安全判据挡下。
+   */
+  selectionSkipped?: number
+  /**
+   * 因**归属隔离**（2026-10-17 定案 B）而跳过的记录条目数：该文件在留点之后是**别的会话**写的。
+   * 只在**没有显式点名**（`onlyPaths` 缺省）时生效；显式点名 = 用户明确要它，归属不再拦。
+   */
+  foreignSkipped?: number
+  /** 三方合并成功、写回「撤销本会话 + 保留对方改动」的条目数（有界清单同给） */
+  mergedCount?: number
+  mergedPaths?: string[]
+  /** 冲突：两侧改到同一处 ⇒ **未写**，交给用户处理 */
+  conflictCount?: number
+  conflictPaths?: string[]
+  /** 无法安全撤销（无中间版本 / 二进制 / 差异被降级 / 对方改成了不存在）⇒ **未写** */
+  unavailableCount?: number
+  unavailablePaths?: string[]
+  /** 写入前发现又被改过（并发）⇒ **未写** */
+  concurrentCount?: number
+  concurrentPaths?: string[]
   /** 会话段：fork 出来的子会话 id */
   childSessionId?: string
   guidance?: RollbackGuidance[]
@@ -984,6 +1034,16 @@ export interface RollbackRewindInput {
    * （把已写回的文件还原、把已删的文件写回）。拒删判据见 createdRemovalRefusal。
    */
   removeCreated?: boolean
+  /**
+   * **路径级选择性恢复**（2026-10-17 用户定案 A）：只恢复 / 只删除这些路径。
+   *
+   * 缺省（undefined）= 既有全量口径，行为一字不变。给了值就：
+   *  · 记录在案的文件里**不在**清单中的：不写（计入 selectionSkipped）；
+   *  · 「留点后新建」的候选里**不在**清单中的：不删（同样计入）。
+   * 清单里出现**既未记录、也不在删除候选**里的路径 ⇒ **fail-closed 拒绝、零写入**（invalid-input）：
+   * 绝不把「用户打错一个路径」变成「静默少恢复几个文件」。
+   */
+  onlyPaths?: readonly string[]
 }
 
 export interface RollbackRewindResult {
@@ -1008,6 +1068,11 @@ export type RollbackStorageProbe = () => Promise<{ ok: true } | { ok: false; det
 export interface RollbackEngineOptions {
   /** 插件数据目录（= $DSH_HOME/dsh-config-manager）；回滚点库在 dataDir/rollback-points */
   dataDir: string
+  /**
+   * 写入归属台账（2026-10-17 用户定案 B）。缺省 = 没有归属信息 ⇒ 预览不标 foreign，
+   * 回退行为与旧版**逐字一致**（未判定绝不当作「别的会话写的」）。
+   */
+  attribution?: RollbackWriteAttributionPort
   /** DSH home（会话根 = homeDir/sessions） */
   homeDir: string
   now?: () => number
@@ -1787,6 +1852,8 @@ export class RollbackPointEngine {
   private ledgerSnapshotCache: { at: number; entries: RollbackLedgerManifestEntry[] } | null = null
   /** 台账存储层（v3：清单 + 单条记录 + 内容寻址载荷；issue #89） */
   private readonly ledger: RollbackLedger
+  /** 写入归属（2026-10-17 定案 B）。undefined = 没有归属信息 ⇒ 预览不标 foreign */
+  private readonly attribution: RollbackWriteAttributionPort | undefined
   private readonly ledgerBytesBudget: number
   /**
    * 工作区捕获的挂钟时间预算（毫秒；见 ROLLBACK_DEFAULT_CAPTURE_BUDGET_MS）。**可变**：
@@ -1843,6 +1910,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
@@ -3668,6 +3736,36 @@ export class RollbackPointEngine {
     return { added: counts.added, removed: counts.removed, truncated: false }
   }
 
+  /**
+   * **合并结果**的逐文件行级统计（与 `previewFileCounts` 同一套预算与降级判据）。
+   *
+   * 为什么单独一份：合并后要写进去的内容既不是记录里的原文（ours），也不是磁盘现状（theirs）——
+   * 预览若照旧拿 ours 算差异，就会把「其实会被保留的对方改动」显示成「会被删掉」。
+   */
+  private async previewMergeCounts(
+    targetBytes: Uint8Array,
+    current: Uint8Array,
+    budget: { bytes: number; work: number },
+  ): Promise<{ added: number | null; removed: number | null; truncated: boolean }> {
+    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: string): Promise<RollbackPreviewResult> {
     const storage = await this.storageStatus()
@@ -3720,8 +3818,21 @@ export class RollbackPointEngine {
       let missing = 0
       // E1：逐文件行级统计 —— **只列会被改动的文件**（内容已一致的一个都不列）
       const changedFiles: RollbackPreviewFile[] = []
+      // 写入归属（2026-10-17 定案 B）：只有**确知**最后写入者是别的会话、且写入发生在留点**之后**时，
+      // 才敢标 foreign。缺归属 / 归属就是本会话 / 写入早于留点 ⇒ 一律不标
+      // （未判定 ≠ 别的会话写的；宁可少标一次，也不误判一次）。
+      const foreignWriterOf = (target: string): RollbackWriteFact | undefined => {
+        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<string, string | null>()
       // T10：stat 的三种结局分开表达 —— 「不存在（ENOENT）」与「存在性未知（其它 errno）」绝不混为一谈
       const previewFiles = wsPayload.files
       // 阶段 A（**并发**）：逐条一次 bigint lstat + 身份快路径。大仓库这里是预览的大头：
@@ -3759,7 +3870,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
         }
         // 身份快路径已证明「与记录一致」⇒ 一个字段都不改（内容一致的文件不列进列表）
@@ -3778,10 +3894,37 @@ export class RollbackPointEngine {
           }
         }
         if (sizeMatches && current !== null && sha256Hex(current) === file.sha256) continue
+        // **合并判定与执行同口径**（2026-10-17 修）：预览必须说清「这次到底会写成什么」。
+        // 之前预览只按「覆盖回记录版本」算差异，而执行端会先做三方合并 ⇒ 预览把对方后来的行
+        // 也算成「会被删掉」，用户据此以为会丢别人的改动（真机：两行描述都显示要删，实际只删 A 那行）。
+        const decision = await (async (): Promise<{ mode: 'overwrite' | 'merged' | 'skip' | 'unchanged'; bytes?: Uint8Array; reason?: string }> => {
+          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: ChunkWalkSink = { skipped: [], excludedDirs: [], ignoredDirs: [], ignoredDirCount: 0, unreadableDirs: [], skippedCount: 0, skippedTruncated: false }
@@ -3929,6 +4072,36 @@ export class RollbackPointEngine {
       else currentUnreadable = true
     }
 
+    // **合并判定与执行同口径**（2026-10-17 修）：「回退后」一侧必须显示这次**真正会写进去**的内容。
+    // 以前它恒定显示记录里的原文（= 整文件覆盖的样子），于是预览列表写着「+0 −2」，点开「查看差异」
+    // 却还是「−1,4 +1,1」—— 同一件事两个说法（真机 2026-10-17 用户当场发现）。
+    let mergedAfter: Uint8Array | null = null
+    /** true 只表示「after 侧真的是合并算出来的」——「不会改动」时 after 也是现状，但不算合并 */
+    let mergedFlag = false
+    let mergeSkippedReason: string | null = 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: Uint8Array | null = mergedAfter ?? snapshot
     const before: RollbackFileDiffSide = {
       exists: currentExists, bytes: currentBytes, lines: null,
       binary: false, oversized: currentOversized, unreadable: currentUnreadable,
@@ -3938,17 +4111,19 @@ export class RollbackPointEngine {
       before.lines = before.binary ? null : splitDiffLines(DIFF_TEXT_DECODER.decode(current)).length
     }
     const after: RollbackFileDiffSide = {
-      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: RollbackFileDiffResult = {
       ...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) return { ...view, reason: 'too-large' }
@@ -3958,7 +4133,7 @@ export class RollbackPointEngine {
     if (before.binary || after.binary) return { ...view, reason: 'binary' }
     const result = diffLines(
       current === null ? '' : DIFF_TEXT_DECODER.decode(current),
-      DIFF_TEXT_DECODER.decode(snapshot),
+      afterBytes === null ? '' : DIFF_TEXT_DECODER.decode(afterBytes),
       { context: ROLLBACK_FILE_DIFF_LIMITS.context, maxD: ROLLBACK_FILE_DIFF_LIMITS.maxD },
     )
     return {
@@ -4073,7 +4248,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) childSessionId = segment.childSessionId
@@ -4149,9 +4327,162 @@ export class RollbackPointEngine {
     return null
   }
 
+  /**
+   * 把一条「留点之后被**别的会话**写过」的记录做成三方合并结果（2026-10-17 跨对话安全回退）。
+   *
+   * 三方：`ours` = 记录里的内容（回退目标）、`base` = 目标点之后**最早**那份中间版本、
+   * `theirs` = 当前磁盘。结果是「撤销本会话那次改动 + 保留对方后来的改动」。
+   *
+   * 返回：`write`（合并干净且确实要写，带目标哈希 + 期望的当前哈希）、
+   * `unchanged`（合并结果就是当前内容 —— 对方没动这一处，本来就不需要写）、
+   * `blocked`（不能安全处理：冲突 / 没有中间版本 / 二进制 / 差异被降级 / 对方改成了不存在 / 读不出）。
+   */
+  private async mergeForeignRecord(
+    file: RollbackWorkspaceFile,
+    baseText: string | null,
+    foreignEvidence: boolean,
+  ): Promise<
+    | { kind: 'write'; bytes: Uint8Array; sha256: string; expectedCurrent: string }
+    | { kind: 'unchanged' }
+    | { kind: 'blocked'; reason: 'conflict' | 'no-base' | 'ambiguous' | 'binary' | 'degraded' | 'theirs-missing' | 'theirs-unreadable' | 'ours-unreadable' }
+    /** 没有可用祖先、也没有「别人写过」的旁证 ⇒ 退回旧口径（整文件覆盖回目标版本） */
+    | { kind: 'fallback' }
+  > {
+    let oursBytes: Uint8Array
+    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: Uint8Array
+    try {
+      theirsBytes = await fs.readFile(file.path)
+    } catch (error) {
+      return { kind: 'blocked', reason: (error as { code?: unknown }).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 = 整文件覆盖，正是本机制要消灭的形态）、
+   * **本会话的点**（见上）、以及内容读不出来的点（继续往后找 —— 找不到 ⇒ 调用方按「无法安全撤销」
+   * 处理，绝不用近似值代替）。
+   */
+  private async baseVersionFor(target: string, afterAt: number, excludeSessionId: string | null): Promise<string | null> {
+    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` 个别的会话的点（按时间升序），且只读路径不读内容。
+   * 扫不完不影响安全方向（少保护也会被归属那条兜一部分），但绝不因此声称「已扫全」。
+   */
+  private async foreignRecordedPaths(afterAt: number, excludeSessionId: string | null, limit = 10): Promise<Set<string>> {
+    const out = new Set<string>()
+    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 as
+        | (RollbackWorkspacePayload & { delta?: { added?: unknown; removed?: unknown } })
+        | null
+        | undefined
+      if (payload === null || payload === undefined) continue
+      const files = (payload as { files?: unknown }).files
+      if (Array.isArray(files)) {
+        for (const item of files) {
+          const target = (item as { path?: unknown }).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 as { path?: unknown } | null)?.path
+          if (typeof target === 'string' && target !== '') out.add(pathKey(target))
+        }
+      }
+    }
+    return out
+  }
+
   private async restoreWorkspace(
     track: RollbackTrack<RollbackWorkspacePayload>,
-    options: { removeCreated?: boolean } = {},
+    options: { removeCreated?: boolean; onlyPaths?: readonly string[]; sessionId?: string } = {},
   ): Promise<RollbackSegmentResult> {
     const payload = track.payload
     if (!track.ok || payload === null) {
@@ -4162,11 +4493,78 @@ export class RollbackPointEngine {
     // （界面据此说「该点没记录文件」而不是「工作区已与该点一致」）。
     if (payload.files.length === 0) return this.noopSegment('workspace', 'no-recorded-files', 'files=0 nothingToDo=true')
     const detail: string[] = []
-    const writable: { file: RollbackWorkspaceFile; bytes: Uint8Array }[] = []
+    // 路径级选择性恢复（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<string, string | null>()
+    const sink: ChunkWalkSink = { 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<string>()
+      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: { file: RollbackWorkspaceFile; bytes: Uint8Array; sha256?: string; expectedCurrent?: string }[] = []
     let failed = 0
     // 「已与记录一致」的条目数（身份快路径证明）—— 后面「0 变更」的文案与统计要用
     let unchanged = 0
+    /** 三方合并成功、写回「撤销本会话 + 保留对方改动」结果的条目数 */
+    let mergedCount = 0
+    /** 冲突：两侧改到同一处 ⇒ 绝不自动选边，交给用户 */
+    let conflictCount = 0
+    /** 无法安全撤销：没有中间版本 / 二进制 / 差异被降级 / 对方把它改成了不存在 */
+    let unavailableCount = 0
+    /** 写入前发现文件又被改过（并发）⇒ 放弃写入 */
+    let concurrentCount = 0
+    const mergedPaths: string[] = []
+    const conflictPaths: string[] = []
+    const unavailablePaths: string[] = []
+    const concurrentPaths: string[] = []
     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)) {
@@ -4192,16 +4590,66 @@ export class RollbackPointEngine {
           pushDetail(detail, 'object-hash-mismatch ' + file.path)
           continue
         }
+        // **合并保护**（2026-10-17 修）：到这里才确认「这个文件确实需要写」，也才值得去查共同祖先。
+        // 触发不吃归属：只要目标点之后存在**别的会话**的回合点（那它就是共同祖先），就走三方合并。
+        if (mergeGuardEnabled) {
+          let base: string | null
+          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) {
         failed += 1
         pushDetail(detail, 'object-missing ' + file.path + ' ' + errorDetail(error))
       }
     }
-    const sink: ChunkWalkSink = { 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,
@@ -4209,9 +4657,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: [] as string[], skipped: [] as string[], truncated: false, refused: null as CreatedRemovalPlan['refused'] }
+    const protectedRemovals: string[] = []
+    if (mergeGuardEnabled && removalPlan.paths.length > 0) {
+      // 两类证据（任一成立就保护）：① 归属表明别的会话写过它；② **别的会话的回合点里记录过该路径**。
+      // 后者不依赖归属（归属可能因工具白名单 / 跨进程整体覆盖 / 采集时机而缺失，见 mergeGuardEnabled 的说明）。
+      const foreignPaths = await this.foreignRecordedPaths(track.capturedAt, isolationSessionId)
+      const keep: string[] = []
+      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 {
@@ -4234,13 +4707,30 @@ export class RollbackPointEngine {
     }
     // E1：内容已与快照一致的条目**不再写** —— 「0 变更」就要是真的 0 次写入
     // （否则工作区已与该点一致时也会重写全部文件，白耗 I/O 并抖动 mtime）。
-    const needed: { file: RollbackWorkspaceFile; bytes: Uint8Array }[] = []
+    const needed: { file: RollbackWorkspaceFile; bytes: Uint8Array; sha256?: string; expectedCurrent?: string }[] = []
     for (const item of writable) {
+      const targetSha = item.sha256 ?? item.file.sha256
+      // 合并路径的**并发闸门**：写入前必须确认磁盘上仍是合并时读到的那一份
+      if (item.expectedCurrent !== undefined) {
+        let current: string | null = 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 {
         identical = false
@@ -4260,6 +4750,12 @@ export class RollbackPointEngine {
       noop.createdSkippedCount = removal.skipped.length
       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
     }
     // 前像（**字节落盘、索引随栈**）：失败时要能整体回到恢复前状态 —— 只覆盖**真会被写**的文件。
@@ -4275,6 +4771,30 @@ export class RollbackPointEngine {
         leftovers: leftovers.leftovers, leftoversTruncated: leftovers.truncated,
       }
     }
+    // **最终并发校验**（紧邻写入之前）：合并/预览之后文件可能又被改过。前一刻的 needed 判定与
+    // 真正写入之间还隔着前像暂存，所以这里再确认一次；不符的条目直接摘掉 ——
+    // 绝不覆盖比我们更新的内容。
+    if (needed.some((item) => item.expectedCurrent !== undefined)) {
+      const keep: typeof needed = []
+      for (const item of needed) {
+        if (item.expectedCurrent === undefined) { keep.push(item); continue }
+        let current: string | null = 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: Uint8Array | null = null
@@ -4328,7 +4848,8 @@ export class RollbackPointEngine {
       for (const item of needed) {
         try {
           const current = await this.readFileBytes(item.file.path)
-          if (sha256Hex(current) !== item.file.sha256) mismatched.push(item.file.path)
+          // 合并路径写入的不是记录里的原文，而是合并结果 ⇒ 复核必须比**这次真正写进去的那份**
+          if (sha256Hex(current) !== (item.sha256 ?? item.file.sha256)) mismatched.push(item.file.path)
         } catch {
           mismatched.push(item.file.path)
         }
@@ -4411,6 +4932,12 @@ 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
     // 前像字节用完即清（成功路径）：留在磁盘上只会变成无人认领的残留
@@ -4646,6 +5173,11 @@ export interface RollbackTrackerOptions {
   log?: (line: string) => void
   /** 会话日志 stat 探针（轮询回退用） */
   statSessionLog?: (logPath: string) => Promise<{ size: number; mtimeMs: number } | undefined>
+  /**
+   * 写入归属采集器（2026-10-17 定案 B）。缺省 = 不采集 ⇒ 预览永远没有 foreign 标记，
+   * 回退行为与旧版**逐字一致**。
+   */
+  attribution?: RollbackWriteRecorder
 }
 
 export interface RollbackTrackerResult {
@@ -4825,6 +5357,7 @@ export class RollbackAutoTracker {
   private readonly pollIntervalMs: number
   private readonly log: ((line: string) => void) | undefined
   private readonly statSessionLog: ((logPath: string) => Promise<{ size: number; mtimeMs: number } | undefined>) | undefined
+  private readonly attribution: RollbackWriteRecorder | undefined
   private readonly bindings = new Map<string, RollbackSessionBinding>()
   private readonly open = new Map<string, { turn: number | null; startSeq: number; boundarySeq: number | null }>()
   /**
@@ -4849,6 +5382,7 @@ export class RollbackAutoTracker {
     )
     this.log = options.log
     this.statSessionLog = options.statSessionLog
+    this.attribution = options.attribution
   }
 
   /** 实际采用的留点机制（output / 诊断用） */
@@ -4948,6 +5482,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 }
       // 回合结束只为「缺省边界」留个记号（轮询/无边界回退用它），不再拍点。
       this.open.delete(event.sessionId)