sillyspec 3.32.4 → 3.32.5

package/src/hooks/worktree-guard.js

@@ -497,6 +497,22 @@ function parseSimpleYaml(content) {
       if (typeof result[topKey] !== 'object' || Array.isArray(result[topKey])) result[topKey] = {}
       if (!Array.isArray(result[topKey][childKey])) result[topKey][childKey] = []
       result[topKey][childKey].push(parseValue(trimmed.slice(2)))
+      continue
+    }
+
+    // indent>=4 的 `<子键>: <值>`（三层嵌套标量，坑 repo-inline-worktree-placement：repos 条目
+    // 对象形态 `repos: → <key>: → path:/worktree:`）——空数组占位（indent2 无值条目）转对象后
+    // 挂键。此前该形态被静默丢弃，analyzeCrossRepoCd 等消费方读不到三层配置。
+    if (indent >= 4 && childKey) {
+      const subMatch = trimmed.match(/^([^:]+):\s*(.*)$/)
+      if (!subMatch) continue
+      if (UNSAFE_KEYS.has(subMatch[1].trim())) continue
+      if (typeof result[topKey] !== 'object' || Array.isArray(result[topKey])) result[topKey] = {}
+      const cur = result[topKey][childKey]
+      if (Array.isArray(cur) && cur.length === 0) result[topKey][childKey] = {}
+      if (result[topKey][childKey] && typeof result[topKey][childKey] === 'object' && !Array.isArray(result[topKey][childKey])) {
+        result[topKey][childKey][subMatch[1].trim()] = parseValue(subMatch[2])
+      }
     }
   }
 
@@ -886,8 +902,25 @@ function analyzeCrossRepoCd(command, callerCwd, projectRoot, inWorktree) {
     const shellResolved = path.isAbsolute(t) ? t : path.resolve(callerCwd, t)
     const intended = path.isAbsolute(t) ? t : path.resolve(inWorktree ? projectRoot : callerCwd, t)
     for (const [key, raw] of Object.entries(repos)) {
-      if (typeof raw !== 'string' || !raw) continue
-      const repoRoot = path.isAbsolute(raw) ? raw : path.resolve(projectRoot, raw)
+      // 条目双形态（坑 repo-inline-worktree-placement）：'path' 字符串（parseSimpleYaml 原样）；
+      // 块式对象 {path, worktree}（parseSimpleYaml 嵌套）；inline '{path: ..}' 字符串
+      // （parseSimpleYaml 不解析 inline flow，原样字符串——手动提取 path 子键）
+      let repoPath = null
+      if (typeof raw === 'string' && raw) {
+        const t = raw.trim()
+        if (t.startsWith('{') && t.endsWith('}')) {
+          for (const part of t.slice(1, -1).split(',')) {
+            const idx = part.indexOf(':')
+            if (idx !== -1 && part.slice(0, idx).trim() === 'path') { repoPath = part.slice(idx + 1).trim().replace(/^['"]|['"]$/g, ''); break }
+          }
+        } else {
+          repoPath = raw
+        }
+      } else if (raw && typeof raw === 'object' && typeof raw.path === 'string' && raw.path) {
+        repoPath = raw.path
+      }
+      if (!repoPath) continue
+      const repoRoot = path.isAbsolute(repoPath) ? repoPath : path.resolve(projectRoot, repoPath)
       if (intended === repoRoot || isPathInside(intended, repoRoot)) {
         hits.push({ key, repoRoot, resolved: intended, shellResolved, target: t })
         break

package/src/index.js

@@ -4139,7 +4139,8 @@ SillySpec platform — SillyHub 平台同步
 用法:
   sillyspec platform connect <url> [--token <token>]
   sillyspec platform disconnect
-  sillyspec platform sync [--change <name>]
+  sillyspec platform sync [--change <name>]   带 --change 同步该变更进度六表+spec 树；
+                                             不带 --change 全树 spec 文件同步
   sillyspec platform sync-docs [--change <name>]
   sillyspec platform pull [--change <name>]
   sillyspec platform resolve <change-name> <--keep-local|--take-platform|--abort>
@@ -4254,8 +4255,26 @@ SillySpec platform — SillyHub 平台同步
         case 'sync': {
           const syncChangeIdx = args.indexOf('--change');
           const syncChangeName = syncChangeIdx >= 0 && args[syncChangeIdx + 1] && !String(args[syncChangeIdx + 1]).startsWith("--") ? args[syncChangeIdx + 1] : null;
-          // manual：用户显式同步，change_deleted 回执噪音闸旁路（显式动作的回执必须可见）
-          await syncModule.sync(syncChangeName, dir, { manual: true });
+          if (syncChangeName) {
+            // manual：用户显式同步，change_deleted 回执噪音闸旁路（显式动作的回执必须可见）
+            await syncModule.sync(syncChangeName, dir, { manual: true });
+          } else {
+            // 全树 spec 文件同步（2026-10-11-sync-conflict-tri-fix FR-03）：不带 --change
+            // 此前报「需要指定变更名称」——归档/历史变更无活跃会话标签时无从下手。现走
+            // syncSpecTreeOnly(null) 全树 diff（以服务器清单为锚）；进度六表仍按变更
+            // 粒度走 --change。未连接明确报错不静默（对齐 platform pull 口径）。
+            const smForCheck = new syncModule.SyncManager(dir);
+            if (!smForCheck._getPlatform()) {
+              console.error('❌ 未连接平台，请先 sillyspec platform connect');
+              process.exit(1);
+            }
+            const r = await syncModule.syncSpecTreeOnly(null, dir, {});
+            if (r && r.conflict) {
+              console.error(`⚠️ 全树同步检测到冲突（${(r.serverVersions && Object.keys(r.serverVersions).length) || 0} 个文件待裁决），处理：sillyspec platform status 查看 / platform resolve <变更名> 处置`);
+              process.exit(1);
+            }
+            console.log(`✅ 全树 spec 同步完成（${r ? r.synced : 0} 个文件差异）`);
+          }
           break;
         }
         case 'sync-docs': {

package/src/run/command.js

@@ -1274,6 +1274,25 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
     // 如果指定了变更名或有变更目录，自动初始化变更的 progress
     const autoChange = changeName || resolveChangeNameAuto(cwd, specRoot)
     if (autoChange) {
+      // 归档同名幽灵复活门（坑 archived-change-resurrect-by-merge，2026-10-10 实证：远端
+      // merge 把已归档变更的旧四件套带回活跃路径，run verify 见活跃目录即自动注册新进度行、
+      // 幽灵态推上平台）。活跃目录与 changes/archive/<同名>/ 并存且库内无该变更活跃行 →
+      // 拒绝注册，指向两出口（认归档：清幽灵目录 / 真要重开：换新名或先恢复归档）。
+      try {
+        const _archiveDup = join(specBase, 'changes', 'archive', autoChange)
+        if (existsSync(_archiveDup) && !progress) {
+          let _activeRows = []
+          try { _activeRows = pm.listChanges(cwd) } catch { /* 列举失败按无活跃行处置 */ }
+          if (!_activeRows.includes(autoChange)) {
+            console.error(`❌ 拒绝注册：${autoChange} 已有归档目录（changes/archive/${autoChange}/），当前活跃目录疑似 merge 带回的幽灵复活（库内无活跃行）。`)
+            console.error('   两个出口：')
+            console.error(`   ① 认归档（多数场景）：git rm -r .sillyspec/changes/${autoChange} 清幽灵目录后提交；归档侧工件在 changes/archive/${autoChange}/`)
+            console.error('   ② 确要重开同名变更：先换新变更名（推荐），或恢复归档（mv 回活跃目录并清理库内 archived 行）后再跑')
+            console.error('   核对：递归 diff 活跃 vs 归档目录确认归档侧为超集零信息损失（坑内处置实录）')
+            process.exit(2)
+          }
+        }
+      } catch { /* 守卫异常不拦正常注册（fail-open）*/ }
       // 创建时即写 title（与 name/KEY 同时落 db）：--input 首行推导 deriveChangeTitle（≤50 字，
       // 用户需求 2026-09-29）优先，长输入兜底 sanitizeDesc 压行，无则用 name 兜底。
       // proposal 还没写、无权威标题来源，这是临时值；brainstorm/plan 完成 proposal/design 落盘后由

package/src/run/multi-repo-context.js

@@ -25,6 +25,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { git, gitQuiet } from '../git-helper.js';
+import { resolveCrossWorktreePathCandidates } from '../cross-placement.js';
 
 /**
  * @typedef {Object} RepoEntry
@@ -152,14 +153,19 @@ export class MultiRepoContext {
         `请补全路径（约束② fail-closed）。`
       );
     }
-    // worktree 模式检测：meta 在 = worktree-cross.js 已建隔离（路径公式与其 crossWorktreePath
-    // 保持同步；execute 启动时创建，晚于本构造的调用会命中）。
+    // worktree 模式检测：meta 在 = worktree-cross.js 已建隔离（寻址经 cross-placement 叶子模块
+    // resolveCrossWorktreePath——注册表优先、公式兜底；execute 启动时创建，晚于本构造的调用会
+    // 命中。不 import worktree-cross 避免 shared↔multi-repo-context 循环，落位逻辑下沉的
+    // 零依赖叶子模块两侧共用无环——坑 cross-wt-toolchain-split 评审吸收①）。
     const specBase = (this.platformOpts && this.platformOpts.specRoot) || join(this.cwd, '.sillyspec');
     let crossMeta = null;
     try {
-      // 同步读（构造函数是同步的，不 import worktree-cross 避免 shared↔multi-repo-context 循环）
-      const metaPath = join(specBase, '.runtime', 'worktrees', `${this.changeName}--${repoKey}`, 'meta.json');
-      if (existsSync(metaPath)) crossMeta = JSON.parse(readFileSync(metaPath, 'utf8'));
+      // 同步读（构造函数是同步的）；寻址候选逐级探测（注册表 → 仓内新公式 → 主仓 specBase 旧
+      // 公式 legacy 兜底）——无注册表条目的存量 worktree 在本读取面不失联
+      for (const cand of resolveCrossWorktreePathCandidates(specBase, this.changeName, repoKey, crossRepoPath)) {
+        const metaPath = join(cand, 'meta.json');
+        if (existsSync(metaPath)) { crossMeta = JSON.parse(readFileSync(metaPath, 'utf8')); break }
+      }
     } catch { crossMeta = null }
     const inWorktree = !!(crossMeta && crossMeta.isCross && crossMeta.worktreePath && existsSync(crossMeta.worktreePath));
     const workRoot = inWorktree ? crossMeta.worktreePath : crossRepoPath;

package/src/run/shared.js

@@ -60,7 +60,12 @@ export function didYouMean(input, candidates) {
 // ── 变更名路径穿越消毒（F6）──
 // change 名会被 join 进 .sillyspec/changes/<name>/ 当目录用。若含 ../ 或路径分隔符，
 // 会逃出 changes/ 写到任意位置（如 --change ../../etc/x 把 proposal.md 写到 changes 同级之外）。
-// 在 --change 解析边界统一消毒，比在每个 join 点守卫更集中。合法名：字母/数字/._-，禁分隔符与 ..
+// 在 --change 解析边界统一消毒，比在每个 join 点守卫更集中。合法名：字母/数字/._-/CJK，
+// 禁分隔符与 ..
+// 2026-10-11-sync-conflict-tri-fix FR-03：字符集扩 CJK（一-鿿，与下方 assertDatedChangeName
+// slug 同集）——本守卫的本职是路径穿越消毒，ASCII 限制是历史误伤：磁盘既有中文名变更
+//（实测 2026-10-10-取消LTC宽表校验规则）被拒致 platform sync/resolve 无法操作。
+// 新建变更名仍受 assertDatedChangeName 日期前缀门约束，不因本放宽回归。
 export function assertSafeChangeName(name, label = '变更名') {
   if (name == null) return
   const s = String(name)
@@ -69,8 +74,8 @@ export function assertSafeChangeName(name, label = '变更名') {
   if (/[\\/]/.test(s) || /(^|[/\\])\.\.(?=$|[/\\])/.test(s) || s === '..' || s.includes('..')) {
     throw new Error(`${label}「${s}」含路径分隔符或 ..，禁止路径穿越（变更名只能是 .sillyspec/changes/ 下的一个目录名，不能逃出）`)
   }
-  if (!/^[\w.\-]+$/.test(s)) {
-    throw new Error(`${label}「${s}」含非法字符（仅允许字母、数字、._-）`)
+  if (!/^[\w.\-一-鿿]+$/.test(s)) {
+    throw new Error(`${label}「${s}」含非法字符（仅允许字母、数字、._-、中文）`)
   }
 }
 
@@ -83,7 +88,8 @@ export function assertSafeChangeName(name, label = '变更名') {
 // 日期只校验形状（月 01-12 日 01-31），不校验「当天」——跨天续跑/次日重命名不应被拦。
 // slug 首字符放宽含 CJK（一-鿿，与 flow 族 validateChangeName 同字符集）：flow start 2026-09-28
 // 起复用本校验器，中文名（平台键 2026-09-25-中文名-a1b2c3 形态）是 flow 族既有测试特性；
-// run 族不受影响——其上游 assertSafeChangeName 仅放行 ASCII [\w.\-]，中文在到达本门之前已被拦。
+// 上游 assertSafeChangeName 自 2026-10-11-sync-conflict-tri-fix 起同放行 CJK（此前 ASCII
+// 限宽拦中文名，属历史误伤，见该守卫注释）。
 const DATED_CHANGE_NAME_RE = /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])-[a-zA-Z0-9一-鿿][\w.\-一-鿿]*$/
 export function assertDatedChangeName(name, label = '变更名') {
   if (name == null) return

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 };
   }