sillyspec 3.28.8 → 3.28.9

package/src/sync-noise.js

@@ -15,10 +15,13 @@
  * - 任意一次同步成功清 marker，且此前在闸内时打一行恢复提示；
  * - SILLYSPEC_DEBUG_SYNC=1 全程不静默。
  *
- * 边界：只覆盖「连接类」失败（HTTP 404/5xx、网络错、超时/abort）。409 冲突与其余
- * 4xx 业务态（平台就绪但状态冲突/鉴权问题）不走闸——那些是每轮都该看见的语义信号，
- * 且已有各自的冲突降噪机制（sync-conflict-banner-spam 一族）。用户显式命令
- * （platform connect 的 health ping）不应被静默——调用方传 noMute 绕过本闸。
+ * 边界：连接类闸只覆盖「连接类」失败（HTTP 404/5xx、网络错、超时/abort）。409 与其余
+ * 4xx 业务态（平台就绪但状态冲突/鉴权问题）不走连接类闸——那些是每轮都该看见的语义信号，
+ * 且已有各自的冲突降噪机制（sync-conflict-banner-spam 一族）。例外：409 code='change_deleted'
+ * 是终态幂等回执（平台侧已删该变更 key，重推永远同回执、永不自愈），走下方按变更名键控的
+ * change_deleted 闸（2026-09-14 用户反馈②）：首报可见 + 跨进程窗口静默 + 推送成功清窗。
+ * 用户显式命令（platform connect 的 health ping / platform sync 手动推送）不应被静默——
+ * 调用方传 noMute 绕过。
  */
 import { readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'fs'
 import { join } from 'path'
@@ -130,13 +133,116 @@ export function syncConnectionWarn(msg) {
 }
 
 /**
- * 判定 HTTP 状态码是否属连接类（可静默）：404（端点未部署/未就绪）与 5xx（服务端故障）。
+ * 判定 HTTP 状态码是否属连接类（可静默）：404（端点未就绪/未部署）与 5xx（服务端故障）。
  * 409 与其余 4xx 不在此列（见模块头注释边界）。
  */
 export function isConnectionClassStatus(status) {
   return status === 404 || (typeof status === 'number' && status >= 500)
 }
 
+// ── 变更级 change_deleted 回执噪音闸（2026-09-14 用户反馈②：--done 的真实报错被
+//    default 墓碑 409 回执刷屏淹没）──
+// 与连接类闸同构但按变更名键控。409 code='change_deleted' 是终态幂等回执：平台侧已删
+// 该变更 key 后，本地同名变更每次自动 push（每步 triggerSync/triggerStepStartSync）都收到
+// 同样的回执——多步流程下逐条重打属零新信息刷屏；且与 base_ts 409 不同，它永远不会自愈
+// （平台侧删除需人工介入）。语义边界（区别于连接类闸的「每轮都该看见」）：
+//   - 首报完整可见（含 ⚠️ 本地仍 active 的可行动信号）；
+//   - 跨进程窗口内同变更的回执静默（窗口过期后照常重报——保活信号，不静默死）；
+//   - 开窗进程内不同回执行照打（诊断完整性，与连接类闸同款）；
+//   - 该变更推送成功（平台侧重建/恢复）→ noteChangeDeletedResolved 清窗；
+//   - 手动 platform sync（opts.manual）与 SILLYSPEC_DEBUG_SYNC=1 旁路。
+const DELETED_MARKER = 'sync-noise-change-deleted.json'
+// 本进程开窗的变更名集合（区分「窗口是本进程开的」与「先前进程留的」，同 _openedByThisProcess）
+let _openedDeletedByThisProcess = new Set()
+// 本进程已见（打印/静默）过的 `${changeName}\u0000${msg}` 集合：同进程内逐字重复只打一次
+const _seenDeletedInProcess = new Set()
+
+function _readDeletedWindows() {
+  const p = _runtimeDir ? join(_runtimeDir, DELETED_MARKER) : null
+  if (!p) return null
+  try {
+    const s = JSON.parse(readFileSync(p, 'utf8'))
+    return s && typeof s === 'object' && !Array.isArray(s) ? s : null
+  } catch { return null }
+}
+
+function _writeDeletedWindows(map) {
+  const p = _runtimeDir ? join(_runtimeDir, DELETED_MARKER) : null
+  if (!p) return
+  try {
+    mkdirSync(_runtimeDir, { recursive: true })
+    const now = Date.now()
+    const pruned = {}
+    for (const [k, v] of Object.entries(map)) if (typeof v === 'number' && v > now) pruned[k] = v
+    if (Object.keys(pruned).length === 0) {
+      try { unlinkSync(p) } catch { /* 无文件/占用：留空 map 文件也等效 */ }
+      return
+    }
+    writeFileSync(p, JSON.stringify(pruned) + '\n', 'utf8')
+  } catch { /* marker 写失败 = 闸门失效退化为直通，仅损失降噪 */ }
+}
+
+function _deletedLineVisible(changeName, msg, noMute) {
+  if (!changeName || noMute || process.env.SILLYSPEC_DEBUG_SYNC) return true
+  const key = changeName + '\u0000' + msg
+  if (_seenDeletedInProcess.has(key)) return false
+  const now = Date.now()
+  const windows = _readDeletedWindows()
+  const until = windows ? windows[changeName] : undefined
+  if (typeof until === 'number' && now < until) {
+    _seenDeletedInProcess.add(key)
+    // 开窗进程内不同回执行可见（诊断完整性），先前进程留的窗口静默
+    return _openedDeletedByThisProcess.has(changeName)
+  }
+  _seenDeletedInProcess.add(key)
+  const next = windows || {}
+  next[changeName] = now + MUTE_WINDOW_MS
+  _writeDeletedWindows(next)
+  _openedDeletedByThisProcess.add(changeName)
+  return true
+}
+
+/**
+ * change_deleted 回执行（info 口吻：本地已注销的墓碑上行 409 属预期回执）。
+ * @returns {boolean} true=已输出
+ */
+export function syncChangeDeletedLog(changeName, msg, { noMute = false } = {}) {
+  if (_deletedLineVisible(changeName, msg, noMute)) {
+    console.log(msg)
+    return true
+  }
+  return false
+}
+
+/**
+ * change_deleted 回执行（warn 口吻：本地仍 active，上行被拒收的可行动信号）。
+ * @returns {boolean} true=已输出
+ */
+export function syncChangeDeletedWarn(changeName, msg, { noMute = false } = {}) {
+  if (_deletedLineVisible(changeName, msg, noMute)) {
+    console.warn(msg)
+    return true
+  }
+  return false
+}
+
+/**
+ * 该变更推送成功（平台侧未删/已重建）：清其回执噪音窗与进程内状态。
+ * 与 noteSyncSuccess 的「任意成功清连接闸」不同——本闸按变更名精清（他变更的窗口不受影响）。
+ */
+export function noteChangeDeletedResolved(changeName) {
+  if (!changeName) return
+  _openedDeletedByThisProcess.delete(changeName)
+  for (const k of _seenDeletedInProcess) {
+    if (k.startsWith(changeName + '\u0000')) _seenDeletedInProcess.delete(k)
+  }
+  const windows = _readDeletedWindows()
+  if (windows && windows[changeName] !== undefined) {
+    delete windows[changeName]
+    _writeDeletedWindows(windows)
+  }
+}
+
 /**
  * 任意一次同步成功：清 marker。此前处于闸内（marker 存在）时打一行恢复提示——
  * 平台恢复的第一个信号应该可见，之后的成功照常静默（成功不打扰）。
@@ -150,9 +256,11 @@ export function noteSyncSuccess() {
   console.log('[sync] 平台连接已恢复（此前静默的同步失败已停止）')
 }
 
-/** 测试复位：清进程内绑定与开窗状态。 */
+/** 测试复位：清进程内绑定与开窗状态（连接类闸 + change_deleted 变更级闸）。 */
 export function _resetSyncNoiseForTest() {
   _runtimeDir = null
   _openedByThisProcess = false
   _seenInProcess.clear()
+  _openedDeletedByThisProcess = new Set()
+  _seenDeletedInProcess.clear()
 }

package/src/sync.js

@@ -18,7 +18,7 @@ import { safeGit } from './git-helper.js';
 import { openDatabase } from './db-engine.js';
 import { PLATFORM_MANAGED_FILENAME, QUICK_SID_RE } from './run/shared.js';
 import { syncSpecTree } from './spec-sync.js';
-import { bindSyncNoiseFromCwd, syncConnectionWarn, isConnectionClassStatus, noteSyncSuccess } from './sync-noise.js';
+import { bindSyncNoiseFromCwd, syncConnectionWarn, isConnectionClassStatus, noteSyncSuccess, syncChangeDeletedLog, syncChangeDeletedWarn, noteChangeDeletedResolved } from './sync-noise.js';
 
 // sync 是 best-effort（网络失败只 warn）：平台指针失效时不抛，跳过平台、回退本地。
 function safePlatformSpecDir(cwd) {
@@ -595,7 +595,7 @@ export class SyncManager {
    * 外来推送（他机/他用户）不可能推进本机 DB 的 base_ts → 走原冲突路径，无误放行。
    */
   async sync(changeName, opts = {}) {
-    const { fromResolve = false } = opts;
+    const { fromResolve = false, manual = false } = opts;
     const platform = this._getPlatform();
     if (!platform) {
       debugLog('[sync] 未连接平台（本地合法状态）；如需平台同步：sillyspec platform connect');
@@ -615,8 +615,30 @@ export class SyncManager {
     if (!fromResolve) {
       const pendingConflict = this.readConflictFile(changeName);
       if (pendingConflict) {
-        console.warn(`⚠️ [sync] 变更 ${changeName} 存在未决平台冲突，跳过自动推送。处理：sillyspec platform resolve ${changeName} --keep-local | --take-platform | --abort`);
-        return { synced: 0, errors: [`conflict pending: ${changeName}`], conflict: true, suppressed: true };
+        // 过期自清（坑 sync-self-echo-false-conflict 附带，2026-09-14 实证 ctx-usage：base_ts 已被
+        // 后续 resolve/自愈推进到 ≥ 冲突文件记录的平台 ts——冲突条件早已消散，但文件残留仍压着
+        // 自动推送（「文件在即抑制」只认文件存在，永不重判）。此时清除文件继续推送是安全的：
+        // base ≥ 平台 ts 意味着本地已同步到冲突点之后，重推只会更新镜像不会丢数据。判不出
+        // （无平台 ts / DB 读失败）维持抑制，fail-closed。
+        const stalePlatTs = pendingConflict.platform_last_pushed_at || null;
+        let stale = false;
+        if (stalePlatTs) {
+          try {
+            const { ProgressManager } = await import('./progress.js');
+            const pm = new ProgressManager({ specDir: safePlatformSpecDir(this.cwd) });
+            const row = pm._ensureDB(this.cwd).getDb().prepare(
+              'SELECT last_synced_platform_ts FROM changes WHERE name = ?'
+            ).get(changeName);
+            if (row && row.last_synced_platform_ts && row.last_synced_platform_ts >= stalePlatTs) stale = true;
+          } catch { /* 判定失败维持抑制（fail-closed） */ }
+        }
+        if (stale) {
+          this.clearConflictFile(changeName);
+          console.warn(`⚠️ [sync] 变更 ${changeName} 的未决冲突已过期（base_ts ≥ 平台 ts=${stalePlatTs}），自动清除并恢复推送`);
+        } else {
+          console.warn(`⚠️ [sync] 变更 ${changeName} 存在未决平台冲突，跳过自动推送。处理：sillyspec platform resolve ${changeName} --keep-local | --take-platform | --abort`);
+          return { synced: 0, errors: [`conflict pending: ${changeName}`], conflict: true, suppressed: true };
+        }
       }
     }
 
@@ -634,7 +656,9 @@ export class SyncManager {
       // change-delete（2026-08-30）：DB status='deleted' 的行目录已随删除移除，属正常时序，
       // 单行 info 提示后继续推删除终态/墓碑（不落入「目录不存在」warn）
       if (this._changeDbStatus(changeName) === 'deleted') {
-        console.log(`[sync] 变更已删除（DB status=deleted），继续推送删除终态/墓碑: ${changeName}`);
+        // 变更级回执噪音闸（sync-noise.js change_deleted 闸）：status=deleted 是终态，此后每步
+        // 自动同步都会走到这里打同一行——首报后跨进程窗口内静默；手动 platform sync 旁路。
+        syncChangeDeletedLog(changeName, `[sync] 变更已删除（DB status=deleted），继续推送删除终态/墓碑: ${changeName}`, { noMute: manual });
       } else {
         archivedQuietly = existsSync(join(specBase, 'changes', 'archive', changeName))
           || this._changeDbStatus(changeName) === 'archived';
@@ -728,9 +752,10 @@ export class SyncManager {
           || progressData?.changes?.[0]?.status === 'archived'
           || progressData?.changes?.[0]?.status === 'deleted'
         if (localTombstone) {
-          console.log(`ℹ️ [sync] 平台已删除变更「${changeName}」——本地注销已由 CLI 完成，墓碑上行 409 属预期回执，无需动作`);
+          syncChangeDeletedLog(changeName, `ℹ️ [sync] 平台已删除变更「${changeName}」——本地注销已由 CLI 完成，墓碑上行 409 属预期回执，无需动作`, { noMute: manual });
         } else {
-          console.warn(`⚠️ [sync] 平台已删除变更「${changeName}」，本次进度上行被拒收（change_deleted）；本地如仍需推进请在平台侧确认`);
+          // 可行动信号（本地仍 active + 平台已删）：首报必须醒目，重复回执走变更级噪音闸
+          syncChangeDeletedWarn(changeName, `⚠️ [sync] 平台已删除变更「${changeName}」，本次进度上行被拒收（change_deleted）；本地如仍需推进请在平台侧确认`, { noMute: manual });
         }
         return { synced: 0, errors: [], platformDeleted: true, reason: '平台已删除（change_deleted 拒收）' };
       }
@@ -739,6 +764,8 @@ export class SyncManager {
         // 平台连接恢复信号（sync-noise.js）：此前静默窗口内的失败在恢复的第一笔成功时
         // 打一行提示并清 marker；之后照常「成功不打扰」。
         noteSyncSuccess();
+        // 该变更推送成功 = 平台侧未删/已重建，change_deleted 回执噪音窗按变更名精清
+        noteChangeDeletedResolved(changeName);
         // 更新 platform_last_sync + 推进 base_ts（ql-20260818-008：值优先平台回执 last_pushed_at，
         // 缺省用本次 pushedAt——服务器 _apply 存的就是客户端 X-SillySpec-Pushed-At 原值，回写一致。
         // 修复前该列从不写，下次 push 永不带 X-SillySpec-Base-Ts、pull 脏度检测恒 false）
@@ -809,6 +836,9 @@ export class SyncManager {
       // 平台 409 响应 { conflict:true, platform_progress, last_pushed_at }，platform_progress 即平台最新 progress JSON
       const platformProgress = res.body && res.body.platform_progress ? res.body.platform_progress : res.body;
       const platformLastPushedAt = (res.body && res.body.last_pushed_at) || null;
+      // 身份归属（ql-20260914 第二批）：服务端 409 body 回传平台行既有 last_pusher——
+      // 与本地 pushUser 同口径比对（platform.user || resolvePlatformUser，与发送侧一致）
+      const platformLastPusher = (res.body && res.body.last_pusher) || null;
 
       // 自竞态自愈：fresh 重读本机 DB base_ts，若已被并发进程回填到 ≥ 平台 409 回执 ts，
       // 说明赢者是本机自己人——刷新 base_ts 重试一次即收敛，不落冲突文件（外来推送不可能
@@ -838,6 +868,42 @@ export class SyncManager {
         }
       } catch { /* 比对失败维持原判（fail-closed 到真冲突分支） */ }
 
+      // ── 自回声归属（坑 sync-self-echo-false-conflict，2026-09-14 multi-agent-platform
+      // 实证 6 个假冲突全为此形；第二批升级身份优先）：平台快照自带 changes[0].
+      // last_local_modified_ts（推送方序列化时的本地脏度血统标记）。归属判定走
+      // _isSelfEchoAttribution——服务端回传 last_pusher 时身份优先（≠本人一律真冲突，
+      // ==本人仅保血统上界），身份缺失回退 [base_ts, local_modified] 双界窗口（窗口内
+      // = 本机自推过的状态：并发推送乱序/失败回填让 base 没跟上，自家回执被当他端
+      // 更新）。判为自回声 ⇒ 推进 base_ts 到平台 ts 后重试推送即收敛，不落冲突文件；
+      // 判为外来 ⇒ 维持原冲突路径：本地永不覆盖血统比自己新的平台状态。
+      if (!fromResolve && platformProgress && platformProgress.changes && platformProgress.changes[0]
+        && platformProgress.changes[0].last_local_modified_ts) {
+        const platLin = platformProgress.changes[0].last_local_modified_ts;
+        try {
+          const { ProgressManager } = await import('./progress.js');
+          const pm = new ProgressManager({ specDir: safePlatformSpecDir(this.cwd) });
+          const row = pm._ensureDB(this.cwd).getDb().prepare(
+            'SELECT last_local_modified_ts, last_synced_platform_ts FROM changes WHERE name = ?'
+          ).get(changeName);
+          const localMod = row && row.last_local_modified_ts;
+          const baseNow = row && row.last_synced_platform_ts;
+          if (this._isSelfEchoAttribution({
+            platformPusher: platformLastPusher, myPusher: pushUser,
+            platLin, baseTs: baseNow, localModified: localMod,
+          })) {
+            const healTs = platformLastPushedAt || pushedAt;
+            pm._ensureDB(this.cwd).getDb().prepare(
+              'UPDATE changes SET last_synced_platform_ts = MAX(?, COALESCE(last_synced_platform_ts, ?)) WHERE name = ?'
+            ).run(healTs, healTs, changeName);
+            console.warn(`⚠️ [sync] push 409 自回声判定：平台 ts=${platformLastPushedAt} 为本机自推回声（血统 ${platLin}，推送者 ${platformLastPusher || '未回传·窗口判定'}），base_ts 已推进到 ${healTs}，自动重推`);
+            if (attempt < MAX_PUSH_ATTEMPTS) continue;
+            // 重试额度耗尽（attempt=2 仍进此分支，理论少见）：不落冲突文件——base 已推进，
+            // 下次常规同步按新 base 直接推送收敛
+            return { synced: 0, errors: [], conflict: false, selfHealed: true, reason: 'push 409 自回声判定：base_ts 已推进，重试额度耗尽，下次常规同步收敛' };
+          }
+        } catch { /* 归属判定失败维持原判（fail-closed 到真冲突分支） */ }
+      }
+
       // resolve --keep-local 的自动重推再撞 409：不落新冲突文件、不打「已卡死」横幅——
       // 原 conflict 已按用户裁决处理完（base_ts 已推进），此刻的 409 只是「平台在用户裁决期间
       // 又动了」；立即落新文件会破坏「keep-local 清冲突文件回 clean」的生命周期契约（冲突文件
@@ -1193,6 +1259,14 @@ export class SyncManager {
         'last_active', 'last_synced_platform_ts', 'last_local_modified_ts',
         'started_at', 'completed_at', 'pushed_at', 'last_pushed_at', 'created_at',
         'deps_checked_at', 'checked_at', 'waited_at', 'completedat',
+        // last_pusher：服务端 GET 顶层回传的推送者元字段（ql-20260914 第二批）——与
+        // last_pushed_at 同理是同步元数据非六表内容，不忽略会让内容一致自愈恒 false。
+        'last_pusher',
+        // owner_session：所有权列（v6，2026-09-14-change-ownership-guards task-02）——与
+        // last_pusher 同理是归属元数据非六表内容：版本切换窗口（平台旧 v5 payload × 本地 v6
+        // 脏态）owner 差异会把内容一致判不等，部署噪声落人工 conflict（last_pusher 先例
+        // ql-20260914-006 同款一行）。
+        'owner_session',
       ]);
       const strip = (v) => {
         if (Array.isArray(v)) return v.map(strip);
@@ -1215,6 +1289,31 @@ export class SyncManager {
     } catch { return false }
   }
 
+  /**
+   * 自回声归属判定（坑 sync-self-echo-false-conflict 身份加固，2026-09-14 第二批）。
+   *
+   * 身份优先——服务端回传 last_pusher（409 body / GET 顶层，服务端 ql-20260914-006-e395
+   * 起；last_pushed_at 亦改存服务器权威钟）且本机 pushUser 可解析时：
+   * - pusher ≠ 本人 ⇒ 一律非自回声（外来否决）——堵跨机时钟偏差把他机更新伪装进
+   *   [base, local_modified] 血统窗口的盲区（慢钟他机的血统可落窗口内，但身份对不上）；
+   * - pusher == 本人 ⇒ 只保血统上界 platLin ≤ local_modified（永不覆盖血统比自己新的
+   *   平台状态——含本人另一台机器的新进度），下界放开（身份已证自家推送，老于 base
+   *   的快照也只是自家旧态，重推无损）。
+   * 任一侧身份缺失（老服务端不回传 / 本地 user 解析不出）⇒ 回退第一批双界窗口
+   * [baseTs, localModified]（纯时间血统，已是当时最优）。platLin 缺失一律 false
+   * （fail-closed：无血统不判自回声）。
+   * @param {{platformPusher?: string|null, myPusher?: string|null, platLin?: string|null, baseTs?: string|null, localModified?: string|null}} a
+   * @returns {boolean} true=判为本机自推回声（可推进 base_ts 重推本地）
+   */
+  _isSelfEchoAttribution({ platformPusher, myPusher, platLin, baseTs, localModified } = {}) {
+    if (!platLin || !localModified) return false;
+    if (platformPusher != null && myPusher != null) {
+      if (platformPusher !== myPusher) return false; // 身份否决：外来更新
+      return platLin <= localModified; // 本人推送：仅保上界
+    }
+    return !!(baseTs && platLin >= baseTs && platLin <= localModified); // 窗口回退
+  }
+
   _writeConflictFile(changeName, info = {}) {
     const specDir = safePlatformSpecDir(this.cwd);
     if (!specDir) return null;
@@ -1360,6 +1459,10 @@ export class SyncManager {
     // 平台响应：serializeForSync 六表 + 顶层 last_pushed_at（兼容 { progress: {...} } 包裹）
     const platformProgress = (result && result.project && result.changes) ? result : (result.progress || result);
     const platformPushedAt = (result && result.last_pushed_at) || null;
+    // 身份归属（ql-20260914 第二批）：服务端 GET 顶层回传 last_pusher（与发送侧同口径
+    // 的本机用户比对——platform.user || resolvePlatformUser）
+    const platformPusher = (result && result.last_pusher) || null;
+    const myPusher = (platform && platform.user) || resolvePlatformUser(this.cwd) || null;
 
     // 2. 本地脏度比对（非 force 时）：本地脏 AND 平台更新 → 冲突
     if (!force) {
@@ -1423,6 +1526,31 @@ export class SyncManager {
           }
         } catch { /* 比对失败维持原判（fail-closed 到真冲突分支） */ }
       }
+      // ── 自回声归属（坑 sync-self-echo-false-conflict，与 push 409 路径同族，2026-09-14；
+      // 第二批升级身份优先）：平台「更新」的血统标记（changes[0].last_local_modified_ts）
+      // 经 _isSelfEchoAttribution 判定——服务端回传 last_pusher 时身份优先（≠本人一律
+      // 真冲突；==本人仅保血统上界 ≤ local_modified），身份缺失回退 [base, local_modified]
+      // 双界窗口（本机自推回声：并发推送回填竞态窗口内读到自家回执）。判为自回声：
+      // 不 import、不落冲突文件，推进 base_ts 到平台 ts——本地内容 ≥ 回声状态，下次
+      // triggerSync 按新 base 正常推送，无损收敛。判为外来维持原冲突判定。
+      if (localDirty && platformNewer && platformProgress && platformProgress.changes
+        && platformProgress.changes[0] && platformProgress.changes[0].last_local_modified_ts) {
+        const platLin = platformProgress.changes[0].last_local_modified_ts;
+        if (this._isSelfEchoAttribution({
+          platformPusher: platformPusher, myPusher: myPusher,
+          platLin, baseTs: localLastSynced, localModified: localLastModified,
+        })) {
+          try {
+            const { ProgressManager } = await import('./progress.js');
+            const pm = new ProgressManager({ specDir: safePlatformSpecDir(this.cwd) });
+            pm._ensureDB(this.cwd).getDb().prepare(
+              'UPDATE changes SET last_synced_platform_ts = MAX(?, COALESCE(last_synced_platform_ts, ?)) WHERE name = ?'
+            ).run(platformPushedAt, platformPushedAt, changeName);
+          } catch { /* 推进失败不影响判定结论：不 import 不落冲突，下次同步重判 */ }
+          debugLog(`[sync] pull 自回声判定: 平台 ts ${platformPushedAt} 为本机自推回声（血统 ${platLin}，推送者 ${platformPusher || '未回传·窗口判定'}），base_ts 已推进`);
+          return { ok: true, imported: false, conflict: false, reason: '平台更新为本机自推回声（归属判定：身份/血统），base_ts 已推进' };
+        }
+      }
       if (localDirty && platformNewer) {
         console.warn('');
         console.warn('⚠️⚠️⚠️════════════════════════════════════════════════════');