sillyspec 3.27.7 → 3.27.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sillyspec",
-  "version": "3.27.7",
+  "version": "3.27.9",
   "description": "SillySpec CLI — 流程状态机，让 AI 严格按步骤来",
   "icon": "logo.jpg",
   "homepage": "https://sillyspec.ppdmq.top/",

package/src/contract-matrix.js

@@ -117,22 +117,50 @@ export function buildContractMatrix(planContent, changeDir) {
 function parseTaskDependencies(registryContent) {
   const deps = {}
 
-  // 方式 1: 任务总表表格形式 | task-04 | ... | 01,02 |
-  // 列前缀用 [^|\d]*（不吃数字）：旧 [^|]* 贪婪会吃掉 deps 列前导 0（" 01" → g2=1 → task-1），
-  // 导致 provider task-1.md 不存在 → contracts 恒空，端点契约管线失效。
-  const tableRows = registryContent.matchAll(/\|[^|]*task-(\d+)[^|]*\|[^|]*\|[^|\d]*(?:task-)?(\d+(?:\s*[,，]\s*\d+)*)[^|]*\|/gi)
-  for (const match of tableRows) {
-    const task = `task-${match[1]}`
-    const depList = match[2].split(/[,，\s]+/).map(d => `task-${d.trim()}`).filter(d => d.startsWith('task-'))
-    deps[task] = depList
+  // 方式 1: 任务总表表格形式（两种常见格式）
+  //   A: | task-04 | Wave | 优先级 | 说明 | 依赖 |  （task-NN 在独立列）
+  //   B: | task | desc | deps |                       （task-NN 在任意列，bare 数字依赖）
+  // 逐行按 | 分列解析，避免旧单正则 [^|]* 跨列贪婪误读说明列数字（409/HTTP 状态码）
+  // 为假依赖（坑 contract-matrix-false-deps）。
+  // deps 列判定：从行尾倒数第一个「非分隔符、非 task 自身、非单数字(Wave/优先级)」的列，
+  // 且须含逗号/task- 引用/bare 两位以上数字。
+  const lines = registryContent.split('\n')
+  for (const line of lines) {
+    const taskIdMatch = line.match(/task-(\d+)/i)
+    if (!taskIdMatch) continue
+    const taskId = `task-${taskIdMatch[1]}`
+
+    const cells = line.split('|').map(c => c.trim()).filter(c => c.length > 0)
+    if (cells.length < 2) continue
+
+    // 从行尾倒数找 deps 列
+    let depCell = null
+    for (let i = cells.length - 1; i >= 0; i--) {
+      const c = cells[i]
+      if (/^-+$/.test(c)) continue                          // 分隔符 "-"
+      if (c.toLowerCase() === taskId.toLowerCase()) continue // task 自身列
+      // deps 列候选：含逗号（多依赖）或含 task- 引用
+      if (/[,，]/.test(c) || /task-\d+/i.test(c)) { depCell = c; break }
+      // bare 数字：须 ≥2 位且位于行尾第2+列（跳过优先级/Wave 列的个位数）
+      if (/^\d{2,}$/.test(c) && i >= cells.length - 2) { depCell = c; break }
+    }
+    if (!depCell) continue
+    const depNums = depCell.match(/\d+/g) || []
+    deps[taskId] = depNums.map(d => `task-${d.padStart(2, '0')}`)
   }
 
   // 方式 2: tasks.md 行内标注 "- [ ] task-04: 名称 (depends_on: task-01,02)"（新家，D-003@v1；
-  // 旧 plan.md checkbox 行内标注同格式兼容）
-  const dependsPattern = registryContent.matchAll(/task-(\d+).*?depends_on.*?(\d+(?:\s*[,，]\s*\d+)*)/gi)
+  // 旧 plan.md checkbox 行内标注同格式兼容）。仅匹配 (depends_on: ...) 括号内内容，
+  // 不在自由文本上全文正则（坑 contract-matrix-false-deps：说明列数字被误读为依赖）。
+  const dependsPattern = registryContent.matchAll(/task-(\d+)\b[^)]*?\(depends_on:\s*([^)]+)\)/gi)
   for (const match of dependsPattern) {
     const task = `task-${match[1]}`
-    const depList = match[2].split(/[,，\s]+/).map(d => `task-${d.trim()}`).filter(d => d.startsWith('task-'))
+    const depStr = match[2]
+    // 兼容两种写法：task-01, task-02 或 01, 02
+    const depList = depStr.split(/[,，]\s*/).map(s => {
+      const num = s.trim().match(/\d+/)
+      return num ? `task-${num[0].padStart(2, '0')}` : null
+    }).filter(Boolean)
     if (!deps[task]) deps[task] = []
     for (const d of depList) {
       if (!deps[task].includes(d)) deps[task].push(d)

package/src/index.js

@@ -1692,6 +1692,19 @@ SillySpec worktree — git worktree 隔离管理
             for (const f of result.changedFiles) {
               console.log(`   ${f}`);
             }
+            // 跨仓 worktree 回落报告（坑 cross-repo-no-worktree-isolation）：跨仓文件不进主仓
+            // changedFiles（在其所属仓的 diff 里），单独列出防漏看
+            if (Array.isArray(result.crossRepoApplied) && result.crossRepoApplied.length > 0) {
+              for (const c of result.crossRepoApplied) {
+                if (c.changedFiles.length > 0) {
+                  console.log(`✅ 跨仓 repo ${c.repoKey} 已回落 ${c.changedFiles.length} 个文件变更（worktree 已清理，分支保留作 review 锚点）:`);
+                  for (const f of c.changedFiles.slice(0, 20)) console.log(`   ${f}`);
+                  if (c.changedFiles.length > 20) console.log(`   … 共 ${c.changedFiles.length} 个`);
+                } else {
+                  console.log(`ℹ️ 跨仓 repo ${c.repoKey} 无交付变更（worktree 已清理）`);
+                }
+              }
+            }
             // filterDeliverableFiles 精细化排除（保留 .sillyspec/docs/，排 changes/+.runtime/+quicklog/ + meta.json）：
             // 模块文档（.sillyspec/docs/）= 交付物，会 auto-apply 到主工作区；变更文档/运行时/quicklog 不 apply。
             // 须告知 agent 哪些未落地，否则它期望这些文件落地却找不到（memory: worktree-apply-excludes-module-docs）。
@@ -1878,6 +1891,18 @@ SillySpec worktree — git worktree 隔离管理
             // 与并行会话的 apply/cleanup 互踩会互相清——与其他写主仓操作共用一把 main-repo.lock
             const { withMainRepoLock } = await import('./worktree-apply.js');
             const result = await withMainRepoLock(dir, wtName, 'worktree-cleanup', () => wm.cleanup(wtName, { force: forceFlag }));
+            // 跨仓 worktree（坑 cross-repo-no-worktree-isolation）：与主仓同锁清理——跨仓 worktree
+            // 注册在各跨仓仓 .git 内，但目录/meta 在主仓 .sillyspec 运行时区，同样怕并发互踩
+            const { cleanupCrossWorktrees } = await import('./worktree-cross.js');
+            const crossResult = cleanupCrossWorktrees({ cwd: dir, changeName: wtName, specBase: resolvePlatformSpecDir(dir, specDir), force: forceFlag });
+            for (const cr of crossResult.results) {
+              if (cr.result === 'cleaned') {
+                console.log(`✅ 跨仓 worktree 已清理: repo=${cr.repoKey}（${(cr.details || []).filter(d => d.startsWith('分支')).join('；') || '详情见上'}）`);
+              } else if (cr.result === 'partial') {
+                console.error(`🚫 跨仓 repo=${cr.repoKey} 清理受阻：${(cr.details || []).join('; ')}`);
+                for (const r of cr.residual || []) console.error(`   残留: ${r}`);
+              }
+            }
             if (result.result === 'cleaned' || result.result === 'force-cleaned') {
               console.log(`✅ worktree 已清理: ${wtName} (mode: ${result.mode})`);
               if (result.details?.length > 0) {

package/src/progress/stage-machine.js

@@ -349,7 +349,9 @@ export class StageMachine {
             command: `sillyspec run ${s} --continue --answer "用户回答"${cc}`,
           };
         }
-        const hasPending = sd.steps.some(st => ['pending', 'waiting', 'failed'].includes(st.status));
+        // blocked（deps/review.json 门控阻断标记）也计入待办（坑 deps-gate-blocked-invisible）：
+        // 漏计会让全局「下一步」建议跳过被阻断的阶段/步骤，误导 agent 去跑更后面的阶段。
+        const hasPending = sd.steps.some(st => ['pending', 'waiting', 'failed', 'blocked'].includes(st.status));
         if (hasPending) {
           return {
             text: `${STAGE_LABELS[s] || s} 进行中，继续执行下一步。`,

package/src/run/command.js

@@ -23,7 +23,7 @@ import { basename, join, resolve, dirname } from 'node:path'
 import { existsSync, readdirSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs'
 import { randomBytes, randomUUID } from 'node:crypto'
 import { writeAtomicSync } from '../fs-atomic.js'
-import { resolveSpecDir, countAncestorSpecDirs, resolveChangeDir, triggerSync, getStageSteps, formatWaitOptions, checkApproval, warnApprovalUnknown, didYouMean, assertSafeChangeName, detectQuickSessionDrift, detectWorktreeSpecDrift, resolveRuntimeRoot, writePlatformPointer, checkPlatformManaged, isSelfReferentialSpecRoot, PLATFORM_MANAGED_FILENAME } from './shared.js'
+import { resolveSpecDir, countAncestorSpecDirs, ancestorSpecDirs, resolveAncestorCeiling, resolveChangeDir, triggerSync, getStageSteps, formatWaitOptions, checkApproval, warnApprovalUnknown, didYouMean, assertSafeChangeName, detectQuickSessionDrift, detectWorktreeSpecDrift, resolveRuntimeRoot, writePlatformPointer, checkPlatformManaged, isSelfReferentialSpecRoot, PLATFORM_MANAGED_FILENAME } from './shared.js'
 import { resolveQuickLinkedChanges } from './quick-audit.js'
 import { outputStep, collectStageWaitHistory } from './prompt.js'
 import { completeStep, skipStep, waitStep, continueStep } from './complete.js'
@@ -385,14 +385,26 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
   // let：下方 worktree 副本漂移守卫命中时锚回 wt.mainSpecBase（task-05/D-03）
   let specBase = platformOpts.specRoot || join(cwd, '.sillyspec')
 
-  // 漂移提醒:cwd 祖先链 ≥2 个 .sillyspec = monorepo 多实例,当前命中的「最近」实例
+  // 漂移阻断:cwd 祖先链 ≥2 个 .sillyspec = monorepo 多实例,当前命中的「最近」实例
   // 可能不是用户意图的项目(如 cd 进被独立 scan 的子项目跑测试后忘回根)。
-  // 平台模式 / 显式 --spec-dir 跳过(已明确指定,无歧义)。仅提醒不阻断。
+  // 平台模式 / 显式 --spec-dir 跳过(已明确指定,无歧义)。
+  // 当前实例 ≠ git 顶层仓库实例 → 默认拒绝(坑 monorepo-cwd-wrong-spec-instance)。
   if (!platformOpts.specRoot && !specDir) {
-    const ancestorCount = countAncestorSpecDirs(cwd)
-    if (ancestorCount >= 2) {
-      console.warn(`⚠️  检测到祖先链有 ${ancestorCount} 个 .sillyspec 实例(monorepo 多实例),当前使用: ${specBase}`)
-      console.warn(`    若意图是另一个项目:cd 回该项目根,或用 --spec-dir <根>/.sillyspec 显式指定。`)
+    const ancestorSpecs = ancestorSpecDirs(cwd)
+    if (ancestorSpecs.length >= 2) {
+      // 判断当前命中的 .sillyspec 是否在 git 顶层仓库根下
+      const gitRoot = resolveAncestorCeiling(resolve(cwd))
+      const currentSpecParent = dirname(resolve(specBase))
+      const isAtGitRoot = gitRoot && resolve(currentSpecParent) === resolve(gitRoot)
+      if (!isAtGitRoot) {
+        console.error(`❌ 检测到祖先链有 ${ancestorSpecs.length} 个 .sillyspec 实例(monorepo 多实例)，当前使用: ${specBase}`)
+        console.error(`   当前 cwd 不在 git 顶层仓库根下，静默绑定到子项目实例会导致进度/QUICKLOG 分裂。`)
+        console.error(`   修复：cd 回项目根目录，或用 --spec-dir <根>/.sillyspec 显式指定。`)
+        process.exit(2)
+      }
+      // 在 git 根下但有多实例(子项目也有 .sillyspec)→ 仅警告(正确实例已命中)
+      console.warn(`⚠️  检测到祖先链有 ${ancestorSpecs.length} 个 .sillyspec 实例(monorepo 多实例)，当前使用: ${specBase}`)
+      console.warn(`    当前已绑定 git 顶层仓库实例。若意图是子项目:用 --spec-dir 显式指定。`)
     }
   }
 
@@ -896,7 +908,7 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
     if (readonlySteps && readonlySteps.length > 0) {
       // 已有进度（历史 seed 过）则渲染当前待办步；无进度从首步开始
       const existingSteps = progress.stages?.[stageName]?.steps
-      const pendingIdx = existingSteps ? existingSteps.findIndex(s => s.status === 'pending' || s.status === 'in-progress') : -1
+      const pendingIdx = existingSteps ? existingSteps.findIndex(s => s.status === 'pending' || s.status === 'in-progress' || s.status === 'blocked') : -1
       const stepIdx = pendingIdx !== -1 ? pendingIdx : 0
       await outputStep(stageName, stepIdx, readonlySteps, cwd, readOnlyChange, progress.project || null, platformOpts, null, collectStageWaitHistory(progress, stageName))
     }
@@ -1295,7 +1307,7 @@ function showStatus(progress, stageName, nextSuggestion = null) {
 
   console.log('')
 
-  const firstPending = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
+  const firstPending = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress' || s.status === 'blocked')
 
   if (progress.batchProgress) {
     const bp = progress.batchProgress
@@ -1314,10 +1326,13 @@ function showStatus(progress, stageName, nextSuggestion = null) {
   }
 
   steps.forEach((step, i) => {
-    const icon = step.status === 'completed' ? '✅' : step.status === 'skipped' ? '⏭️' : step.status === 'waiting' ? '⏸️' : '⬜'
-    const isCurrent = (step.status === 'pending' || step.status === 'in-progress') && i === firstPending
+    const icon = step.status === 'completed' ? '✅' : step.status === 'skipped' ? '⏭️' : step.status === 'waiting' ? '⏸️' : step.status === 'blocked' ? '🚫' : '⬜'
+    const isCurrent = (step.status === 'pending' || step.status === 'in-progress' || step.status === 'blocked') && i === firstPending
     const isWaiting = step.status === 'waiting'
-    console.log(`${icon} Step ${i + 1}: ${step.name}${isCurrent ? ' ← 当前' : ''}${isWaiting ? ' [WAITING]' : ''}`)
+    console.log(`${icon} Step ${i + 1}: ${step.name}${isCurrent ? ' ← 当前' : ''}${isWaiting ? ' [WAITING]' : ''}${step.status === 'blocked' ? ' [BLOCKED]' : ''}`)
+    if (step.status === 'blocked') {
+      console.log(`       此前被门控阻断——${step.blockReason || 'deps 未就绪 / review.json 不完整'}；修复后重跑 --done 即恢复，无需 --reset`)
+    }
     if (isWaiting) {
       if (step.waitReason) console.log(`       原因：${step.waitReason}`)
       if (step.waitOptions) console.log(`       选项：${formatWaitOptions(step.waitOptions)}`)
@@ -1355,6 +1370,22 @@ async function resetStage(pm, progress, stageName, cwd, changeName, platformOpts
     } catch (e) {
       console.warn(`⚠️  reset 清理 worktree 失败（不阻断 reset）: ${e.message}`)
     }
+    // 跨仓 worktree 一并清理（坑 cross-repo-no-worktree-isolation）：否则下次 execute 因 meta
+    // 存在复用带脏状态的旧跨仓 worktree
+    try {
+      const { cleanupCrossWorktrees } = await import('../worktree-cross.js')
+      const cross = cleanupCrossWorktrees({
+        cwd, changeName,
+        specBase: platformOpts?.specRoot || join(cwd, '.sillyspec'),
+        force: true,
+      })
+      for (const cr of cross.results) {
+        if (cr.result === 'cleaned') console.log(`🧹 已清理跨仓 worktree repo=${cr.repoKey}，下次 execute 将重建`)
+        else if (cr.result === 'partial') console.warn(`⚠️ 跨仓 repo=${cr.repoKey} 清理残留: ${(cr.details || []).join('; ')} ${(cr.residual || []).join('; ')}`)
+      }
+    } catch (e) {
+      console.warn(`⚠️  reset 清理跨仓 worktree 失败（不阻断 reset）: ${e.message}`)
+    }
   }
   const defSteps = await getStageSteps(stageName, cwd, progress, platformOpts?.specRoot || null)
   progress.stages[stageName] = {
@@ -1484,7 +1515,7 @@ async function runAutoMode(pm, progress, cwd, flags, changeName, platformOpts =
     console.log('')
 
     const defSteps = await getAutoSteps(currentStage)
-    const pendingIdx = progress.stages[currentStage]?.steps?.findIndex(step => step.status === 'pending' || step.status === 'in-progress') ?? -1
+    const pendingIdx = progress.stages[currentStage]?.steps?.findIndex(step => step.status === 'pending' || step.status === 'in-progress' || step.status === 'blocked') ?? -1
     if (pendingIdx === -1) {
       const wsIdx = progress.stages[currentStage]?.steps?.findIndex(step => step.status === 'waiting') ?? -1
       if (wsIdx !== -1) {
@@ -1536,7 +1567,7 @@ async function runAutoMode(pm, progress, cwd, flags, changeName, platformOpts =
     return
   }
 
-  const nextPendingIdx = progress.stages[currentStage]?.steps?.findIndex(step => step.status === 'pending' || step.status === 'in-progress') ?? -1
+  const nextPendingIdx = progress.stages[currentStage]?.steps?.findIndex(step => step.status === 'pending' || step.status === 'in-progress' || step.status === 'blocked') ?? -1
   if (nextPendingIdx !== -1) {
     const defSteps = await getAutoSteps(currentStage)
     // execute 阶段启动前检查审批
@@ -1615,7 +1646,7 @@ async function runAutoMode(pm, progress, cwd, flags, changeName, platformOpts =
 
   console.log(`\n${currentStage} complete. Auto advanced to ${next}.`)
   const nextSteps = await getAutoSteps(next)
-  const firstPending = progress.stages[next]?.steps?.findIndex(step => step.status === 'pending' || step.status === 'in-progress') ?? -1
+  const firstPending = progress.stages[next]?.steps?.findIndex(step => step.status === 'pending' || step.status === 'in-progress' || step.status === 'blocked') ?? -1
   if (firstPending !== -1) {
     // execute 阶段启动前检查审批
     if (next === 'execute' && !skipApproval) {

package/src/run/complete-handlers.js

@@ -1385,6 +1385,26 @@ export async function handleExecuteWorktreeCleanup({ stageName, changeName, cwd
     } catch (e) {
       console.warn(`🔗 Worktree: check failed — ${e.message}`);
     }
+    // 跨仓 worktree（坑 cross-repo-no-worktree-isolation）：execute 完成时不自动清——交付还在
+    // 跨仓 worktree 分支上未回落主工作副本，与主仓「pending apply」同语义，报状态 + 下一步指引
+    try {
+      const { listCrossWorktreeMetas } = await import('../worktree-cross.js')
+      const specBase = join(cwd, '.sillyspec')
+      for (const { repoKey, meta: cm } of listCrossWorktreeMetas(specBase, changeName)) {
+        let pending = 0
+        try {
+          const d = safeGit(cm.worktreePath, ['diff', '--name-only', cm.baseHash], { timeout: 30000 })
+          const u = safeGit(cm.worktreePath, ['ls-files', '--others', '--exclude-standard'], { timeout: 30000 })
+          pending = ((d.value || '') + '\n' + (u.value || '')).split('\n').filter(Boolean).length
+        } catch { /* 状态探测失败按未知处理 */ }
+        if (pending > 0) {
+          console.log(`🔗 跨仓 worktree repo=${repoKey}: pending apply (${pending} 个未回落变更)`)
+          console.log(`   下一步: sillyspec worktree apply ${changeName}（跨仓与主仓一并回落）`)
+        } else {
+          console.log(`🔗 跨仓 worktree repo=${repoKey}: 无未回落变更（apply 时将自动清理）`)
+        }
+      }
+    } catch { /* 跨仓状态报告 best-effort */ }
   }
   return null
 }

package/src/run/complete.js

@@ -103,7 +103,16 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   }
 
   const steps = stageData.steps
-  let currentIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
+  // blocked（deps/review.json 门控阻断标记）也视为当前步骤（坑 deps-gate-blocked-invisible，
+  // 2026-08-27 实证）：门控阻断时 enforceDepsGate/enforceReviewJsonGate 把当前步置 blocked 后
+  // exit(1)，若谓词漏 blocked，被阻断步骤对 findIndex 永久隐身——重试 --done 落到其后第一个
+  // pending 步骤上（错步记账，DB 显示与事实脱节），且 blocked 步骤无任何恢复路径（状态机卡死，
+  // 只能 --reset 丢进度）。门控本身在下方会重新校验：deps 已修复 → 正常完成；未修复 → 再次
+  // 阻断同一步（幂等，不污染后续步骤）。
+  let currentIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress' || s.status === 'blocked')
+  if (currentIdx !== -1 && steps[currentIdx].status === 'blocked') {
+    console.log(`⚠️  Step "${steps[currentIdx].name}" 此前被门控阻断（blocked），本次 --done 重新校验门控后继续推进。`)
+  }
   // ── 坑1：--done --answer 解「已 waiting 的步骤」──
   // findIndex 仅查 pending/in-progress，排除 waiting；故 --done --answer 落到已 --wait 暂停的
   // requiresWait 步骤时会跳过它、把 --answer 静默丢弃，步骤永久卡 WAITING、末步报「等待用户输入」。

package/src/run/gates.js

@@ -321,10 +321,42 @@ 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
@@ -411,7 +443,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) {

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

package/src/run/stage.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)

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 = {}) {

package/src/stages/execute.js

@@ -1006,14 +1006,19 @@ ${indexLines}
       return { taskNum, repo, workdir }
     })
 
-    // D-010 跨仓 task base 锡点：派发前实时 git rev-parse HEAD 落 task 卡 base_commit
-    // 仅对跨仓 task（repo≠'main'）落盘，主仓 task 锚 meta.baseHash（MultiRepoContext 已处理）
+    // D-010 跨仓 task base 锡点：派发前落 task 卡 base_commit
+    // 仅对跨仓 task（repo≠'main'）落盘，主仓 task 锚 meta.baseHash（MultiRepoContext 已处理）。
+    // worktree 模式（跨仓 worktree 隔离，坑 cross-repo-no-worktree-isolation）优先 entry.baseCommitHint
+    //（= meta.baseHash 创建时快照）——worktree HEAD 会随子代理 commit 推进，rev-parse HEAD 当 base
+    // 会把 Wave 内前序 task 的交付错算进后续 task 的 base；legacy 直写模式沿用跨仓根实时 HEAD。
     const baseCommitCache = new Map() // 同仓多 task 只 spawn 一次
     for (const item of perTaskWorkdirs) {
       if (item.repo === 'main') continue
       const entry = ctx.resolve(item.repo)
       if (!entry) continue
-      if (!baseCommitCache.has(entry.gitDir)) baseCommitCache.set(entry.gitDir, gitQuiet(entry.gitDir, ['rev-parse', 'HEAD']))
+      if (!baseCommitCache.has(entry.gitDir)) {
+        baseCommitCache.set(entry.gitDir, entry.baseCommitHint || gitQuiet(entry.gitDir, ['rev-parse', 'HEAD']))
+      }
       const baseCommit = baseCommitCache.get(entry.gitDir)
       if (!baseCommit) continue // git 不可达已由 MultiRepoContext 构造时 fail-closed 拦截，此处置防御
       const taskFile = changeDir
@@ -1023,28 +1028,43 @@ ${indexLines}
       baseCommitWrites.push({ taskNum: item.taskNum, repo: item.repo, taskFile, written, baseCommit })
     }
 
-    // 跨仓 task commit 指引 + head_commit 落盘指引（D-010 回收时机）
+    // 跨仓 task commit 指引 + head_commit 落盘指引（D-010 回收时机）。
+    // worktree 模式（跨仓 worktree 隔离）：子代理在跨仓 worktree 分支改+commit，apply 阶段 CLI
+    // 统一 patch 回跨仓主工作区（与主仓同构）；legacy 直写模式保留原文案（commit 直落跨仓主干）。
+    const crossWorktreeItems = perTaskWorkdirs.filter(i => {
+      const e = i.repo !== 'main' ? ctx.resolve(i.repo) : null
+      return e && e.isWorktree
+    })
+    const crossLegacyItems = perTaskWorkdirs.filter(i => i.repo !== 'main' && !crossWorktreeItems.some(w => w.taskNum === i.taskNum))
     const crossLines = perTaskWorkdirs
       .filter(i => i.repo !== 'main')
-      .map(i => `- task-${i.taskNum} → repo \`${i.repo}\`，workdir=\`${i.workdir}\``)
+      .map(i => {
+        const e = ctx.resolve(i.repo)
+        return `- task-${i.taskNum} → repo \`${i.repo}\`，workdir=\`${i.workdir}\`${e && e.isWorktree ? '（worktree 隔离）' : ''}`
+      })
       .join('\n')
-    crossRepoCommitSection = `
-### 跨仓 task 派发与双锡点
-
-本 Wave 含跨仓 task（直接改跨仓仓主干，**不经主仓 worktree**）：
+    const crossWorktreeSection = crossWorktreeItems.length > 0 ? `
 
-${crossLines}
+**跨仓 worktree task（repo 已建 worktree 隔离）——像主仓 task 一样工作：**
+- 子代理在 workdir（跨仓 worktree）内改+commit（git add + git commit 到 worktree 当前分支），**不要碰跨仓主工作副本**。
+- apply 阶段 CLI 统一把各跨仓 worktree 的交付 patch 回对应跨仓主工作区（勿手工 apply）。
+- base 已锚 worktree meta.baseHash（创建时快照），review 的 base/head 由 CLI 按 task 卡锡点解析。` : ''
+    const crossLegacySection = crossLegacyItems.length > 0 ? `
 
 **派发跨仓 task 前（base 锡点，CLI 已在 prompt 构造时落盘）：**
 - 跨仓 task 卡 frontmatter 的 \`base_commit\` 已由 CLI 实时 \`git -C <跨仓仓根> rev-parse HEAD\` 锁定（base 锡点，约束①）。子代理在此 HEAD 上改+commit，不受同 Wave 其他 task 推进 HEAD 影响。
 
+**跨仓 task 子代理 prompt 必须注入（legacy 直写模式）：**
+> 该 task 改的是 \`<repo>\` 仓，workdir=\`<跨仓仓根>\`。**直接在该仓主干工作区改+commit（git add + git commit 到该仓主干），不经主仓 worktree、不建分支。** commit 到该仓主干即落盘，apply 阶段对跨仓 task 为 no-op（design §5.4 G1）。
+> task 卡 allowed_paths 是相对**该仓根**的路径（如 \`src/routes/x.js\`）——不带仓库名前缀（\`<repo>/src/...\` ❌）、不是绝对路径；在 workdir 下直接按相对路径定位文件。` : ''
+    crossRepoCommitSection = `
+### 跨仓 task 派发与双锡点
+
+${crossLines}${crossWorktreeSection}${crossLegacySection}
+
 **回收跨仓 task（head 锡点，CLI 自动落盘，勿手写）：**
-- 子代理完成 commit 后，正常写 review.json（verdict/notes）并勾选 checkbox 即可。execute \`--done\` 时 CLI 自动 \`git -C <跨仓仓根> rev-parse HEAD\` 写入该 task 卡 \`head_commit:\`（幂等，已存在不覆盖——你若手写了精确锚点则以你的为准）。
+- 子代理完成 commit 后，正常写 review.json（verdict/notes）并勾选 checkbox 即可。execute \`--done\` 时 CLI 自动对跨仓仓（worktree 模式=该仓 worktree，legacy=仓根）\`git rev-parse HEAD\` 写入该 task 卡 \`head_commit:\`（幂等，已存在不覆盖——你若手写了精确锚点则以你的为准）。
 - review.json 的 mechanics 字段（\`base\`/\`head\`/\`changedFiles\`）无需手算：\`base\` 取 task 卡 \`base_commit\`、\`head\` 取 task 卡 \`head_commit\`，写完跑 \`sillyspec backfill-reviews --change <变更名> --adopt\` 一键代填（verdict 保留）。
-
-**跨仓 task 子代理 prompt 必须注入：**
-> 该 task 改的是 \`<repo>\` 仓，workdir=\`<跨仓仓根>\`。**直接在该仓主干工作区改+commit（git add + git commit 到该仓主干），不经主仓 worktree、不建分支。** commit 到该仓主干即落盘，apply 阶段对跨仓 task 为 no-op（design §5.4 G1）。
-> task 卡 allowed_paths 是相对**该仓根**的路径（如 \`src/routes/x.js\`）——不带仓库名前缀（\`<repo>/src/...\` ❌）、不是绝对路径；在 workdir 下直接按相对路径定位文件。
 `
   }