sillyspec 3.28.8 → 3.28.10

package/src/stages/plan-postcheck.js

@@ -785,12 +785,19 @@ export function parseLocalYamlModules(yamlText) {
  * modules 从 local.yaml 提取（monorepo 子包感知）：无 modules 块时仅查根 package.json
  * （与 scan-postcheck 历史行为一致）；有 modules 块时多候选子包 package.json 任一命中即通过。
  *
+ * 跨仓卡基准根切换（坑 verify-cmd-cross-repo-root，2026-09-15 wp 会话实证）：卡片声明
+ * repo: <key> 时其 verify/implementation 里的路径相对**该仓**根——此前恒用主仓 projectRoot，
+ * 跨仓卡的 `cd src && npm run lint`（src 在跨仓里）解析到主仓 → 误报死命令。repoRegistry
+ * 命中该 key 时以跨仓根为该卡的 projectRoot（modules 是主仓 local.yaml 的相对子包路径，
+ * 跨仓卡不适用，置 null）；repo 未注册时由检查 1 的注册校验报错，此处维持主仓根不重复报。
+ *
  * @param {string} changeDir - 变更目录
  * @param {string} projectRoot - 项目根目录（package.json 查找基准）
  * @param {object|null} modules - local.yaml modules 块（{ name: { path } }），可选
+ * @param {Map<string,string>|null} [repoRegistry=null] - local.yaml repos: 段（跨仓卡基准根解析）
  * @returns {{ ok: boolean, errors: string[], warnings: string[] }}
  */
-export function validateTaskCommands(changeDir, projectRoot, modules = null) {
+export function validateTaskCommands(changeDir, projectRoot, modules = null, repoRegistry = null) {
   const errors = []
   const warnings = []
 
@@ -826,7 +833,16 @@ export function validateTaskCommands(changeDir, projectRoot, modules = null) {
     const text = `${verifyText}\n${implText}`
     if (!text.trim()) continue
 
-    const { invalid } = validateScriptCommands(text, { projectRoot, modules })
+    // 跨仓卡基准根切换（坑 verify-cmd-cross-repo-root）：repo: 命中注册表 → 该卡命令以跨仓
+    // 根解析；modules（主仓相对子包路径）对跨仓卡不适用置 null
+    const cardRepo = parseRepo(content)
+    let cardRoot = projectRoot
+    let cardModules = modules
+    if (cardRepo && cardRepo !== 'main' && repoRegistry && repoRegistry instanceof Map && repoRegistry.has(cardRepo)) {
+      cardRoot = repoRegistry.get(cardRepo)
+      cardModules = null
+    }
+    const { invalid } = validateScriptCommands(text, { projectRoot: cardRoot, modules: cardModules })
     for (const inv of invalid) {
       errors.push(`${taskId}: ${inv.cmd} 命令不存在（${inv.reason}）`)
     }
@@ -880,7 +896,7 @@ const FILE_LIST_SECTION_RE = /^#{2,3}\s*(?:\d+[.)]\s*)?(文件变更清单|变
  * @param {string} designPath - design.md 绝对路径
  * @returns {{ byRepo: Map<string, Set<string>>, hasSegmentHeader: boolean, allFiles: string[], malformedHeaders: string[] }}
  */
-function parseDesignCoverageByRepo(designPath) {
+export function parseDesignCoverageByRepo(designPath) {
   const byRepo = new Map()
   const allFiles = []
   const malformedHeaders = []
@@ -1619,10 +1635,21 @@ export async function executePlanPostcheck(context) {
   let taskModules = null
   let repoRegistry = null
   if (existsSync(localYamlPath)) {
-    const localYamlText = readFileSync(localYamlPath, 'utf8')
+    const localYamlText = _readFileSync(localYamlPath, 'utf8')
     taskModules = parseLocalYamlModules(localYamlText)
     repoRegistry = parseRepoRegistry(localYamlText)
   }
+  // 坑 register-repo-specbase-split-brain（读侧对齐）：平台模式下 specDir=平台 spec 根，此处
+  // 读 spec 根 local.yaml 的 repos: 而 execute MultiRepoContext 恒读 <cwd>/.sillyspec/local.yaml
+  // ——plan gate 看得到注册、execute 启动却 fail-closed（2026-09-15 wp 会话实证）。项目侧
+  // local.yaml 存在时以它为 repos: 权威（register-repo 写侧已对齐项目侧）；不存在（纯平台
+  // 项目从未建过项目侧文件）维持 spec 根回退，零回归。
+  const projectLocalYamlPath = pJoin(cwd, '.sillyspec', 'local.yaml')
+  if (existsSync(projectLocalYamlPath)) {
+    try {
+      repoRegistry = parseRepoRegistry(_readFileSync(projectLocalYamlPath, 'utf8'))
+    } catch { /* 项目侧读失败维持 spec 根结果 */ }
+  }
 
   // ── 1. 一致性校验 ──
   const consistency = validateBlueprintConsistency(changeDir, { repoRegistry })
@@ -1656,7 +1683,7 @@ export async function executePlanPostcheck(context) {
   // invalid → error 硬阻断，避免 execute 子代理跑死命令（design D-04 / 问题 3）。
   // modules 块可选：无块时仅查根 package.json（与 scan-postcheck 历史行为一致）。
   // local.yaml 已在检查 1 前预读（taskModules），此处直接消费。
-  const taskCmds = validateTaskCommands(changeDir, context.cwd, taskModules)
+  const taskCmds = validateTaskCommands(changeDir, context.cwd, taskModules, repoRegistry)
   if (taskCmds.errors.length > 0) {
     failures.push({
       name: 'TaskCard 命令存在性校验（verify/implementation 的 npm/pnpm/yarn run <script> 不存在）',

package/src/stages/quick.js

@@ -25,7 +25,7 @@ step 3 --done 审计会把 src 核心文件（CLI / 状态机 / 注入框架等
 4. 构建命令（CLI 自 local.yaml 注入，勿再读文件）：
 {LOCAL_COMMANDS}
 5. 若有关联变更，加载每个变更的设计文档：\`cat {SPEC_ROOT}/changes/<c>/design.md 2>/dev/null\`（理解设计意图）
-6. 如有需要，查询知识库：\`cat {SPEC_ROOT}/knowledge/INDEX.md 2>/dev/null\`
+6. 知识库：CLI 已按本会话任务描述（--input）机械匹配知识库——命中时本 prompt 末尾注入「📚 命中知识」段（top-3 文件正文截断），直接阅读即可，勿自行重跑 INDEX 匹配；段未出现（无命中或未带 --input）且确有需要时才查询：\`cat {SPEC_ROOT}/knowledge/INDEX.md 2>/dev/null\`
 
 ### 模块上下文（CLI 按任务描述匹配注入）
 按本会话任务描述从 _module-map.yaml 匹配的模块已注入本 prompt 开头「📦 模块上下文」段（职责/核心文件/风险/最近变更）——**不要再 cat _module-map.yaml 挑卡**；开头无该段 = 无命中模块，需要跨模块全局视野时才读 \`{SPEC_ROOT}/docs/<project>/modules/_module-map.yaml\` 自查。

package/src/stages/verify.js

@@ -160,6 +160,7 @@ export const definition = {
 2. 如果存在：
    - 逐个读取 tasks/task-NN.md，对照 frontmatter 的 \`acceptance:\` 列表逐条核验（TaskCard 协议的验收标准在 frontmatter YAML，正文无 checkbox）
    - 每条 acceptance 对照实际实现/测试结果判定满足与否，未满足的项列为不通过
+   - 覆盖对账走探针 7 矩阵：verify-result.md「探针 7：验收×测试覆盖矩阵」段已由 CLI 预填归属测试文件与关键词提示（骨架未生成时先跑 \`sillyspec verify-probes --change <change-name> --init\`，幂等不覆盖已有正文）；逐行填判定（covered/partial/uncovered/non-testable 四选一）与证据——covered/partial 附测试锚点（\`.test.\` 文件或 file:line），non-testable 写一句理由；判定/证据未填会被 verify \`--done\` 门禁阻断（fail-closed）
 3. 如果不存在：跳过此步骤
 
 ### 输出

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,170 @@ 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)
+  }
+}
+
+// ── push 409 自愈回执噪音闸（2026-09-15 复盘反馈：自愈重试不阻断但每步刷屏）──
+// 与 change_deleted 闸同构，按 `${changeName}\u0000${kind}` 键控（kind=自竞态/内容一致/自回声
+// 三类自愈）。语义边界：自愈是成功收敛路径不是故障——base_ts 409 每步自动同步都可能重撞、
+// ts 逐次不同但零新信息；首报完整可见（保留原文 ⚠️ 口吻），10 分钟窗口内同变更同类型重复
+// 自愈静默，窗口过期重报保活。推送成功不自愈清窗（下次 409 首报照常可见——竞态是否复发
+// 本身是信号）；SILLYSPEC_DEBUG_SYNC=1 与手动 platform sync（noMute）旁路。
+const SELF_HEAL_MARKER = 'sync-noise-self-heal.json'
+let _openedSelfHealByThisProcess = new Set()
+const _seenSelfHealInProcess = new Set()
+
+function _readSelfHealWindows() {
+  const p = _runtimeDir ? join(_runtimeDir, SELF_HEAL_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 _selfHealLineVisible(changeName, kind, noMute) {
+  if (!changeName || noMute || process.env.SILLYSPEC_DEBUG_SYNC) return true
+  const key = changeName + '\u0000' + kind
+  if (_seenSelfHealInProcess.has(key)) return false
+  const now = Date.now()
+  const windows = _readSelfHealWindows()
+  const until = windows ? windows[key] : undefined
+  if (typeof until === 'number' && now < until) {
+    _seenSelfHealInProcess.add(key)
+    // 开窗进程内同类自愈可见（诊断完整性），先前进程留的窗口静默
+    return _openedSelfHealByThisProcess.has(key)
+  }
+  _seenSelfHealInProcess.add(key)
+  const next = windows || {}
+  next[key] = now + MUTE_WINDOW_MS
+  try {
+    mkdirSync(_runtimeDir, { recursive: true })
+    writeFileSync(join(_runtimeDir, SELF_HEAL_MARKER), JSON.stringify(next) + '\n', 'utf8')
+  } catch { /* marker 写失败 = 闸门失效退化为直通，仅损失降噪 */ }
+  _openedSelfHealByThisProcess.add(key)
+  return true
+}
+
+/**
+ * push 409 自愈回执（warn 口吻：首报保留原文 ⚠️，窗口内同变更同类型静默）。
+ * @returns {boolean} true=已输出
+ */
+export function syncSelfHealWarn(changeName, kind, msg, { noMute = false } = {}) {
+  if (_selfHealLineVisible(changeName, kind, noMute)) {
+    console.warn(msg)
+    return true
+  }
+  return false
+}
+
 /**
  * 任意一次同步成功：清 marker。此前处于闸内（marker 存在）时打一行恢复提示——
  * 平台恢复的第一个信号应该可见，之后的成功照常静默（成功不打扰）。
@@ -150,9 +310,13 @@ export function noteSyncSuccess() {
   console.log('[sync] 平台连接已恢复（此前静默的同步失败已停止）')
 }
 
-/** 测试复位：清进程内绑定与开窗状态。 */
+/** 测试复位：清进程内绑定与开窗状态（连接类闸 + change_deleted 变更级闸 + 409 自愈闸）。 */
 export function _resetSyncNoiseForTest() {
   _runtimeDir = null
   _openedByThisProcess = false
   _seenInProcess.clear()
+  _openedDeletedByThisProcess = new Set()
+  _seenDeletedInProcess.clear()
+  _openedSelfHealByThisProcess = new Set()
+  _seenSelfHealInProcess.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, syncSelfHealWarn } 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,12 +836,17 @@ 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 重试一次即收敛，不落冲突文件（外来推送不可能
       // 推进本机 DB 的 base_ts，不满足条件自然落回下方真冲突分支，零误放行）
       if (attempt < MAX_PUSH_ATTEMPTS && await this._localBaseTsCovers(changeName, platformLastPushedAt)) {
-        console.warn(`⚠️ [sync] push 409 自竞态判定：本机并发推送已回填 base_ts（平台 ts=${platformLastPushedAt}），刷新后自动重试`);
+        // 409 自愈键控闸（2026-09-15 复盘：自愈不阻断但每步刷屏）——首报可见、窗口内同变更
+        // 同类型静默；手动 platform sync（manual）旁路
+        syncSelfHealWarn(changeName, 'self-race', `⚠️ [sync] push 409 自竞态判定：本机并发推送已回填 base_ts（平台 ts=${platformLastPushedAt}），刷新后自动重试`, { noMute: manual });
         continue;
       }
 
@@ -833,11 +865,49 @@ export class SyncManager {
               'UPDATE changes SET last_synced_platform_ts = MAX(?, COALESCE(last_synced_platform_ts, ?)) WHERE name = ?'
             ).run(platformLastPushedAt || pushedAt, platformLastPushedAt || pushedAt, changeName);
           } catch {}
-          console.warn(`⚠️ [sync] push 409 内容一致自愈: 平台 ts=${platformLastPushedAt} 为外来噪声重推（六表内容与本地一致），base_ts 已推进，不落冲突文件`);
+          // 409 自愈键控闸同上（kind=content-equal）
+          syncSelfHealWarn(changeName, 'content-equal', `⚠️ [sync] push 409 内容一致自愈: 平台 ts=${platformLastPushedAt} 为外来噪声重推（六表内容与本地一致），base_ts 已推进，不落冲突文件`, { noMute: manual });
           return { synced: 1, errors: [], selfHealed: true, reason: 'push 409 平台内容与本地一致（外来噪声重推），base_ts 已推进' };
         }
       } 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);
+            // 409 自愈键控闸同上（kind=self-echo）
+            syncSelfHealWarn(changeName, 'self-echo', `⚠️ [sync] push 409 自回声判定：平台 ts=${platformLastPushedAt} 为本机自推回声（血统 ${platLin}，推送者 ${platformLastPusher || '未回传·窗口判定'}），base_ts 已推进到 ${healTs}，自动重推`, { noMute: manual });
+            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 +1263,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 +1293,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 +1463,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 +1530,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('⚠️⚠️⚠️════════════════════════════════════════════════════');