sillyspec 3.32.3 → 3.32.5

package/src/scope-audit.js

@@ -480,7 +480,7 @@ const QL_ID_RE = /^ql-\d{8}-\d{3}-[0-9a-f]{4}$/
  * @param {string} specBase .sillyspec 根
  * @returns {string[]} repoKey 清单
  */
-function loadRegisteredRepoKeys(specBase) {
+export function loadRegisteredRepoKeys(specBase) {
   try {
     const p = join(specBase || '', 'local.yaml')
     if (!specBase || !existsSync(p)) return []
@@ -1214,90 +1214,14 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   }
 
   // —— 计划侧跨仓段分仓真实对账（2026-09-20 scope-audit-cross-repo task-02，design Wave 2）——
-  // 旧形态「⊘ 行不在本仓对账面（实际侧只采主仓 git）」升级：plannedEntries 按 e.repo 分组，
-  // 每组调 collectRepoActual 共享内核（task-01）在**该仓**取 actual（锚点四级：A reviews-range
-  // > B head~1-window > C head-uncommitted-window > degraded），主仓同款三类差集出真实三态行
-  // + 行数；degraded 仓（未注册/路径不可达/git 双源失败）退 v1 ⊘ 形态（untouched + crossRepo）
-  // + 降级注记进 note，不炸主仓表（D-006 fail-soft）。
-  // 行数由本集成层对内核产物跑 collectNumstatByPath（内核不 import scope-audit 防环，评审
-  // G3——调用方职责）；anchor.base 为 null（B/C 档降级锚）→ numstat 空 Map → degradedStat
-  // 该仓根兜底（行数 null 降级档，不出伪数据）。跨仓行过滤口径与主仓 actual 侧一致
-  // （filterDeliverableFiles：排 .sillyspec 运行时面/平台自装脚手架），unplanned 行的
-  // classifyToolScaffold 软桶与主仓 unplanned 行同款。
-  const crossRepoKeys = [...new Set(plannedEntries.map(e => e.repo).filter(Boolean))]
-  const crossRepoRows = []
-  const crossRepoEntries = []
-  if (crossRepoKeys.length > 0) {
-    const crossCount = plannedEntries.filter(e => e.repo).length
-    notes.push(`计划侧含 ${crossCount} 个跨仓文件（repo：${crossRepoKeys.join('、')}）——已按 local.yaml repos 注册表分仓对账（各仓锚点档见 repos[].anchor）`)
-    for (const repoKey of crossRepoKeys) {
-      const entries = plannedEntries.filter(e => e.repo === repoKey)
-      const repoRows = []
-      let repoActual = null
-      let repoFailure = null
-      try {
-        repoActual = collectRepoActual({ repoKey, specBase: sb, cwd, runtimeRoot, changeName })
-      } catch (e) {
-        repoFailure = e && e.message ? String(e.message).split('\n')[0] : String(e)
-      }
-      if (repoFailure || !repoActual || repoActual.degradedReason) {
-        // degraded 仓（内核 fail-soft 产物或调用点异常）：v1 ⊘ 形态回退——该组行恒 untouched，
-        // 降级原因进 note 与 repos[] 条目（平台消费方可感知），主仓表不受影响。
-        const reason = repoFailure
-          ? `内核采集异常: ${repoFailure}`
-          : (repoActual && repoActual.degradedReason) || '跨仓采集不可用'
-        for (const e of entries) {
-          repoRows.push({ path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched', crossRepo: repoKey })
-        }
-        notes.push(`跨仓 ${repoKey} 对账降级: ${reason}`)
-        crossRepoEntries.push({
-          key: repoKey,
-          repoPath: repoActual ? repoActual.repoPath : null,
-          anchor: repoActual ? repoActual.anchor : { source: 'degraded', base: null, head: null, label: 'degraded' },
-          totals: repoTotals(repoRows),
-          degraded: true,
-          degradedReason: reason,
-        })
-        crossRepoRows.push(...repoRows)
-        continue
-      }
-      // 真实三态：该仓 actual（filterDeliverableFiles 过滤，主仓口径）× 该组声明面 pathMatches
-      // 双向容差（glob/目录前缀兼容，design 清单可写 glob）→ planned / unplanned / untouched
-      const repoFiles = [...new Set(filterDeliverableFiles(repoActual.files).filter(Boolean))].map(toPosix).sort()
-      const repoStats = collectNumstatByPath(repoActual.repoPath, repoFiles, { baseRef: repoActual.anchor.base })
-      const repoMatched = new Set()
-      for (const f of repoFiles) {
-        const path = toPosix(f)
-        const st = repoStats.get(path) || degradedStat(repoActual.repoPath, path)
-        const row = { path, planned: null, additions: st.additions, deletions: st.deletions, kind: st.kind, verdict: 'unplanned', crossRepo: repoKey }
-        const entry = entries.find(e => pathMatches(path, e.path))
-        if (entry) {
-          repoMatched.add(entry.path)
-          row.planned = entry.operation || null
-          row.verdict = 'planned'
-        } else {
-          // 工具/平台脚手架软桶（主仓 unplanned 行同款）：CLI/平台自装文件不占「计划外」逐条清单
-          const facility = classifyToolScaffold(path)
-          if (facility) row.facility = facility
-        }
-        repoRows.push(row)
-      }
-      // 声明未动：该仓清单文件无实际改动 → 补行（行数 0/0，主仓补行同款；crossRepo 恒带）
-      for (const e of entries) {
-        if (repoMatched.has(e.path)) continue
-        repoRows.push({ path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched', crossRepo: repoKey })
-      }
-      crossRepoEntries.push({
-        key: repoKey,
-        repoPath: repoActual.repoPath,
-        anchor: repoActual.anchor,
-        totals: repoTotals(repoRows),
-        degraded: false,
-        degradedReason: null,
-      })
-      crossRepoRows.push(...repoRows)
-    }
-  }
+  // 集成逻辑抽共享导出 reconcileCrossRepoPlan（2026-10-10-cross-repo-patch-freeze D-002@v1）：
+  // heavy（本函数）与 thin（flow.js done）同源消费防口径漂移；本处行为等价（rows/repos/notes
+  // 三产物原样并回）+ collectPatch 时 repos[].patch/patchSha256 增量。
+  const crossRecon = reconcileCrossRepoPlan({ cwd, specBase: sb, runtimeRoot, changeName, planEntries: plannedEntries, collectPatch: !!collectPatch })
+  const crossRepoRows = crossRecon.rows
+  const crossRepoEntries = crossRecon.repos
+  for (const n of crossRecon.notes) notes.push(n)
+  const crossRepoKeys = crossRepoEntries.map(e => e.key)
 
   // —— 三态判定 ——
   const rows = []
@@ -1382,6 +1306,127 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   }
 }
 
+/**
+ * 跨仓对账集成层（2026-10-10-cross-repo-patch-freeze D-002@v1，自 computeFullFlowAudit 内联段
+ * 抽出——heavy（computeFullFlowAudit）与 thin（flow.js done）同源消费防两份口径漂移；复用
+ * collectRepoActual 共享内核（2026-09-20「单一真相源」哲学））。
+ *
+ * planEntries 按 e.repo 分组，每组调 collectRepoActual 在**该仓**取 actual（锚点：A
+ * reviews-range > B' worktree-baseline > B head~1-window > C head-uncommitted-window >
+ * degraded），主仓同款三类差集出真实三态行 + 行数；degraded 仓退 ⊘ 形态（untouched +
+ * crossRepo + degradedReason），不炸调用方表（D-006 fail-soft）。行数由本层对内核产物跑
+ * collectNumstatByPath（内核不 import 本模块防环，评审 G3——调用方职责）。
+ *
+ * collectPatch=true 时每仓增 patch 采集（D-001@v1/D-003@v1）：窗口与行数同根同窗——A/B' 档
+ * 锚 hash 为 baseRef；B 档字面 HEAD~1、C 档字面 HEAD（工作树口径含 untracked 自拼 hunk）；
+ * buildFrozenPatch 失败或空窗 → patch=null 不出伪件；sha256 走 sha256PatchNormalized（LF 归一，
+ * autocrlf 跨平台一致）。collectPatch=false 不产 patch 两键（additive 契约，既有读方零感知）。
+ *
+ * @param {{ cwd: string, specBase: string, runtimeRoot?: string|null, changeName?: string|null,
+ *           planEntries: Array<{path, operation?, repo?}>, collectPatch?: boolean }} args
+ * @returns {{ rows: Array<object>, repos: Array<object>, notes: string[] }}
+ *   rows 带 crossRepo 标记（真实三态或 degraded ⊘）；repos 条目
+ *   { key, repoPath, anchor, totals, degraded, degradedReason, patch?, patchSha256? }；
+ *   notes 为调用方 note 链的增量行（跨仓计数行 + 降级行）。
+ */
+export function reconcileCrossRepoPlan({ cwd, specBase, runtimeRoot, changeName, planEntries, collectPatch = false }) {
+  const rows = []
+  const repos = []
+  const notes = []
+  const planned = Array.isArray(planEntries) ? planEntries : []
+  const crossRepoKeys = [...new Set(planned.map(e => e.repo).filter(Boolean))]
+  if (crossRepoKeys.length === 0) return { rows, repos, notes }
+  const crossCount = planned.filter(e => e.repo).length
+  notes.push(`计划侧含 ${crossCount} 个跨仓文件（repo：${crossRepoKeys.join('、')}）——已按 local.yaml repos 注册表分仓对账（各仓锚点档见 repos[].anchor）`)
+  for (const repoKey of crossRepoKeys) {
+    const entries = planned.filter(e => e.repo === repoKey)
+    const repoRows = []
+    let repoActual = null
+    let repoFailure = null
+    try {
+      repoActual = collectRepoActual({ repoKey, specBase, cwd, runtimeRoot, changeName })
+    } catch (e) {
+      repoFailure = e && e.message ? String(e.message).split('\n')[0] : String(e)
+    }
+    if (repoFailure || !repoActual || repoActual.degradedReason) {
+      // degraded 仓（内核 fail-soft 产物或调用点异常）：⊘ 形态回退——该组行恒 untouched，
+      // 降级原因进 note 与 repos[] 条目（平台消费方可感知），调用方主表不受影响。
+      const reason = repoFailure
+        ? `内核采集异常: ${repoFailure}`
+        : (repoActual && repoActual.degradedReason) || '跨仓采集不可用'
+      for (const e of entries) {
+        repoRows.push({ path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched', crossRepo: repoKey })
+      }
+      notes.push(`跨仓 ${repoKey} 对账降级: ${reason}`)
+      repos.push({
+        key: repoKey,
+        repoPath: repoActual ? repoActual.repoPath : null,
+        anchor: repoActual ? repoActual.anchor : { source: 'degraded', base: null, head: null, label: 'degraded' },
+        totals: repoTotals(repoRows),
+        degraded: true,
+        degradedReason: reason,
+        ...(collectPatch ? { patch: null, patchSha256: null } : {}),
+      })
+      rows.push(...repoRows)
+      continue
+    }
+    // 真实三态：该仓 actual（filterDeliverableFiles 过滤，主仓口径）× 该组声明面 pathMatches
+    // 双向容差（glob/目录前缀兼容，design 清单可写 glob）→ planned / unplanned / untouched
+    const repoFiles = [...new Set(filterDeliverableFiles(repoActual.files).filter(Boolean))].map(toPosix).sort()
+    const repoStats = collectNumstatByPath(repoActual.repoPath, repoFiles, { baseRef: repoActual.anchor.base })
+    const repoMatched = new Set()
+    for (const f of repoFiles) {
+      const path = toPosix(f)
+      const st = repoStats.get(path) || degradedStat(repoActual.repoPath, path)
+      const row = { path, planned: null, additions: st.additions, deletions: st.deletions, kind: st.kind, verdict: 'unplanned', crossRepo: repoKey }
+      const entry = entries.find(e => pathMatches(path, e.path))
+      if (entry) {
+        repoMatched.add(entry.path)
+        row.planned = entry.operation || null
+        row.verdict = 'planned'
+      } else {
+        // 工具/平台脚手架软桶（主仓 unplanned 行同款）：CLI/平台自装文件不占「计划外」逐条清单
+        const facility = classifyToolScaffold(path)
+        if (facility) row.facility = facility
+      }
+      repoRows.push(row)
+    }
+    // 声明未动：该仓清单文件无实际改动 → 补行（行数 0/0，主仓补行同款；crossRepo 恒带）
+    for (const e of entries) {
+      if (repoMatched.has(e.path)) continue
+      repoRows.push({ path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched', crossRepo: repoKey })
+    }
+    // patch 采集（D-001/D-003）：窗口 = 行数窗口——锚 hash 优先；B/C 档降级锚用字面 ref
+    // （head~1-window → HEAD~1；head-uncommitted-window → HEAD），工作树口径含 untracked。
+    let patch = null
+    let patchSha256 = null
+    if (collectPatch && repoFiles.length > 0) {
+      const patchBase = repoActual.anchor.base
+        || (repoActual.anchor.source === 'head~1-window' ? 'HEAD~1'
+          : repoActual.anchor.source === 'head-uncommitted-window' ? 'HEAD'
+          : null)
+      if (patchBase) {
+        const text = buildFrozenPatch(repoActual.repoPath, repoFiles, { baseRef: patchBase })
+        if (typeof text === 'string' && text.length > 0) {
+          patch = text
+          patchSha256 = sha256PatchNormalized(text)
+        }
+      }
+    }
+    repos.push({
+      key: repoKey,
+      repoPath: repoActual.repoPath,
+      anchor: repoActual.anchor,
+      totals: repoTotals(repoRows),
+      degraded: false,
+      degradedReason: null,
+      ...(collectPatch ? { patch, patchSha256 } : {}),
+    })
+    rows.push(...repoRows)
+  }
+  return { rows, repos, notes }
+}
+
 /**
  * 变更范围对账纯函数（scope-audit 命令与三处阶段注入的唯一数据源，D-003）。
  *

package/src/spec-sync.js

@@ -594,11 +594,29 @@ export function isFollowerSetChanged(specRoot, key, list) {
  * @param {string} changeName - 当前变更名
  * @returns {Promise<{synced: number, conflict?: boolean, serverVersions?: object}>}
  */
+/**
+ * 冲突路径 → 变更名归因标签（2026-10-11-sync-conflict-tri-fix FR-03 全树同步入口用）：
+ * changes/(archive/)?<名>/ 前缀提取，全部路径归因到同一变更 → 用该变更名（冲突文件
+ * spec-sync-conflict-<名>.json 与 per-change 流程兼容，resolve/status UX 不变）；
+ * 跨多变更或无可归因路径 → 'full-tree'（单文件合并裁决，resolve 整体 force-push）。
+ */
+function attributeChangeLabel(paths) {
+  const names = new Set()
+  for (const p of paths) {
+    const m = p.match(/^changes\/(?:archive\/)?([^/]+)\//)
+    if (m) names.add(m[1])
+  }
+  return names.size === 1 ? [...names][0] : 'full-tree'
+}
+
 export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
   if (!platform || !platform.url || !platform.token) {
     debugLog('[spec-sync] 未连接平台（本地合法状态）；跳过 spec 树增量同步');
     return { synced: 0 };
   }
+  // 全树入口（platform sync 无 --change，2026-10-11-sync-conflict-tri-fix FR-03）
+  // changeName=null：日志用 full-tree 标签，冲突归因见下方 conflictLabel。
+  const logLabel = changeName || 'full-tree';
   // 绑定连接类失败噪音闸（sync-noise.js）：本目录所有 [spec-sync]/[sync] 失败 warn 的
   // 跨进程静默窗口 marker 落这里（与 SyncManager 构造器绑定同目录）。
   try { bindSyncNoiseRoot(join(specRoot, '.runtime')); } catch { /* 直通降级 */ }
@@ -622,7 +640,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       // 8 分钟才被后续步骤的同步补上）。失败可见、成功不打扰。
       // 连接类失败（404=端点未就绪 / 5xx）走噪音闸（sync-noise.js）：平台未就绪期每步
       // 自动同步重刷同一行，淹没门禁输出；其余状态码（4xx 业务态）每轮该看见。
-      const line = `[spec-sync] 拉取清单失败 HTTP ${res.status}（文件树本次未同步，下次自动重试）: ${changeName}`;
+      const line = `[spec-sync] 拉取清单失败 HTTP ${res.status}（文件树本次未同步，下次自动重试）: ${logLabel}`;
       if (isConnectionClassStatus(res.status)) syncConnectionWarn(line);
       else console.warn(line);
       return { synced: 0 };
@@ -630,7 +648,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
     const body = await res.json().catch(() => ({}));
     serverManifest = body.files || {};
   } catch (err) {
-    const line = `[spec-sync] 拉取清单异常（文件树本次未同步，下次自动重试）: ${changeName}: ${describeSyncError(err)}`;
+    const line = `[spec-sync] 拉取清单异常（文件树本次未同步，下次自动重试）: ${logLabel}: ${describeSyncError(err)}`;
     syncConnectionWarn(line); // 网络/超时/熔断均连接类
     return { synced: 0 };
   }
@@ -671,7 +689,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
   }
 
   if (ops.length === 0) {
-    debugLog(`[spec-sync] 无差异，跳过同步: ${changeName}`);
+    debugLog(`[spec-sync] 无差异，跳过同步: ${logLabel}`);
     clearStaleTombstoneMarkers(specRoot);
     return { synced: 0 };
   }
@@ -688,7 +706,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       signal: withSignal(30000),
     });
     if (!res.ok) {
-      const line = `[spec-sync] 同步请求失败 HTTP ${res.status}（文件树本次未同步，下次自动重试）: ${changeName}`;
+      const line = `[spec-sync] 同步请求失败 HTTP ${res.status}（文件树本次未同步，下次自动重试）: ${logLabel}`;
       if (isConnectionClassStatus(res.status)) syncConnectionWarn(line);
       else console.warn(line);
       return { synced: 0 };
@@ -719,6 +737,9 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
         ? { followers: [], real: serverVersions }
         : partitionConflictPaths(serverVersions, localFiles, baseHashes, lastSyncTs);
       const realPaths = Object.keys(real).filter((p) => !tombSet.has(p));
+      // 全树入口（changeName=null）冲突归因：单一变更 → 该变更名（冲突文件/markers 与
+      // per-change 流程同名兼容）；跨变更 → 'full-tree' 单文件合并裁决。
+      const conflictLabel = changeName || attributeChangeLabel(realPaths);
 
       // 纯墓碑形态：版本冲突面为空、拒收全是墓碑 → 不写/不清通用冲突标记（clear 会把
       // 状态洗成「已消解」误导 status），单独落冲突文件 + 正确恢复指引。
@@ -743,13 +764,13 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       // 自愈」连环刷屏。冲突文件在且冲突集未变 = 用户已被告知：重复轮次单行提示（可见但不
       // 吓人），不重写文件（created_at 稳定，status 红标语义不变）；冲突集变化才重写+全幅。
       // forcePush（resolve --keep-local 刚裁决完重推）不参与去重——需真实判定与文件刷新。
-      const pendingSame = !opts.forcePush && realPaths.length > 0 && isSamePendingSpecConflict(specRoot, changeName, realPaths);
+      const pendingSame = !opts.forcePush && realPaths.length > 0 && isSamePendingSpecConflict(specRoot, conflictLabel, realPaths);
       if (pendingSame) {
         if (followers.length > 0) {
           debugLog(`[spec-sync] ${followers.length} 个本地未改动文件自动跟随服务器: ${followers.slice(0, 5).join(', ')}${followers.length > 5 ? ' 等' : ''}`);
         }
-        console.warn(`⚠️ [spec-sync] 变更 ${changeName} 存在未决 spec 树冲突（${realPaths.length} 个文件待裁决，本轮非冲突改动已照常同步）。处理：sillyspec platform resolve ${changeName} --keep-local | --take-platform | --abort`);
-        return { synced: 0, conflict: true, serverVersions: real, autoResolved: followers.length, conflictPath: join(specRoot, '.runtime', `spec-sync-conflict-${changeName}.json`), suppressed: true };
+        console.warn(`⚠️ [spec-sync] 变更 ${conflictLabel} 存在未决 spec 树冲突（${realPaths.length} 个文件待裁决，本轮非冲突改动已照常同步）。处理：sillyspec platform resolve ${conflictLabel} --keep-local | --take-platform | --abort`);
+        return { synced: 0, conflict: true, serverVersions: real, autoResolved: followers.length, conflictPath: join(specRoot, '.runtime', `spec-sync-conflict-${conflictLabel}.json`), suppressed: true };
       }
       if (followers.length > 0) {
         console.warn(`[spec-sync] ${followers.length} 个本地未改动文件自动跟随服务器（正常多端前进，无需人工裁决）: ${followers.slice(0, 5).join(', ')}${followers.length > 5 ? ' 等' : ''}`);
@@ -757,18 +778,18 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       if (realPaths.length === 0) {
         writeLastSyncTs(specRoot);
         writeBaseSnapshot(specRoot, localFiles);
-        clearSpecConflictMarker(specRoot, changeName);
+        clearSpecConflictMarker(specRoot, conflictLabel);
         noteSyncSuccess();
-        console.log(`[spec-sync] 冲突已自动消解（0 个需人工裁决；本会话改动 ${ops.length - followers.length > 0 ? '已同步' : '无差异'}）: ${changeName}`);
+        console.log(`[spec-sync] 冲突已自动消解（0 个需人工裁决；本会话改动 ${ops.length - followers.length > 0 ? '已同步' : '无差异'}）: ${conflictLabel}`);
         return { synced: Math.max(ops.length - followers.length, 0), conflict: false, autoResolved: followers.length };
       }
       let conflictPath = null;
       try {
         const runtimeDir = join(specRoot, '.runtime');
         mkdirSync(runtimeDir, { recursive: true });
-        conflictPath = join(runtimeDir, `spec-sync-conflict-${changeName}.json`);
+        conflictPath = join(runtimeDir, `spec-sync-conflict-${conflictLabel}.json`);
         writeFileSync(conflictPath, JSON.stringify({
-          change: changeName,
+          change: conflictLabel,
           kind: 'spec-tree',
           created_at: new Date().toISOString(),
           server_versions: real,
@@ -786,20 +807,28 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       console.warn('');
       console.warn(`⚠️ [spec-sync] 检测到 spec 树冲突（${realPaths.length} 个文件: ${shownPaths}；逐文件服务器版本见冲突详情文件）`);
       if (tombNote) console.warn(`⚠️ [spec-sync]${tombNote.trim()}`);
-      console.warn(`⚠️ 处置：sillyspec platform resolve ${changeName} --keep-local | --take-platform | --abort（冲突详情: ${conflictPath || '(写入失败)'}）`);
+      console.warn(`⚠️ 处置：sillyspec platform resolve ${conflictLabel} --keep-local | --take-platform | --abort（冲突详情: ${conflictPath || '(写入失败)'}）`);
       return { synced: 0, conflict: true, serverVersions: real, autoResolved: followers.length, conflictPath };
     }
     noteSyncSuccess();
-    console.log(`[spec-sync] 已同步 ${ops.length} 个文件变更: ${changeName}`);
+    console.log(`[spec-sync] 已同步 ${ops.length} 个文件变更: ${logLabel}`);
     // 本轮无冲突 = 此前的未决 spec 树冲突已不存在，清残留标记（否则 status 永久红标、
-    // 横幅去重单行提示不消——坑 spec-sync-conflict-banner-spam）
-    clearSpecConflictMarker(specRoot, changeName);
+    // 横幅去重单行提示不消——坑 spec-sync-conflict-banner-spam）。全树入口
+    // （changeName=null，2026-10-11-sync-conflict-tri-fix FR-03）按归因清：只清本轮
+    // ops 触及变更的标记——未触及变更的未决冲突不因全树绿而误清。
+    if (changeName) {
+      clearSpecConflictMarker(specRoot, changeName);
+    } else {
+      for (const name of new Set(ops.map((o) => attributeChangeLabel([o.path])))) {
+        if (name !== 'full-tree') clearSpecConflictMarker(specRoot, name);
+      }
+    }
     clearStaleTombstoneMarkers(specRoot);
     writeLastSyncTs(specRoot);
     writeBaseSnapshot(specRoot, localFiles);
     return { synced: ops.length };
   } catch (err) {
-    const line = `[spec-sync] 同步异常（文件树本次未同步，下次自动重试）: ${changeName}: ${describeSyncError(err)}`;
+    const line = `[spec-sync] 同步异常（文件树本次未同步，下次自动重试）: ${logLabel}: ${describeSyncError(err)}`;
     syncConnectionWarn(line); // 网络/超时/熔断均连接类
     return { synced: 0 };
   }

package/src/stages/plan-postcheck.js

@@ -261,6 +261,34 @@ export function detectDuplicateTopKeys(fmText) {
  * @returns {Map<string, string>} repoKey → absolutePath
  */
 export function parseRepoRegistry(yamlText) {
+  return _parseRepoEntries(yamlText, 'path')
+}
+
+/**
+ * repos 段条目的 worktree 子键 → Map<repoKey, 落位根目录>（坑 cross-wt-toolchain-split 配置
+ * 简化，2026-10-10 用户反馈：独立 worktree.crossPlacement 段与仓注册分居两处形态重——落位
+ * 直接内联在注册条目上）。
+ *
+ * 只认对象形态条目的 worktree 子键；字符串条目（值即路径）无落位语义不入 Map。清洗规则
+ * （CRLF/行内注释/引号）与 parseRepoRegistry 同源。
+ * @param {string} yamlText
+ * @returns {Map<string, string>} repoKey → 落位根目录（未配置的仓不在 Map）
+ */
+export function parseRepoWorktreePlacements(yamlText) {
+  return _parseRepoEntries(yamlText, 'worktree')
+}
+
+/**
+ * repos 段统一解析内核：subkey='path' → 注册表（字符串条目值即 path）；subkey='worktree' →
+ * 落位内联（仅对象条目）。条目三形态：
+ *   urgent: /mnt/e/repo                                # 字符串（值即 path，worktree 不适用）
+ *   urgent: {path: /mnt/e/repo, worktree: /mnt/e/wt}   # inline flow 对象
+ *   urgent:                                            # 块式对象
+ *     path: /mnt/e/repo
+ *     worktree: /mnt/e/wt
+ * @returns {Map<string, string>}
+ */
+function _parseRepoEntries(yamlText, subkey) {
   const reg = new Map()
   if (!yamlText) return reg
   // CRLF 归一（坑 register-repo-crlf-idempotent-loop，2026-08-23 实证：Windows 下 agent Write
@@ -269,6 +297,7 @@ export function parseRepoRegistry(yamlText) {
   // 幂等跳过不落盘 → 死循环。同文件 parseAllowedPaths/parseDependsOn/parseBaseCommit 均有此
   // 归一，本函数是唯一缺口）
   const lines = String(yamlText).replace(/\r\n?/g, '\n').split('\n')
+  const cleanVal = (v) => String(v || '').replace(/\s+#.*$/, '').trim().replace(/^['"]|['"]$/g, '')
   let startIdx = -1
   for (let i = 0; i < lines.length; i++) {
     if (/^repos:\s*(?:#.*)?$/.test(lines[i])) { startIdx = i; break }
@@ -281,15 +310,44 @@ export function parseRepoRegistry(yamlText) {
     // 条目格式：  <key>: <value>（key 限 [A-Za-z0-9_.\-]，与 parseLocalYamlModules 对齐）
     const entry = line.match(/^\s+([A-Za-z0-9_.\-]+):\s*(.*)$/)
     if (!entry) continue
-    const value = (entry[2] || '').trim()
-    if (value === '' || value.startsWith('#')) continue
-    // 去可选行内注释（`value # comment`）—— 注意路径不含 ` #`，注释前必带空格
-    const cleaned = value.replace(/\s+#.*$/, '').trim()
-    if (cleaned === '') continue
-    // 去首尾可选引号（YAML 字符串引用），保留路径内反斜杠原样
-    const path = cleaned.replace(/^['"]|['"]$/g, '')
-    if (path === '') continue
-    reg.set(entry[1], path)
+    const key = entry[1]
+    const indent = line.length - line.trimStart().length
+    const rawValue = (entry[2] || '').trim()
+
+    if (rawValue !== '' && !rawValue.startsWith('#')) {
+      if (rawValue.startsWith('{') && rawValue.endsWith('}')) {
+        // inline flow 对象：拆逗号取目标子键（值内逗号不支持——路径含逗号请用块式）
+        let hit = null
+        for (const part of rawValue.slice(1, -1).split(',')) {
+          const idx = part.indexOf(':')
+          if (idx === -1) continue
+          if (part.slice(0, idx).trim() === subkey) { hit = cleanVal(part.slice(idx + 1)); break }
+        }
+        if (hit) reg.set(key, hit)
+      } else if (subkey === 'path') {
+        // 字符串条目：值即 path（worktree 子键语义不适用于字符串形态）
+        const cleaned = cleanVal(rawValue)
+        if (cleaned !== '') reg.set(key, cleaned)
+      }
+      continue
+    }
+
+    // 块式对象条目（value 空）：消费整个子键块（缩进更深的连续行），取目标子键首个命中——
+    // 整块消费防子键行（path:/worktree:）被外层循环误当条目再匹配（'path'/'worktree' 混进
+    // registry 污染 Map）
+    let j = i + 1
+    for (; j < lines.length; j++) {
+      const l = lines[j]
+      if (l.trim() === '' || l.trim().startsWith('#')) continue
+      const subIndent = l.length - l.trimStart().length
+      if (subIndent <= indent) break // 离开本条目块（下一条目或段结束）
+      const sub = l.match(/^\s+([A-Za-z0-9_.\-]+):\s*(.*)$/)
+      if (sub && sub[1] === subkey && !reg.has(key)) {
+        const cleaned = cleanVal(sub[2])
+        if (cleaned !== '' && !cleaned.startsWith('#')) reg.set(key, cleaned)
+      }
+    }
+    i = j - 1 // 整块已消费；外层 ++ 落在块尾后第一行（下一条目或段边界）
   }
   return reg
 }

package/src/sync.js

@@ -2333,6 +2333,9 @@ export function listConflictFiles(cwd) {
 // 清单为锚做全树 diff，与变更目录无关——triggerSync 对 quick 会话降级只调本函数，
 // 不走 sync()（后者第二道 existsSync 门会以「变更不存在」提前 return）。
 // 未连接平台 → {synced: 0} 静默（本地合法状态，与 syncSpecTree 内部口径一致）。
+// 2026-10-11-sync-conflict-tri-fix FR-03：changeName=null 是合法形态——CLI 手动
+// 全树同步入口（platform sync 无 --change）经此走全树 diff；冲突归由 syncSpecTree
+// 内部 attributeChangeLabel 按路径归因（单一变更名或 'full-tree'）。
 export async function syncSpecTreeOnly(changeName, cwd, opts = {}) {
   const sm = new SyncManager(cwd);
   const platform = sm._getPlatform();

package/src/verify-postcheck.js

@@ -58,7 +58,21 @@ import { runVerifyProbes, readSmokeResultRecord, deriveSmokeSectionState, scanSm
 import { parseEvidenceSlots, classifyVerifiedFile } from './verify-facts-schema.js'
 
 // 测试命令最长执行时间；超时视为失败（防止 CLI 被挂起的测试卡死）
-const TEST_TIMEOUT_MS = Number(process.env.SILLYSPEC_TEST_TIMEOUT_MS) || 10 * 60 * 1000
+// 单位统一（坑 active-pitfalls SILLYSPEC_TEST_TIMEOUT_MS 单位二义，2026-10-10 实证）：
+// 此前本常量裸读 env 当毫秒，而 resolveTestTimeoutMs 按文档契约（config-schema
+// test_timeout_sec 同效）当秒×1000——同一变量两读法，按文档传秒值（如 1800）被批执行器
+// 当 1.8s 帽、deps 批瞬时 ETIMEDOUT。统一走 parseTestTimeoutEnvMs：秒契约为准；
+// ≥10000 的值按毫秒兼容解释（实证期的规避口径）并告警促改秒。
+function parseTestTimeoutEnvMs(raw) {
+  const e = Number(raw)
+  if (!Number.isFinite(e) || e <= 0) return null
+  if (e >= 10_000) {
+    console.warn(`⚠️ SILLYSPEC_TEST_TIMEOUT_MS=${e} 按毫秒解释（= ${(e / 1000).toFixed(0)}s）——本变量契约单位是秒（与 test_timeout_sec 同效），建议改传秒值。`)
+    return e
+  }
+  return e * 1000
+}
+const TEST_TIMEOUT_MS = parseTestTimeoutEnvMs(process.env.SILLYSPEC_TEST_TIMEOUT_MS) || 10 * 60 * 1000
 
 /**
  * 测试超时配置链（R9 实证 2026-09-23）：local.yaml commands.test_timeout_sec > env
@@ -69,8 +83,7 @@ const TEST_TIMEOUT_MS = Number(process.env.SILLYSPEC_TEST_TIMEOUT_MS) || 10 * 60
 export function resolveTestTimeoutMs(yamlText, env = process.env) {
   const m = String(yamlText || '').match(/^\s*test_timeout_sec:\s*([0-9]+)\s*(?:#.*)?$/m)
   if (m && Number(m[1]) > 0) return Number(m[1]) * 1000
-  const e = Number(env.SILLYSPEC_TEST_TIMEOUT_MS)
-  return Number.isFinite(e) && e > 0 ? e * 1000 : TEST_TIMEOUT_MS
+  return parseTestTimeoutEnvMs(env.SILLYSPEC_TEST_TIMEOUT_MS) || TEST_TIMEOUT_MS
 }
 const OUTPUT_TAIL_CHARS = 4000
 // 判账失败行台账上限（坑 verify-test-reconcile-tail-blindspot）：对账按完整输出判、tail 只存
@@ -1936,7 +1949,29 @@ function resolveMainChangedFiles(cwd, changeName, specBase = null) {
       const diffBase = meta?.baselineCommit || meta?.actualBaseHash || meta?.baseHash
       if (diffBase) {
         const gitDir = found.gitDir
-        const files = runGitDiffNameOnly(gitDir, `${diffBase}..HEAD`)
+        // 基点 merge-base 化（坑 verify-reconcile-base-stale-parallel-drift，2026-10-10 实证：
+        // 执行期把 main 合入 worktree 分支后，立项 diffBase..HEAD 把主仓并行演进算成本变更
+        // 产出——对账 21 条 undeclared 噪声淹没真实信号。改锚 merge-base(<主分支>, HEAD)：
+        // 只含本分支自身提交；未合 main 时 merge-base == 立项点行为零变化。不放大守卫：
+        // 仅当 mb 是 diffBase 的后代（窗口只收窄）才采用，否则退旧区间。
+        let anchor = String(diffBase)
+        try {
+          const headHash = String(gitQuiet(gitDir, ['rev-parse', 'HEAD'], { timeout: 15000 }) || '').trim()
+          const mainRef = typeof meta?.baseBranch === 'string' && meta.baseBranch.trim() ? meta.baseBranch.trim() : 'main'
+          let mb = gitQuiet(gitDir, ['merge-base', mainRef, 'HEAD'], { timeout: 15000 })
+          if (!(typeof mb === 'string' && mb.trim())) mb = gitQuiet(gitDir, ['merge-base', 'master', 'HEAD'], { timeout: 15000 })
+          // 三重守卫：mb == HEAD（提交落主分支本身/in-place 形态——主分支即本变更线，
+          // 收窄到 HEAD 会清空 diff 面）或 mb == 立项点（零变化）或 mb 非立项点后代
+          // （窗口放大）时一律保持旧锚。仅「严格收窄」形态才采用 merge-base。
+          if (typeof mb === 'string' && mb.trim()) {
+            const mbHash = mb.trim()
+            if (mbHash !== String(diffBase) && mbHash !== headHash && headHash) {
+              const isDesc = gitQuiet(gitDir, ['merge-base', '--is-ancestor', String(diffBase), mbHash], { timeout: 15000 })
+              if (isDesc === '') anchor = mbHash
+            }
+          }
+        } catch { /* 退旧区间（不放大） */ }
+        const files = runGitDiffNameOnly(gitDir, `${anchor}..HEAD`)
         // 坑 verify-evidence-account-diff-misses-committed-changes（2026-09-13 实证）：
         // wt-commit 流程把本变更提交落在**主仓 HEAD**，worktree 分支不前移——仅查 worktree
         // 侧 diffBase..HEAD 时已提交文件全部 miss（7 task diffHit=false 连环假红，verify 两连
@@ -2801,8 +2836,19 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
   const SUITE_META_RE = /(^|\/)run-tests\.mjs$/
   const jsMeta = js.filter(f => SUITE_META_RE.test(norm(f)))
   const jsList = js.filter(f => !SUITE_META_RE.test(norm(f)))
+  // 非测试形态拆批（坑 verify-dynamic-subset-node-test-ts-source，2026-10-10 平台侧实证，
+  // 用户授权修复）：deps 面（FR 绑定 / 增量账本 / 依赖发现）可携带非测试文件——node --test
+  // 语义「文件即测试」直跑源码必败（TS 源码 import './x.js' 无 resolver 映射
+  // ERR_MODULE_NOT_FOUND）、vitest/jest 点名非测试文件 No test suite found、pytest 点名
+  // 非测试 .py 0 collected exit 5——三执行批统一只收测试形态（isTestFilePath 同口径），
+  // 被拆文件 nontest-skip 批点名披露（不跑不拦，绑定面脏数据可见可治理）。
+  const pyNonTest = py.filter(f => !isTestFilePath(f))
+  const pyTest = py.filter(f => isTestFilePath(f))
+  const jsNonTest = jsList.filter(f => !isTestFilePath(f))
+  const jsTest = jsList.filter(f => isTestFilePath(f))
+  const nonTestFiles = [...pyNonTest, ...jsNonTest]
   const CAP = 30
-  const pyCap = py.length === 0 ? 0 : jsList.length === 0 ? CAP : Math.max(5, Math.min(CAP - 5, Math.round(CAP * py.length / (py.length + jsList.length))))
+  const pyCap = pyTest.length === 0 ? 0 : jsTest.length === 0 ? CAP : Math.max(5, Math.min(CAP - 5, Math.round(CAP * pyTest.length / (pyTest.length + jsTest.length))))
   const jsCap = CAP - pyCap
   // 配额制组卷（2026-10-06-fr-regress-cap-drop）：优先面整跑豁免帽，普通依赖填剩余席位；
   // dropped 只计普通依赖弃置（优先面零弃置是构造保证），组内序保持「优先前缀+字母序」。
@@ -2812,8 +2858,8 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
     const ordinaryRun = ordinary.slice(0, Math.max(0, quota - prioInGroup.length))
     return { run: [...prioInGroup, ...ordinaryRun], prioCount: prioInGroup.length, dropped: ordinary.length - ordinaryRun.length, prioDropped: 0 }
   }
-  const pyQ = quotaFill(py, pyCap)
-  const jsQ = quotaFill(jsList, jsCap)
+  const pyQ = quotaFill(pyTest, pyCap)
+  const jsQ = quotaFill(jsTest, jsCap)
   const pyRun = pyQ.run
   const jsRun = jsQ.run
   // .py 运行器推断双源（2026-09-26-dynamic-test-inference）：① 命中模块命令串（旧路径，兼容期）；
@@ -2883,8 +2929,10 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
   // dropped 只计普通依赖弃置、prioDropped=防御路径计数（构造上恒 0——quotaFill 保证优先面零弃置，
   // >0 即组卷逻辑被破坏，消费面 loud 披露）。js 批经 jsNative/jsProject 内容分流后计数随分流面。
   if (pyRun.length > 0) batches.push({ name: 'deps(auto-py)', short: 'py', command: `${pyRunner} ${pyRun.map(rebase).join(' ')}`, count: pyRun.length, prioCount: pyQ.prioCount, dropped: pyQ.dropped, prioDropped: pyQ.prioDropped, files: pyRun })
-  if (jsNative.length > 0) batches.push({ name: 'deps(auto-js)', short: 'js', command: `node --test --test-reporter=spec --test-reporter-destination=stderr --test-reporter=tap --test-reporter-destination=stdout ${jsNative.join(' ')}`, count: jsNative.length, prioCount: jsNative.filter(f => prio(f) === 0).length, dropped: jsList.length - jsRun.length, prioDropped: jsQ.prioDropped, tap: true, files: jsNative })
+  if (jsNative.length > 0) batches.push({ name: 'deps(auto-js)', short: 'js', command: `node --test --test-reporter=spec --test-reporter-destination=stderr --test-reporter=tap --test-reporter-destination=stdout ${jsNative.join(' ')}`, count: jsNative.length, prioCount: jsNative.filter(f => prio(f) === 0).length, dropped: jsTest.length - jsRun.length, prioDropped: jsQ.prioDropped, tap: true, files: jsNative })
   if (jsMeta.length > 0) batches.push({ name: 'deps(auto-js-meta-skip)', short: 'js-meta-skip', command: null, count: jsMeta.length, dropped: 0, skip: true, files: jsMeta, reason: '套件编排器（run-tests.mjs=npm test 组卷入口）非单测文件——内嵌执行=递归全量套件（嵌套 runner 污染假败）；全量门由收口实测/CI 的 npm test 承担' })
+
+  if (nonTestFiles.length > 0) batches.push({ name: 'deps(auto-nontest-skip)', short: 'nontest-skip', command: null, count: nonTestFiles.length, dropped: 0, skip: true, files: nonTestFiles, reason: `非测试形态文件 ${nonTestFiles.length} 个不进单测执行批（node --test 语义「文件即测试」/ vitest No test suite found / pytest 0 collected exit 5——直跑必假败；坑 verify-dynamic-subset-node-test-ts-source）：${nonTestFiles.slice(0, 3).join('、')}${nonTestFiles.length > 3 ? ' 等' : ''}——FR 绑定面脏数据可 sillyspec tests --unbind --tests <路径> 清行` })
   if (jsProjectRun.length > 0) {
     if (jsxRunner) {
       const isVitest = /vitest/.test(jsxRunner)

package/src/verify-probes.js

@@ -1758,15 +1758,22 @@ export function parseTaskAcceptance(content) {
 }
 
 /**
- * allowed_paths 条目是否测试形态（结构归属面）：test/ 前缀，或文件名含 .test. / _test. / spec
- * 惯例（(?:^|[._-])test(?:[._-]|$) 覆盖 foo.test.mjs / foo_test.js / test-foo.js 三形）。
- * 比探针 3 的存在性面（isTestFileName 文件名形态判定，宽松存在性提示）严格——这是 3/7 口径差异的落点。
- */
-function isProbe7TestPath(p) {
+ * allowed_paths 条目是否测试形态（结构归属面）：tests?/ 或 __tests__/ 目录段，或文件名
+ * .test./.spec. js 系后缀锚，或 python test_*.py / *_test.py——与 verify-postcheck 执行侧
+ * isTestFilePath 同口径（坑 verify-dynamic-subset-node-test-ts-source，2026-10-10 平台侧
+ * 实证：旧 /spec/i 裸子串把 spec-sync.ts 等「文件名含 spec 字样」的源码误判为测试路径，
+ * 随 trace 落盘进 FR 机器绑定行，后续变更经 FR 回归面被 node --test 直跑假败）。
+ * 漏检边界（宁紧勿松）：foo_test.js 连字形态不再预填——落 agent 手查是 fail-visible，
+ * 误绑产假败是 fail-hidden 更糟。比探针 3 的存在性面（isTestFileName 宽松提示）严格——
+ * 3/7 口径差异落点。
+ */
+export function isProbe7TestPath(p) {
   const posix = String(p).split('\\').join('/')
-  if (/^test\//.test(posix)) return true
+  if (/(^|\/)(tests?|__tests__)\//.test(posix)) return true
   const name = basename(posix)
-  return /(?:^|[._-])test(?:[._-]|$)/i.test(name) || /spec/i.test(name)
+  return /\.(test|spec)\.[cm]?(js|jsx|ts|tsx)$/.test(name)
+    || /(^|\/)test_[^\/]+\.py$/.test(posix)
+    || /(^|\/)[^\/]+_test\.py$/.test(posix)
 }
 
 /**