sillyspec 3.27.7 → 3.27.11

package/src/run/gates.js

@@ -321,16 +321,65 @@ export async function enforceDepsGate(stageName, cwd, changeName, step, steps, c
     console.warn(`⚠️ worktree meta 读取失败（deps gate 将走物理目录判定）: ${e.message}`)
   }
   const depsStatus = meta?.depsStatus
-  if (['linked', 'installed', 'n/a'].includes(depsStatus)) return true
+  const mainOk = ['linked', 'installed', 'n/a'].includes(depsStatus)
+  if (mainOk) {
+    // ── 跨仓 worktree deps 校验（坑 cross-repo-no-worktree-isolation）──
+    // 跨仓仓供给失败同样无构建/测试能力（前端仓无 node_modules 建不了 build）。只校验已建
+    // worktree 的跨仓仓（legacy 直写模式无 meta，维持原语义，下游 Task Review 兜底）。
+    let crossFailed = []
+    try {
+      const crossSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
+      const { listCrossWorktreeMetas } = await import('../worktree-cross.js')
+      crossFailed = listCrossWorktreeMetas(crossSpecBase, changeName)
+        .filter(({ meta: cm }) => cm.depsStatus && !['linked', 'installed', 'n/a'].includes(cm.depsStatus))
+    } catch (e) {
+      console.warn(`⚠️ 跨仓 worktree deps 校验跳过（${e.message}）`)
+    }
+    if (crossFailed.length === 0) return true
+    if (steps && steps[currentIdx]) {
+      steps[currentIdx].status = 'blocked'
+      steps[currentIdx].blockReason = `跨仓 deps 门控阻断（${crossFailed.map(f => f.repoKey).join(', ')}）：修复后重试 --done`
+    }
+    console.error('❌ ── deps 门控阻断（本次 --done 未完成，进度未推进）──')
+    for (const { repoKey, meta: cm } of crossFailed) {
+      console.error(`   跨仓 repo ${repoKey} 依赖未就绪（depsStatus=${cm.depsStatus || 'unknown'}）——workdir: ${cm.worktreePath}`)
+      if (cm.depsError) console.error(`   上次供给错误：${cm.depsError}`)
+    }
+    console.error('   修复：进上述跨仓 worktree 手动安装依赖（用该仓的包管理器），或重跑 sillyspec run execute 让 CLI 重试供给后 --done。')
+    if (persist) { try { await persist() } catch { /* 落盘失败不吞阻断语义 */ } }
+    process.exit(1)
+  }
   const changeDir = changeName ? join(specBase, 'changes', changeName) : null
   if (isCurrentWaveAllNoDepsVerify(step?.name, changeDir)) return true
-  if (steps && steps[currentIdx]) steps[currentIdx].status = 'blocked'
+  if (steps && steps[currentIdx]) {
+    steps[currentIdx].status = 'blocked'
+    // 阻断原因持久化（坑 deps-gate-blocked-invisible）：--status/诊断时可见，不依赖阻断当刻的
+    // stderr（跨进程即失忆）。completed 时由 completeStep 主流程覆盖整个步骤行，残留字段不外泄。
+    steps[currentIdx].blockReason = `deps 门控阻断（depsStatus=${depsStatus || 'unknown'}）：worktree doctor --fix 修复后重试 --done`
+  }
   // ── 诊断分支（Phase 2，G2/R3 修正：判定基于物理目录而非 !meta）──
   // getMeta 对"目录不存在"与"meta 损坏"都返回 null，后者会误判终态 → 用物理目录存在性判定。
   let worktreeGone = true
   try {
     worktreeGone = !!(wm && changeName) && !existsSync(wm.getWorktreePath(changeName))
   } catch {}
+  // ── 正当收尾放行（坑 deps-gate-cleanup-order，2026-08-28 实证：apply 后 / execute 空变更
+  // cleanup 后重试 --done，被本门拦「worktree 不可用」逼 doctor --align-execute-progress 手工
+  // 对齐——顺序矛盾：cleanup 是流程自己做的收尾，门却当意外丢失拦）。两凭据二选一：
+  //   - apply-pathspec-<change>.txt：applyWorktree 成功后落盘（apply 后自动 cleanup 删 meta）；
+  //   - execute-cleanup-<change>.json：handleExecuteWorktreeCleanup 正当清理回执。
+  // 有凭据 = 隔离期已正当结束（交付已落主仓或本无交付），deps 能力要求不再适用 → 放行。
+  if (worktreeGone && changeName) {
+    try {
+      const runtimeRoot = resolveRuntimeRoot(platformOpts, specBase)
+      const legitimatelyEnded = existsSync(join(runtimeRoot, `apply-pathspec-${changeName}.txt`))
+        || existsSync(join(runtimeRoot, `execute-cleanup-${changeName}.json`))
+      if (legitimatelyEnded) {
+        console.log('ℹ️  worktree 已在 apply/execute 收尾时正当清理（凭据在 .runtime），deps 门放行')
+        return true
+      }
+    } catch { /* 凭据读取失败 → 维持原判定 */ }
+  }
   // ── fail-loud 块（Phase 3，D-005@v1：仅改拒绝侧 stderr）──
   console.error('❌ ── deps 门控阻断（本次 --done 未完成，进度未推进）──')
   if (worktreeGone) {
@@ -411,7 +460,10 @@ export async function enforceReviewJsonGate(stageName, cwd, changeName, step, st
   }
   const result = validateCheckedTaskReviews({ planContent, runtimeRoot, executeRunId })
   if (result.ok) return true
-  if (steps && steps[currentIdx]) steps[currentIdx].status = 'blocked'
+  if (steps && steps[currentIdx]) {
+    steps[currentIdx].status = 'blocked'
+    steps[currentIdx].blockReason = 'review.json 字段校验阻断：补齐后重试 --done（backfill-reviews --adopt 可代填 mechanics）'
+  }
   console.error('❌ ── review.json 字段校验阻断（本次 --done 未完成，进度未推进）──')
   console.error('   已勾选 [x] 的 task review.json 不完整（铁律：勾 checkbox 前必须先写完整 review.json）:')
   for (const f of result.failures) {
@@ -524,6 +576,19 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     }
   }
 
+  // plan 门 facade 候选预检（坑 plan-facade-files-manual-backfill，2026-08-28 用户实证 ×2：
+  // daemon/service.py 类「透传必经文件」不在 allowed_paths → 执行期 apply Gate1 拦截 →
+  // 手工回补两轮）。allowed 集与 Gate1 同源（resolveApplyAllowSet 主仓切片），
+  // 静态引用/聚合扫描亮候选，advisory 不阻断。
+  if (stageName === 'plan' && changeName) {
+    try {
+      const { resolveApplyAllowSet } = await import('../worktree-apply.js')
+      const { warnFacadeCandidateFiles } = await import('../facade-hint.js')
+      const allowMap = resolveApplyAllowSet(cwd, changeName)
+      warnFacadeCandidateFiles({ cwd, changeName, allowSet: allowMap.get('main') })
+    } catch { /* 预检失败不阻断 plan 完成 */ }
+  }
+
   // verify 产物校验通过 + 结论非 FAIL（否则上面已阻断）。
   // 再由 CLI 亲自执行 local.yaml 的测试命令，与 verify-result.md 的自报告对账：
   // 自报告 PASS 但实测失败 → 阻断（防止"文案通过"绕过验证）。
@@ -541,16 +606,23 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
         const { collectForeignDeclaredFiles } = await import('../verify-postcheck.js')
         const { gitQuiet } = await import('../git-helper.js')
         const foreignMap = collectForeignDeclaredFiles(cwd, changeName, { specBase, runtimeRoot: resolveRuntimeRoot(platformOpts, specBase) })
+        // dirty 集提前算好：归因提示①（他者在途）与②（生成产物旧基线）共用
+        const dirty = (gitQuiet(cwd, ['diff', '--name-only', 'HEAD']) || '')
+          .split('\n').filter(Boolean).map(f => f.replace(/\\/g, '/'))
+        const dirtySet = new Set(dirty)
         if (foreignMap.size > 0) {
-          const dirty = (gitQuiet(cwd, ['diff', '--name-only', 'HEAD']) || '')
-            .split('\n').filter(Boolean).map(f => f.replace(/\\/g, '/'))
           const hitForeign = dirty.filter(f => foreignMap.has(f))
           if (hitForeign.length > 0) {
             console.error(`   ℹ️ 归因提示：主仓检出 ${hitForeign.length} 个并行会话声明的在途文件（${hitForeign.slice(0, 5).join(', ')}${hitForeign.length > 5 ? ' 等' : ''}）——实测失败可能混入他者 WIP 而非本变更问题。待其提交/收尾后复验，仍失败才是本变更的。`)
           }
         }
         // 第二判据（坑 derived-artifact-stale-baseline）：本变更 apply 的文件（apply-pathspec 落盘）
-        // 与主仓近期提交重叠——本变更旧基线的生成产物可能覆盖了已合入内容，先在新基线重跑生成命令再复验
+        // 与主仓近期提交重叠——本变更旧基线的生成产物可能覆盖了已合入内容，先在新基线重跑生成命令再复验。
+        // 坑 verify-attr2-foreign-wip-misdirection（2026-08-28 实证）：并行会话在途/近期收尾文件
+        // 让重叠集虚高（51 文件），每轮误导 agent 重跑 gen:types，实际失败源是他者 WIP。两道过滤：
+        //   - 必须 dirty：apply 落盘的旧内容此刻物理在场（verify gate 时本变更未提交，旧基线覆盖
+        //     必然表现为对 HEAD 的修改）——内容与 HEAD 一致时重跑生成命令改变不了本轮实测；
+        //   - 剔除他者声明集：那是归因提示①的领地（待其收尾后复验），不是生成产物过期。
         try {
           const pathspecFile = join(resolveRuntimeRoot(platformOpts, specBase), `apply-pathspec-${changeName}.txt`)
           if (changeName && existsSync(pathspecFile)) {
@@ -559,8 +631,9 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
               const recent = (gitQuiet(cwd, ['log', '-n', '10', '--name-only', '--pretty=format:']) || '')
                 .split('\n').map(l => l.trim().replace(/\\/g, '/')).filter(Boolean)
               const overlap = [...new Set(recent)].filter(f => ownFiles.has(f))
-              if (overlap.length > 0) {
-                console.error(`   ℹ️ 归因提示②：本变更有 ${overlap.length} 个文件与主仓最近 10 条提交重叠（${overlap.slice(0, 5).join(', ')}${overlap.length > 5 ? ' 等' : ''}）——若为生成产物（api-types 等），本变更可能在旧基线生成并覆盖了已合入内容；先在新基线重跑生成命令（如 gen:types）再复验。`)
+              const actionable = filterStaleBaselineOverlap(overlap, dirtySet, foreignMap)
+              if (actionable.length > 0) {
+                console.error(`   ℹ️ 归因提示②：本变更有 ${actionable.length} 个文件与主仓最近 10 条提交重叠且旧内容仍在工作区（${actionable.slice(0, 5).join(', ')}${actionable.length > 5 ? ' 等' : ''}）——若为生成产物（api-types 等），本变更可能在旧基线生成并覆盖了已合入内容；先在新基线重跑生成命令（如 gen:types）再复验。（重叠共 ${overlap.length} 个，其余未在工作区改动或属他者会话在途文件，已归提示①/无需处理）`)
               }
             }
           }
@@ -1077,6 +1150,25 @@ export async function completeStageGates({ stageName, cwd, changeName, platformO
 }
 
 
+/**
+ * 归因提示②（生成产物旧基线覆盖）的重叠集过滤（坑 verify-attr2-foreign-wip-misdirection）。
+ *
+ * 原始重叠 = 本变更 apply-pathspec ∩ 主仓最近提交。并行会话场景下该集合被在途/刚收尾的
+ * 他者文件虚高，逐轮误导 agent 重跑生成命令。只保留两个必要条件都成立的文件：
+ *   - dirty（此刻对 HEAD 有改动）：verify gate 时本变更未提交，旧基线覆盖必然物理在场；
+ *     内容与 HEAD 一致时重跑生成命令改变不了本轮实测。
+ *   - 非他者声明集（collectForeignDeclaredFiles）：他者在途文件归归因提示①（待其收尾
+ *     复验），不是生成产物过期。
+ *
+ * @param {string[]} overlap 原始重叠文件（POSIX 路径）
+ * @param {Set<string>} dirtySet 主仓当前对 HEAD 的改动集
+ * @param {Set<string>|Map} foreignDeclared 他者会话声明集（Map 亦可用 has 判定）
+ * @returns {string[]} 可行动子集（空 = 不出提示②，避免误导）
+ */
+export function filterStaleBaselineOverlap(overlap, dirtySet, foreignDeclared) {
+  return (overlap || []).filter(f => dirtySet?.has(f) && !(foreignDeclared?.has(f)))
+}
+
 /**
  * verify 服务进程回收（verify --done 收尾调用）。
  *

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

@@ -22,6 +22,8 @@
  * 不涉及生命周期契约（design §7.5）：纯内存对象，不跨进程、不持久化、不入库。
  */
 
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
 import { git, gitQuiet } from '../git-helper.js';
 
 /**
@@ -133,7 +135,9 @@ export class MultiRepoContext {
   }
 
   /**
-   * 跨仓 RepoEntry：isMain=false，gitDir=projectRoot=worktreePath=跨仓仓根。
+   * 跨仓 RepoEntry：有 worktree meta（worktree-cross.js 创建）→ gitDir=worktreePath=worktree，
+   * base 锚 meta.baseHash（与主仓同构，坑 cross-repo-no-worktree-isolation）；无 meta（legacy
+   * 直写主干模式）→ gitDir=projectRoot=worktreePath=跨仓仓根，base 靠 taskBaseCommit 锡点。
    * 构造时 `git -C <crossRepo> rev-parse HEAD` 必须 succeed（约束② fail-closed），
    * 路径不存在/非 git 仓 → throw 阻断 execute。
    * @param {string} repoKey
@@ -148,14 +152,26 @@ export class MultiRepoContext {
         `请补全路径（约束② fail-closed）。`
       );
     }
+    // worktree 模式检测：meta 在 = worktree-cross.js 已建隔离（路径公式与其 crossWorktreePath
+    // 保持同步；execute 启动时创建，晚于本构造的调用会命中）。
+    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'));
+    } catch { crossMeta = null }
+    const inWorktree = !!(crossMeta && crossMeta.isCross && crossMeta.worktreePath && existsSync(crossMeta.worktreePath));
+    const workRoot = inWorktree ? crossMeta.worktreePath : crossRepoPath;
+
     // 约束②：跨仓 git 必须可达。失败 = 路径不存在 / 非 git 仓 / git 异常，一律阻断。
     // 不沿用主仓 verifyReviewGitEvidence unavailable 降级（design §9 兼容策略表）。
     let headVerify;
     try {
-      headVerify = git(crossRepoPath, ['rev-parse', 'HEAD']);
+      headVerify = git(workRoot, ['rev-parse', 'HEAD']);
     } catch (e) {
       throw new Error(
-        `MultiRepoContext: 跨仓 repo "${repoKey}" git 不可达（路径：${crossRepoPath}）。` +
+        `MultiRepoContext: 跨仓 repo "${repoKey}" git 不可达（路径：${workRoot}${inWorktree ? `（worktree，跨仓根 ${crossRepoPath}）` : ''}）。` +
         `rev-parse HEAD 失败：${e.message}。` +
         `请检查 local.yaml repos: 段路径是否正确、目录是否存在且为 git 仓（约束② fail-closed，配置错误不降级）。`
       );
@@ -164,17 +180,39 @@ export class MultiRepoContext {
       // git() 返回空串属异常态（无 commit 的空仓 rev-parse HEAD 会非零退出，已被 catch 兜底），
       // 此处仅作防御性双保险，触发同样走 fail-closed。
       throw new Error(
-        `MultiRepoContext: 跨仓 repo "${repoKey}"（${crossRepoPath}）rev-parse HEAD 返回空——` +
+        `MultiRepoContext: 跨仓 repo "${repoKey}"（${workRoot}）rev-parse HEAD 返回空——` +
         `疑似空 git 仓（无 commit）。跨仓 task 需仓库已有至少一个 commit（约束② fail-closed）。`
       );
     }
 
+    if (inWorktree) {
+      // worktree 模式：子代理在跨仓 worktree 分支上改+commit，apply 阶段由 CLI patch 回跨仓
+      // 主工作区。base 锚 meta.baseHash（创建时快照），head 实时取 worktree HEAD（子代理
+      // commit 推进后反映最新）；baseCommitHint 供派发侧优先取（HEAD 会推进，不能当 base）。
+      return {
+        repoKey,
+        gitDir: workRoot,
+        worktreePath: workRoot,
+        projectRoot: crossRepoPath,
+        isMain: false,
+        isWorktree: true,
+        baseCommitHint: crossMeta.baseHash || null,
+        resolveHead: () => git(workRoot, ['rev-parse', 'HEAD']),
+        resolveBase: (taskBaseCommit) => crossMeta.baseHash || taskBaseCommit || (() => {
+          throw new Error(
+            `MultiRepoContext: 跨仓 repo "${repoKey}"（worktree 模式）meta.baseHash 缺失且未传 taskBaseCommit。`
+          );
+        })(),
+      };
+    }
+
     return {
       repoKey,
       gitDir: crossRepoPath,
       worktreePath: crossRepoPath,
       projectRoot: crossRepoPath,
       isMain: false,
+      isWorktree: false,
       // 约束①：跨仓 HEAD 实时取，不缓存（task 推进后过期，每次 resolveHead 反映最新 HEAD）。
       resolveHead: () => git(crossRepoPath, ['rev-parse', 'HEAD']),
       // 约束①：跨仓 base = task 卡 base_commit 锡点（必传）。跨仓仓无 meta.json，

package/src/run/shared.js

@@ -139,7 +139,7 @@ export function resolveSpecDir(cwd, opts = {}) {
 // 只缓存"git root 已找到"的结果——非 git 仓库不缓存，防测试流程中途 git init 后读到陈旧 null。
 const _ancestorCeilingCache = new Map()
 
-function resolveAncestorCeiling(resolved) {
+export function resolveAncestorCeiling(resolved) {
   if (_ancestorCeilingCache.has(resolved)) return _ancestorCeilingCache.get(resolved)
   // 一次 spawn 拿两值（rev-parse 按参数序输出，每值一行）
   const out = safeGit(resolved, ['rev-parse', '--show-toplevel', '--git-common-dir']).value
@@ -813,6 +813,54 @@ export function isQuickMetadata(p, linkedChanges = []) {
   return false
 }
 
+// 危险文件清单（auditQuickCompletion 危险门与 predictProtectedQuickFiles 预告共用单一真相源）。
+// SillySpec 核心流程代码。W6 重构后 src/run.js（23 行 barrel）/ src/progress.js（facade）
+// 把真正逻辑下沉到 src/run/、src/progress/ 子目录——旧的精确文件名匹配
+// （file === 'src/run.js'）命中不到 src/run/command.js（. 与 / 不可混同），致危险文件门
+// 静默失效。改用「目录前缀（带尾斜杠，startsWith 不会误伤 src/runtime-* 等同名前缀）+
+// barrel/facade 本体精确名」双重覆盖。重构 src/ 模块时须同步本清单（multi-agent-review Q5）。
+const QUICK_DANGEROUS_PATTERNS = [
+  'package.json',
+  'package-lock.json',
+  'yarn.lock',
+  'pnpm-lock.yaml',
+  '.eslintrc',
+  'tsconfig.json',
+  'src/run.js',
+  'src/run/',
+  'src/progress.js',
+  'src/progress/',
+  'src/db.js',
+  'src/stage-contract.js',
+  'src/stage-contract-spec.js',
+  'src/worktree.js',
+  'src/worktree-apply.js',
+  'src/hooks/',
+]
+
+/**
+ * 预告：--files 声明中哪些文件会在 --done 审计被危险/基线门拦截（坑 quick-protected-late-hint，
+ * 2026-08-28 用户实证：scan 类文档 ARCHITECTURE/CONCERNS 属受保护基线，--files 声明了照样拦、
+ * 必须 --force-baseline——设计合理但提示太晚，要等审计轮才发现，白跑一轮往返）。
+ * 判定与 auditQuickCompletion 危险门逐字同口径（isQuickMetadata 豁免 + 关联变更目录退栈 +
+ * DANGEROUS_PATTERNS 前缀/精确匹配），forceBaseline 已带 → 无预告。
+ * @param {string[]} files 声明文件（--files）
+ * @param {{ linkedChanges?: string[], forceBaseline?: boolean }} opts
+ * @returns {string[]} 将被拦截的声明文件子集
+ */
+export function predictProtectedQuickFiles(files, { linkedChanges = [], forceBaseline = false } = {}) {
+  if (forceBaseline) return []
+  const linked = (Array.isArray(linkedChanges) ? linkedChanges : []).map(c => String(c).replace(/\\/g, '/'))
+  const isUnderLinkedChange = (f) => linked.some(lc => f.startsWith(`.sillyspec/changes/${lc}/`))
+  return (files || [])
+    .filter(Boolean)
+    .map(f => String(f).replace(/\\/g, '/'))
+    .filter(f => {
+      if (f.startsWith('.sillyspec/') && !isQuickMetadata(f, linked) && !isUnderLinkedChange(f)) return true
+      return QUICK_DANGEROUS_PATTERNS.some(p => p === f || f.startsWith(p))
+    })
+}
+
 /**
  * quick 完成审计：对比 baseline 与实际变更。
  * @returns {{ status: 'safe'|'warning'|'blocked', reasons: string[], changedFiles: string[], newFiles: string[], deletedFiles: string[], baselineHit: string[], stagedTotal: number, attributedFiles: string[], undeclaredFiles: string[], foreignSessionDeclared: Array<{file: string, sessions: string[]}> }}
@@ -990,29 +1038,7 @@ export async function auditQuickCompletion(cwd, guard, options = {}) {
       }
       return foreignDeclaredIndex.get(f) || null
     }
-    const DANGEROUS_PATTERNS = [
-      'package.json',
-      'package-lock.json',
-      'yarn.lock',
-      'pnpm-lock.yaml',
-      '.eslintrc',
-      'tsconfig.json',
-      // SillySpec 核心流程代码。W6 重构后 src/run.js（23 行 barrel）/ src/progress.js（facade）
-      // 把真正逻辑下沉到 src/run/、src/progress/ 子目录——旧的精确文件名匹配
-      // （file === 'src/run.js'）命中不到 src/run/command.js（. 与 / 不可混同），致危险文件门
-      // 静默失效。改用「目录前缀（带尾斜杠，startsWith 不会误伤 src/runtime-* 等同名前缀）+
-      // barrel/facade 本体精确名」双重覆盖。重构 src/ 模块时须同步本清单（multi-agent-review Q5）。
-      'src/run.js',
-      'src/run/',
-      'src/progress.js',
-      'src/progress/',
-      'src/db.js',
-      'src/stage-contract.js',
-      'src/stage-contract-spec.js',
-      'src/worktree.js',
-      'src/worktree-apply.js',
-      'src/hooks/',
-    ]
+    const DANGEROUS_PATTERNS = QUICK_DANGEROUS_PATTERNS
 
     for (const entry of currentEntries) {
       // porcelain 两字符状态码（X=暂存区 Y=工作区）不能先 trim：' D'.trim()==='D' 使第二分支恒假、

package/src/run/stage.js

@@ -19,7 +19,7 @@
 import { join, dirname } from 'node:path'
 import { existsSync, readdirSync, readFileSync, mkdirSync } from 'node:fs'
 import { writeAtomicSync } from '../fs-atomic.js'
-import { resolveSpecDir, resolveChangeDir, resolveRuntimeRoot, resolveQuickSessionsDir, triggerSync, safeGit, parsePorcelainPath, formatWaitOptions, checkApproval, getStageSteps, warnApprovalUnknown } from './shared.js'
+import { resolveSpecDir, resolveChangeDir, resolveRuntimeRoot, resolveQuickSessionsDir, triggerSync, safeGit, parsePorcelainPath, formatWaitOptions, checkApproval, getStageSteps, warnApprovalUnknown, predictProtectedQuickFiles } from './shared.js'
 import { computeScanProfile, applyScanProfileSteps, executeScanPreflight, executeScanPostcheck } from './scan-profile.js'
 import { outputStep, collectStageWaitHistory } from './prompt.js'
 import { allocateQuicklogEntry, deriveTitleFromLinkedChange, sanitizeDesc } from '../quicklog.js'
@@ -93,6 +93,26 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
       const execSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
       await ensureDepsFreshness(cwd, effectiveChange, execSpecBase, existingMeta)
     }
+
+    // ── 跨仓仓 worktree 隔离（坑 cross-repo-no-worktree-isolation，2026-08-27 用户实证）──
+    // 主仓 worktree 就绪后，为 plan 声明的每个跨仓仓建同构 worktree（幂等）。此前跨仓 task 直写
+    // 跨仓主工作副本，与用户在途改动混流、无 base 锚、无回滚面。fail-closed：建不起来不开工
+    //（对齐主仓 create 语义）。
+    try {
+      const { ensureCrossWorktrees } = await import('../worktree-cross.js')
+      const execSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
+      const cross = ensureCrossWorktrees({ cwd, changeName: effectiveChange, specBase: execSpecBase })
+      for (const c of cross.created) {
+        console.log(`🔗 跨仓 worktree 已创建: repo=${c.repoKey} → ${c.worktreePath}`)
+      }
+      for (const r of cross.reused) {
+        console.log(`🔗 跨仓 worktree 已存在: repo=${r.repoKey} → ${r.worktreePath}`)
+      }
+    } catch (e) {
+      console.error(`❌ 跨仓 worktree 创建失败: ${e.message}`)
+      console.error(`   修复后重跑本命令（已建成功的仓会幂等复用）。`)
+      process.exit(1)
+    }
   }
 
   // ── execute 阶段启动时固定 executeRunId（绑定变更名，避免跨变更复用） ──
@@ -228,8 +248,14 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
 
   let currentIdx = steps.findIndex(s => s.status !== 'completed' && s.status !== 'skipped')
 
-  // stale 步骤视为可执行（等同于 pending）
-  if (currentIdx !== -1 && steps[currentIdx].status === 'stale') {
+  // stale/blocked 步骤视为可执行（等同于 pending）：
+  //   stale = reopen 后未重做（原语义）；blocked = 门控（deps/review.json）阻断标记。
+  // blocked 必须一并转换（坑 deps-gate-blocked-invisible 的路径①失效面）：reopen 后首个未完成
+  // 步骤若是 blocked（早前门控阻断污染），只转 stale 会让 completeStep 的 findIndex(pending)
+  // 跳过它、--done 永远撞 stale 门控报错——「逐个真实执行」指引失效。门控在 --done 时会
+  // 重新校验，此处拉回 pending 不会绕过任何校验。
+  if (currentIdx !== -1 && (steps[currentIdx].status === 'stale' || steps[currentIdx].status === 'blocked')) {
+    console.log(`⚠️  Step "${steps[currentIdx].name}" 处于 ${steps[currentIdx].status}，已拉回待执行。`)
     steps[currentIdx].status = 'pending'
     pm._write(cwd, progress, changeName)
     triggerSync(cwd, changeName, platformOpts)
@@ -302,6 +328,15 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
   // （D-003@v1：顶层 quickGuard 不跨进程持久化；agent 在 step 间用 `run quick` 取下一步
   // prompt 时每个新进程都进此块，按文件判幂等才不会重复分配 ql-ID / 重复写条目）。
   if (stageName === 'quick') {
+    // 受保护文件预告打印（坑 quick-protected-late-hint，2026-08-28 用户实证：scan 类文档
+    // ARCHITECTURE/CONCERNS 属受保护基线，--files 声明了照样拦、必须 --force-baseline——
+    // 设计合理但提示太晚。step1 即预告哪些声明文件会触发拦截，省一轮跑到 --done 才发现的往返）
+    const warnProtectedQuickFiles = (protectedFiles) => {
+      console.warn(`⚠️ 声明文件中 ${protectedFiles.length} 个属受保护/危险范围，--done 审计将拦截（--files 只声明归属，不解锁拦截）：`)
+      for (const f of protectedFiles) console.warn(`   - ${f}`)
+      console.warn(`   确认要改这类文件：本会话收尾带 --force-baseline（sillyspec run quick --done --force-baseline ...）；`)
+      console.warn(`   属误判或不该由本会话改：换出 --files 声明，或走完整流程（execute 有 review 把关）。`)
+    }
     // quick-sessions 目录经 resolveQuickSessionsDir 单一解析（multi-agent-review Q4）：
     // 平台模式 runtimeRoot 与 specBase/.runtime 不同时，写/读须对齐，否则 guard 写一处、收尾读另一处。
     const sessionGuardDir = join(resolveQuickSessionsDir(platformOpts, specBase), changeName)
@@ -322,6 +357,13 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
         const known = new Set(progress.quickGuard.allowedFiles || [])
         const added = resumeFiles.filter(f => !known.has(f))
         if (added.length > 0) {
+          // 受保护文件预告（坑 quick-protected-late-hint）：追加声明若含审计将拦的文件，
+          // 追加时即点破（省一轮跑到 --done 才发现）。--files 只声明归属，不解锁拦截。
+          const protectedPreview = predictProtectedQuickFiles(added, {
+            linkedChanges: progress.quickGuard.linkedChanges || [],
+            forceBaseline: quickOpts?.isForceBaseline || false,
+          })
+          if (protectedPreview.length > 0) warnProtectedQuickFiles(protectedPreview)
           progress.quickGuard.allowedFiles = [...(progress.quickGuard.allowedFiles || []), ...added]
           progress.quickGuard.allowedFilesHash = { ...(progress.quickGuard.allowedFilesHash || {}) }
           for (const f of added) {
@@ -359,6 +401,10 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
         const allowDelete = quickOpts?.isAllowDelete || false
         const forceBaseline = quickOpts?.isForceBaseline || false
         const linkedChanges = Array.isArray(quickOpts?.linkedChanges) ? quickOpts.linkedChanges : []
+        // 受保护文件预告（坑 quick-protected-late-hint）：会话起步（step1）即点破，
+        // 判定与 --done 审计危险门同口径（predictProtectedQuickFiles）
+        const protectedPreview = predictProtectedQuickFiles(allowedFiles, { linkedChanges, forceBaseline })
+        if (protectedPreview.length > 0) warnProtectedQuickFiles(protectedPreview)
         // CLI 接管：分配 ql-ID + 写 QUICKLOG「进行中」条目 + 关联 tasks.md（持锁、当天唯一）
         const gitUser = safeGit(cwd, ['config', 'user.name']).value || 'unknown'
         // 标题回退：启动 quick 不带 --input 时，从关联变更的 proposal/design 提取语义标题，

package/src/spec-sync.js

@@ -8,6 +8,11 @@
  *
  * 复用 daemon 已验证的排除口径（UPLOAD_EXCLUDE_TOP_BASE / UPLOAD_PRUNE_NAMES_BASE），
  * 与 daemon 共用同一套清单语义（base_version 乐观锁、conflict 提示但不阻塞）。
+ *
+ * 并行会话 fail-closed 护栏（computeSpecOps 空树/changes 整删守卫 + filterStaleUpdates
+ * 旧副本回推守卫）：共享同一平台工作空间的多会话/多机场景下，错锚或滞后本地的破坏性
+ * ops（整删 changes/、旧版内容回推）在发出前拦下——服务器侧一旦被破坏会经同步链路
+ * 落地回各端本地（2026-08-26/27 两次实证）。
  */
 
 import { createHash } from 'crypto';
@@ -140,6 +145,20 @@ export function computeSpecOps(serverManifest, localFiles) {
     return [];
   }
 
+  // 并行会话护栏（坑 spec-sync-parallel-changes-wipe，2026-08-26/27 两次实证：平台同步
+  // 删整个 changes 目录）：本地树非空但 changes/ 子树一个文件都没有、服务器却有——
+  // 几乎必然是错锚/新机未先落地，而非用户真删光了所有变更（archive 是移动不是清空）。
+  // 放行即服务器 changes/ 整树清空，再经 daemon/对端同步落地回本地（破坏本地）。
+  // 逐个变更目录的合法删除不受影响（本地仍有其他 changes/ 文件时不触发本护栏）。
+  const serverChanges = serverPaths.filter((p) => p.startsWith('changes/'));
+  const localChanges = localFiles.filter((f) => f.path.startsWith('changes/'));
+  if (localFiles.length > 0 && serverChanges.length > 0 && localChanges.length === 0) {
+    console.warn(
+      `[spec-sync] 本地 spec 树无 changes/ 文件但服务器有 ${serverChanges.length} 个，跳过同步（防并行会话/错锚整删 changes/；请检查 spec 目录锚点，新环境先完成平台侧文件落地）`
+    );
+    return [];
+  }
+
   // rename 检测：旧路径（服务器有、本地无）↔ 新路径（本地有、服务器无）hash 相同
   const renames = [];
   const consumedNew = new Set();
@@ -248,6 +267,62 @@ function collectChangeDir(dirs, p) {
   }
 }
 
+/**
+ * 过滤「旧副本回推」型 update op（坑 spec-sync-parallel-stale-overwrite，2026-08-26/27
+ * 两次实证：平台同步把本地文件覆盖回旧版）。
+ *
+ * 判据：本地文件 mtime 早于上次成功同步（mtime + 1s 缓冲）= 该文件自上次同步后本地从未
+ * 改动——此刻服务器 hash 却不同，只可能是他者会话/他机推进了服务器内容。本地这份是旧
+ * 副本，照推 update 就是把服务器内容回退到旧版（再经 daemon/对端落地破坏各端本地）。
+ * 本地改过的文件（mtime 晚于上次同步）不受影响，正常 last-writer-wins。
+ *
+ * 被滤掉的文件如确需以本地为准覆盖服务器：本地重存（touch/再编辑）后重推。
+ *
+ * @param {Array} ops computeSpecOps 产物
+ * @param {Array} localFiles hashFiles 产物（含 mtime，Unix 秒）
+ * @param {number|null} lastSyncTs 上次成功同步完成时刻（ms）；null/0 → 不过滤
+ * @returns {{ ops: Array, stale: string[] }} 过滤后 ops + 被拦下的路径
+ */
+export function filterStaleUpdates(ops, localFiles, lastSyncTs) {
+  if (!lastSyncTs || !Array.isArray(ops) || ops.length === 0) {
+    return { ops, stale: [] };
+  }
+  const mtimeByPath = new Map(localFiles.map((f) => [f.path, f.mtime]));
+  const stale = [];
+  const kept = [];
+  for (const op of ops) {
+    if (op.op === 'update') {
+      const mtime = mtimeByPath.get(op.path);
+      if (mtime !== undefined && mtime * 1000 + 1000 <= lastSyncTs) {
+        stale.push(op.path);
+        continue;
+      }
+    }
+    kept.push(op);
+  }
+  return { ops: kept, stale };
+}
+
+// 上次成功同步标记（本地 .runtime 下，walk 排除不上传）：filterStaleUpdates 的时间锚。
+const LAST_SUCCESS_MARKER = 'spec-sync-last-success.json';
+
+function readLastSyncTs(specRoot) {
+  try {
+    const raw = readFileSync(join(specRoot, '.runtime', LAST_SUCCESS_MARKER), 'utf8');
+    const ts = JSON.parse(raw).ts;
+    return Number.isFinite(ts) ? ts : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeLastSyncTs(specRoot) {
+  try {
+    mkdirSync(join(specRoot, '.runtime'), { recursive: true });
+    writeFileSync(join(specRoot, '.runtime', LAST_SUCCESS_MARKER), JSON.stringify({ ts: Date.now() }) + '\n', 'utf8');
+  } catch { /* 标记失败只损失下次的防回推过滤，不影响本次同步结果 */ }
+}
+
 /**
  * 同步本地 .sillyspec 树到平台（CLI 直跑增量同步入口）。
  *
@@ -292,7 +367,17 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
   // 2. walk/hash/diff
   const entries = walkSpecTree(specRoot);
   const localFiles = hashFiles(entries);
-  const ops = computeSpecOps(serverManifest, localFiles);
+  let ops = computeSpecOps(serverManifest, localFiles);
+
+  // 旧副本回推防护（并行会话一致性）：上次同步后本地从未改动的文件不回推覆盖服务器新内容
+  const lastSyncTs = readLastSyncTs(specRoot);
+  const filtered = filterStaleUpdates(ops, localFiles, lastSyncTs);
+  if (filtered.stale.length > 0) {
+    console.warn(
+      `[spec-sync] 拦下 ${filtered.stale.length} 个旧副本回推（本地自上次同步未改动而服务器已前进，如确需以本地为准：重存后重推）: ${filtered.stale.slice(0, 5).join(', ')}${filtered.stale.length > 5 ? ' 等' : ''}`
+    );
+  }
+  ops = filtered.ops;
 
   if (ops.length === 0) {
     debugLog(`[spec-sync] 无差异，跳过同步: ${changeName}`);
@@ -342,6 +427,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       return { synced: 0, conflict: true, serverVersions, conflictPath };
     }
     console.log(`[spec-sync] 已同步 ${ops.length} 个文件变更: ${changeName}`);
+    writeLastSyncTs(specRoot);
     return { synced: ops.length };
   } catch (err) {
     console.warn(`[spec-sync] 同步异常（文件树本次未同步，下次自动重试）: ${changeName}: ${err.message}`);
@@ -354,5 +440,6 @@ export default {
   hashFiles,
   computeSpecOps,
   extractChangeDirs,
+  filterStaleUpdates,
   syncSpecTree,
 };

package/src/stage-contract.js

@@ -459,13 +459,26 @@ function validatePlanOutputs(cwd, changeName, context = {}) {
  * 历史教训：原正则锚定确切「## 结论」，用户写「## 验收结论：✅ PASS」不被识别。
  */
 function extractVerifyConclusion(verify) {
-  const headingRe = /^##\s[^\n]*(?:结论|conclusion|result|结果)/im
-  const headingMatch = verify.match(headingRe)
-  if (!headingMatch) return ''
-  const start = headingMatch.index
-  const slice = verify.slice(start, start + 400)
-  const kw = slice.match(/\b(PASS(?:\s+WITH\s+NOTES)?|FAIL)\b/i)
-  return kw ? kw[1].toUpperCase().replace(/\s+/g, ' ') : ''
+  // 遍历所有含关键词的二级标题，取其 400 字符窗口内含 PASS/FAIL 的那个（坑
+  // verify-conclusion-heading-hijack：旧逻辑取首个匹配，"## 测试结果"等普通标题
+  // 排在真结论前时劫持识别）。优先精确匹配「## 结论」类窄标题。
+  const headingRe = /^##\s[^\n]*(?:结论|conclusion|result|结果)/gim
+  let best = null
+  let bestPriority = -1
+  for (const headingMatch of verify.matchAll(headingRe)) {
+    const start = headingMatch.index
+    const slice = verify.slice(start, start + 400)
+    const kw = slice.match(/\b(PASS(?:\s+WITH\s+NOTES)?|FAIL)\b/i)
+    if (!kw) continue
+    // 优先级：精确含「结论/conclusion」> 宽泛含「result/结果」
+    const text = headingMatch[0].toLowerCase()
+    const priority = (/结论|conclusion/i.test(text)) ? 1 : 0
+    if (priority > bestPriority || (priority === bestPriority && !best)) {
+      best = kw[1].toUpperCase().replace(/\s+/g, ' ')
+      bestPriority = priority
+    }
+  }
+  return best || ''
 }
 
 function validateVerifyOutputs(cwd, changeName, context = {}) {