sillyspec 3.28.7 → 3.28.9

package/src/sync.js

@@ -12,12 +12,13 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlink
 import { createHash } from 'crypto';
 import { writeAtomicSync } from './fs-atomic.js';
 import { join, dirname, basename, isAbsolute, relative } from 'path';
+import { homedir } from 'os';
 import { resolvePlatformSpecDir } from './progress.js';
 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) {
@@ -534,7 +535,20 @@ export class SyncManager {
    * 不删后两者则"disconnect 后恢复本地模式"不可达（指针健在时 resolvePlatformSpecDir
    * 仍解析平台 specRoot；声明健在时指针缺失会 fail-closed）。
    */
-  disconnect() {
+  disconnect(opts = {}) {
+    const { keepPointer = false } = opts
+    // 坑 platform-sync-progress-rollback-and-db-corruption 坑1③（2026-09-08 实证）：三清里的
+    // 指针/声明是 daemon 内嵌 CLI 的 specDir 解析依据——指针缺席期间 daemon 心跳读仓库
+    // .sillyspec（空）并把空状态推上平台，反而放大回滚。两道防线：
+    //   ① keepPointer（CLI `platform disconnect --keep-pointer`）：只清 local.yaml platform
+    //      段（自己 CLI 的同步断开），指针/声明保留给 daemon——回滚环恢复序列的正规化出口；
+    //   ② 默认三清前检测 daemon 主目录存在 → 醒目警告（在线 daemon 会失锚）。
+    const daemonHome = join(homedir(), '.sillyhub', 'daemon')
+    if (!keepPointer && existsSync(daemonHome)) {
+      console.warn(`⚠️ 检测到本机存在 SillyHub daemon（${daemonHome}）——三清将删除平台指针，daemon 内嵌 CLI 将失锚：`)
+      console.warn(`   指针缺席期间 daemon 心跳读仓库本地 .sillyspec（可能为空）并把空状态推上平台，会放大进度回滚。`)
+      console.warn(`   若只想断开自己 CLI 的同步（保留 daemon 锚点）：sillyspec platform disconnect --keep-pointer`)
+    }
     const p = join(this.cwd, LOCAL_YAML);
     if (existsSync(p)) {
       const text = readFileSync(p, 'utf8');
@@ -549,6 +563,10 @@ export class SyncManager {
         }
       }
     }
+    if (keepPointer) {
+      console.log('[sync] 已断开连接（--keep-pointer：仅清 local.yaml platform 段，指针与接管声明保留给 daemon 内嵌 CLI）');
+      return;
+    }
     // 三清之二/三：指针 + 接管声明（disconnect 是声明的唯一退出路径——design.md §5.4）。
     // HUB-12 有意不清 .sillyspec-platform-cleaned marker：它防的是「重新接入平台时 init
     // 重复做残留清理」——disconnect 后重连若清掉 marker，init 会对现在装着本地数据的
@@ -577,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');
@@ -597,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 };
+        }
       }
     }
 
@@ -616,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';
@@ -710,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 拒收）' };
       }
@@ -721,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）
@@ -791,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 重试一次即收敛，不落冲突文件（外来推送不可能
@@ -820,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」的生命周期契约（冲突文件
@@ -1175,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);
@@ -1197,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;
@@ -1342,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) {
@@ -1405,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('⚠️⚠️⚠️════════════════════════════════════════════════════');
@@ -1723,7 +1869,51 @@ export class SyncManager {
     const cf = this.readConflictFile(changeName);
     const specCf = this.readSpecConflictFile(changeName);
     if (!cf && !specCf) {
-      return { ok: false, resolved: false, reason: `无可解决冲突: ${changeName}（无 sync-conflict / spec-sync-conflict 文件）` };
+      // 坑 platform-sync-progress-rollback-and-db-corruption 坑1②（2026-09-08 实证）：回滚环
+      // 中间态——冲突文件已被某次常规同步静默清除，但 DB 的 base_ts 仍落后，keep-local
+      // 找不到裁决目标被拒（「无可解决冲突」），恢复序列被迫走人肉 SQL。显式出口：keep-local
+      // 在无冲突文件时降级为「无冲突强推」——拉平台 last_pushed_at 推进 base_ts（与有冲突
+      // 路径同款 MAX/COALESCE 单调 SQL）+ 自动重推闭环，等价完成裁决意图。take-platform
+      // 依赖冲突文件里的 platform_progress 快照，无文件时仍拒绝（无可覆盖源）。
+      if (mode !== 'keep-local') {
+        return { ok: false, resolved: false, reason: `无可解决冲突: ${changeName}（无 sync-conflict / spec-sync-conflict 文件）` };
+      }
+      const platform = this._getPlatform();
+      if (!platform) {
+        return { ok: false, resolved: false, reason: `无可解决冲突且未连接平台: ${changeName}——keep-local 无冲突强推需拉平台 last_pushed_at` };
+      }
+      let pushedAt = null;
+      try {
+        const res = await fetchJson(
+          `${platform.url}/api/changes/${encodeURIComponent(changeName)}/progress`,
+          { headers: { Authorization: `Bearer ${platform.token}` } },
+        );
+        pushedAt = (res && res.last_pushed_at) || null;
+      } catch { /* 拉取失败按 null：仅跳过 base_ts 推进，重推仍可尝试 */ }
+      if (pushedAt) {
+        try {
+          const { ProgressManager } = await import('./progress.js');
+          const pm = new ProgressManager({ specDir: safePlatformSpecDir(this.cwd) });
+          const db = pm._ensureDB(this.cwd).getDb();
+          db.prepare('UPDATE changes SET last_synced_platform_ts = MAX(COALESCE(?, last_synced_platform_ts), COALESCE(last_synced_platform_ts, ?)) WHERE name = ?')
+            .run(pushedAt, pushedAt, changeName);
+        } catch (err) {
+          return { ok: false, resolved: false, reason: `无冲突 keep-local 推进 base_ts 失败: ${err.message}` };
+        }
+      }
+      let repush = null;
+      try {
+        repush = await this.sync(changeName, { fromResolve: true });
+      } catch (err) {
+        debugLog(`[sync] 无冲突 keep-local 重推异常: ${changeName}: ${err.message}`);
+      }
+      if (repush && repush.synced === 1) {
+        return { ok: true, resolved: true, mode: 'keep-local-noconflict', reason: '无冲突显式 keep-local：base_ts 已对齐平台最新，本地已重推——回滚环收敛出口' };
+      }
+      if (repush && repush.conflict) {
+        return { ok: true, resolved: true, mode: 'keep-local-noconflict', reason: '无冲突显式 keep-local：base_ts 已推进；重推被拒（平台刚又有更新，已落冲突文件）——再跑一次 resolve --keep-local 即可' };
+      }
+      return { ok: true, resolved: true, mode: 'keep-local-noconflict', reason: '无冲突显式 keep-local：base_ts ' + (pushedAt ? '已推进' : '未获取（平台拉取失败）') + '；重推未成功（未连接/网络），请手动 sillyspec platform sync --change ' + changeName };
     }
     const platformPushedAt = (cf && cf.platform_last_pushed_at) || null;
 
@@ -1954,8 +2144,8 @@ export async function connect(url, token, cwd) {
   return new SyncManager(cwd).connect(url, token);
 }
 
-export async function disconnect(cwd) {
-  return new SyncManager(cwd).disconnect();
+export async function disconnect(cwd, opts = {}) {
+  return new SyncManager(cwd).disconnect(opts);
 }
 
 export async function sync(changeName, cwd, opts) {