sillyspec 3.22.1 → 3.22.3

package/src/index.js

@@ -297,6 +297,20 @@ async function main() {
       break;
     }
     case 'run': {
+      // doctor --json 等价 doctor 顶层 --json（结构化诊断），与 case 'doctor' 行为一致——
+      // 否则 sillyspec doctor --json 走 runDoctorDiagnostics，sillyspec run doctor --json 走 runCommand
+      // prompt 自检，两者输出不等价（违反"顶层别名 == run <stage>"契约）。
+      if (filteredArgs[1] === 'doctor' && json) {
+        const doctorEffectiveDir = specDir ? dir : resolveEffectiveDir(dir)
+        const { runDoctorDiagnostics, formatDoctorJson, writeDoctorDiagnosis } = await import('./doctor-diagnostics.js')
+        const result = await runDoctorDiagnostics({ cwd: doctorEffectiveDir })
+        const output = formatDoctorJson(result, { source_root: dir })
+        const written = writeDoctorDiagnosis(output, result.authoritySpecDir)
+        if (written) console.error(`📁 诊断结果已写入: ${written}`)
+        console.log(JSON.stringify(output, null, 2))
+        process.exitCode = output.overall_status === 'pass' ? 0 : 1
+        break
+      }
       const { runCommand } = await import('./run.js')
       // 平台模式（--spec-dir 已指定）时，--dir 是明确的 source_root，不应被 resolveEffectiveDir 纠正
       const effectiveDir = specDir ? dir : resolveEffectiveDir(dir)
@@ -317,6 +331,57 @@ async function main() {
       const pathIdx = filteredArgs.indexOf('--path');
       const dbPath = pathIdx >= 0 && filteredArgs[pathIdx + 1] ? filteredArgs[pathIdx + 1] : null;
 
+      // --align-execute-progress：基于 plan.md 声明对齐 execute 派生戳（仿 --cleanup-remnant 范式）
+      // 默认 dry-run（只报告将补哪些 step），加 --confirm 才写。命中即 break，绝不 fall-through。
+      const alignFlag = filteredArgs.includes('--align-execute-progress');
+      if (alignFlag) {
+        // --change 解析：显式优先，缺省用单活跃变更自动兜底（与 run.js resolveChangeNameAuto 同逻辑）
+        const alignChangeIdx = filteredArgs.indexOf('--change');
+        let alignChange = alignChangeIdx >= 0 && filteredArgs[alignChangeIdx + 1] ? filteredArgs[alignChangeIdx + 1] : null;
+        if (!alignChange) {
+          const changesDir = join(resolvePlatformSpecDir(doctorEffectiveDir, specDir) || join(doctorEffectiveDir, '.sillyspec'), 'changes');
+          if (existsSync(changesDir)) {
+            const activeChanges = readdirSync(changesDir, { withFileTypes: true })
+              .filter(e => e.isDirectory() && e.name !== 'archive')
+              .map(e => e.name);
+            if (activeChanges.length === 1) alignChange = activeChanges[0];
+          }
+        }
+        if (!alignChange) {
+          console.error('❌ 无法确定变更名：请用 --change <name>，或确保仅有一个活跃变更');
+          process.exitCode = 2;
+          break;
+        }
+
+        // 复用顶层静态 import（line 12），不动态 await import
+        const pm = new ProgressManager({ specDir: resolvePlatformSpecDir(doctorEffectiveDir, specDir) });
+        const specBase = resolvePlatformSpecDir(doctorEffectiveDir, specDir) || join(doctorEffectiveDir, '.sillyspec');
+        let r;
+        try {
+          r = await pm.alignExecuteToPlan(doctorEffectiveDir, alignChange, specBase, { confirm: doctorConfirm });
+        } catch (e) {
+          console.error(`❌ 对齐失败：${e.message}`);
+          process.exitCode = 1;
+          break;
+        }
+
+        if (json) {
+          console.log(JSON.stringify(r, null, 2));
+        } else if (r.ok === false) {
+          console.error(`❌ ${r.reason || '对齐未执行'}`);
+        } else {
+          console.log(`✅ 已基于 plan.md 声明对齐 ${r.aligned} 个 step（plan: ${r.planChecked}/${r.planTotal}）。`);
+          if (!doctorConfirm) {
+            console.log(`   （dry-run：未写盘。加 --confirm 实际落盘，并置 execute 阶段 status=completed。）`);
+          } else {
+            console.log(`   已落盘，execute 阶段 status=completed。请确认 verify 通过。`);
+          }
+        }
+        // ok=false 或 reason 非空 → 1；否则 0（与 --cleanup-remnant 的 r.errors 逻辑同构）
+        process.exitCode = (r.ok === false || r.reason) ? 1 : 0;
+        break;
+      }
+
       if (cleanupRemnant) {
         const { cleanupRemnantDbs } = await import('./doctor-diagnostics.js');
         const r = await cleanupRemnantDbs({ cwd: doctorEffectiveDir, confirm: doctorConfirm });

package/src/progress.js

@@ -1799,4 +1799,115 @@ export class ProgressManager {
       writeFileSync(gitignorePath, rule + '\n');
     }
   }
+
+  // ── plan.md 对齐（doctor --align-execute-progress 入口）──
+
+  /**
+   * 解析 changeDir/plan.md（回退 tasks.md）的 task checkbox 统计。
+   * 仅匹配 `- [ ] task-NN` / `- [x] task-NN` 形态的行（task- 前缀锚定，避免误捞非任务项）。
+   * @param {string} changeDir - 变更目录绝对路径（含 plan.md/tasks.md）
+   * @returns {{ total: number, checked: number }}
+   */
+  readPlanCheckboxStatus(changeDir) {
+    if (!changeDir || typeof changeDir !== 'string') {
+      throw new Error('changeDir 不能为空');
+    }
+    const planPath = join(changeDir, 'plan.md');
+    const tasksPath = join(changeDir, 'tasks.md');
+    let content = null;
+    if (existsSync(planPath)) {
+      content = readFileSync(planPath, 'utf8');
+    } else if (existsSync(tasksPath)) {
+      content = readFileSync(tasksPath, 'utf8');
+    } else {
+      return { total: 0, checked: 0 };
+    }
+    // 匹配 `- [ ] task-NN` / `- [x] task-NN`（允许 [x] 大小写、空格弹性、task- 前缀）
+    const re = /^\s*[-*]\s+\[([ xX])\]\s+task-\d+/gm;
+    let total = 0;
+    let checked = 0;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      total++;
+      if (m[1] === 'x' || m[1] === 'X') checked++;
+    }
+    return { total, checked };
+  }
+
+  /**
+   * 按 plan.md 声明对齐 execute 阶段派生进度戳。
+   * 仅当 plan.md 所有 task checkbox 全勾时，把 execute 阶段所有非 completed step 标 completed，
+   * 并显式置 execute stageData.status='completed' + completedAt（绕过 completeStep 推导，D-003@v2）。
+   * 不复核代码，信任 plan.md 声明（与 archive 同源，verify 阶段兜底，D-002/D-004）。
+   *
+   * @param {string} cwd
+   * @param {string} changeName
+   * @param {string} specBase - platformOpts.specRoot || join(cwd, '.sillyspec')，用于定位 changes 目录
+   * @param {object} [opts]
+   * @param {boolean} [opts.confirm=false] - 默认 dry-run，仅当 confirm=true 才落盘
+   * @returns {Promise<{ ok: boolean, aligned: number, skipped: number, planTotal: number, planChecked: number, reason?: string, dryRun?: boolean }>}
+   */
+  async alignExecuteToPlan(cwd, changeName, specBase, opts = {}) {
+    if (!changeName) throw new Error('changeName 不能为空');
+    const { confirm = false } = opts;
+
+    // 1. 读 progress；无 progress / 无 execute 阶段 → 拒绝
+    const progress = await this.read(cwd, changeName);
+    if (!progress || !progress.stages || !progress.stages.execute) {
+      return { ok: false, aligned: 0, skipped: 0, planTotal: 0, planChecked: 0, reason: 'execute 阶段无进度数据' };
+    }
+    const executeStage = progress.stages.execute;
+    const steps = Array.isArray(executeStage.steps) ? executeStage.steps : [];
+    if (steps.length === 0) {
+      return { ok: false, aligned: 0, skipped: 0, planTotal: 0, planChecked: 0, reason: 'execute 阶段无进度数据' };
+    }
+
+    // 2. 读 plan.md checkbox；未全勾 → 拒绝（D-002）
+    const specRoot = specBase || this._getSpecDir(cwd);
+    const changeDir = join(specRoot, CHANGES_SUBDIR, changeName);
+    const { total: planTotal, checked: planChecked } = this.readPlanCheckboxStatus(changeDir);
+    if (planTotal === 0) {
+      return { ok: false, aligned: 0, skipped: 0, planTotal, planChecked, reason: 'plan.md 无 task checkbox（无法判定完成度）' };
+    }
+    if (planChecked < planTotal) {
+      return {
+        ok: false,
+        aligned: 0,
+        skipped: 0,
+        planTotal,
+        planChecked,
+        reason: `plan.md 有未勾选 task（${planChecked}/${planTotal}），拒绝对齐`,
+      };
+    }
+
+    // 3. 全勾：计算将补哪些 step
+    const now = new Date().toISOString();
+    let aligned = 0;
+    let skipped = 0;
+    for (const step of steps) {
+      if (step.status === 'completed') {
+        skipped++;
+        continue;
+      }
+      aligned++;
+      if (confirm) {
+        step.status = 'completed';
+        step.completedAt = now;
+      }
+    }
+
+    // dry-run：只报告，不落盘
+    if (!confirm) {
+      return { ok: true, aligned, skipped, planTotal, planChecked, dryRun: true };
+    }
+
+    // 4. confirm：显式置 execute stageData.status='completed' + completedAt（D-003@v2，复刻 run.js:2303-2304）
+    executeStage.status = 'completed';
+    executeStage.completedAt = now;
+    progress.currentStage = progress.currentStage || 'execute';
+    progress.lastActive = now;
+    await this._write(cwd, progress, changeName);
+
+    return { ok: true, aligned, skipped, planTotal, planChecked };
+  }
 }

package/src/run.js

@@ -4,7 +4,7 @@
  * CLI 成为流程引擎，AI 变成步骤执行器。
  * 支持多变更并行：每个变更状态存储在 sillyspec.db 中。
  */
-import { basename, join, resolve, dirname } from 'path'
+import { basename, join, resolve, dirname, relative, isAbsolute } from 'path'
 import { existsSync, readdirSync, mkdirSync, writeFileSync, appendFileSync, readFileSync, rmSync, statSync } from 'fs'
 import { createRequire } from 'module'
 const require = createRequire(import.meta.url)
@@ -61,7 +61,8 @@ export function validateParsedProjects(projects, sourceRoot) {
         errors.push(`项目 "${id}" 的 path 包含 .. ，拒绝越界`)
       } else {
         const absPath = resolve(safeRoot, proj.path)
-        if (!absPath.startsWith(safeRoot + '/') && absPath !== safeRoot) {
+        const rel = relative(safeRoot, absPath)
+        if (rel.startsWith('..') || isAbsolute(rel)) {
           errors.push(`项目 "${id}" 的 path "${proj.path}" 解析后超出 source_root`)
         }
         if (!existsSync(absPath)) {
@@ -1585,7 +1586,7 @@ export async function runCommand(args, cwd, specDir = null) {
 
   // --skip
   if (isSkip) {
-    return await skipStep(pm, progress, stageName, cwd, effectiveChange)
+    return await skipStep(pm, progress, stageName, cwd, effectiveChange, platformOpts)
   }
 
   // --wait: 将 step 设为 waiting（独立于 --done）
@@ -2388,19 +2389,35 @@ function isCurrentWaveAllNoDepsVerify(stepName, changeDir) {
 async function enforceDepsGate(stageName, cwd, changeName, step, steps, currentIdx, specBase, platformOpts) {
   if (stageName !== 'execute') return true
   let meta = null
+  let wm = null
   try {
     const { WorktreeManager } = await import('./worktree.js')
-    meta = new WorktreeManager({ cwd }).getMeta(changeName)
+    wm = new WorktreeManager({ cwd })
+    meta = wm.getMeta(changeName)
   } catch {}
   const depsStatus = meta?.depsStatus
   if (['linked', 'installed', 'n/a'].includes(depsStatus)) return true
   const changeDir = changeName ? join(specBase, 'changes', changeName) : null
   if (isCurrentWaveAllNoDepsVerify(step?.name, changeDir)) return true
   if (steps && steps[currentIdx]) steps[currentIdx].status = 'blocked'
-  console.error(`❌ 拒绝 --done：依赖未就绪（depsStatus=${depsStatus || 'unknown'}），不得在无构建/测试能力时声称完成。`)
-  console.error(`   修复：sillyspec worktree doctor --fix${changeName ? ` --change ${changeName}` : ''}`)
-  console.error(`   或在 worktree 内手动安装依赖后重试。`)
-  if (meta?.depsError) console.error(`   上次供给错误：${meta.depsError}`)
+  // ── 诊断分支（Phase 2，G2/R3 修正：判定基于物理目录而非 !meta）──
+  // getMeta 对"目录不存在"与"meta 损坏"都返回 null，后者会误判终态 → 用物理目录存在性判定。
+  let worktreeGone = true
+  try {
+    worktreeGone = !!(wm && changeName) && !existsSync(wm.getWorktreePath(changeName))
+  } catch {}
+  // ── fail-loud 块（Phase 3，D-005@v1：仅改拒绝侧 stderr）──
+  console.error('❌ ── deps 门控阻断（本次 --done 未完成，进度未推进）──')
+  if (worktreeGone) {
+    console.error('   worktree 不可用（已 cleanup 或目录不存在）。')
+    console.error(`   修复：sillyspec doctor --align-execute-progress${changeName ? ` --change ${changeName}` : ''} 按 plan.md 对齐进度`)
+    console.error(`   或：  sillyspec worktree create ${changeName || '<change>'} 重建 worktree 继续跑`)
+  } else {
+    console.error(`   原因：依赖未就绪（depsStatus=${depsStatus || 'unknown'}），不得在无构建/测试能力时声称完成。`)
+    console.error(`   修复：sillyspec worktree doctor --fix${changeName ? ` --change ${changeName}` : ''}`)
+    console.error('   或在 worktree 内手动安装依赖后重试。')
+    if (meta?.depsError) console.error(`   上次供给错误：${meta.depsError}`)
+  }
   process.exit(1)
 }
 
@@ -2481,7 +2498,19 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
   if (currentStepDef.requiresWait === true && !currentStep.waitAnswer) {
     // 检查 --done 是否带了 --answer：如果是，自动补全 waitAnswer 状态，一步完成
     const doneAnswer = typeof options !== 'undefined' && options.doneAnswer ? options.doneAnswer : null
-    if (doneAnswer) {
+    // B4: 前置 step 已对同一问题确认则自动跳过重复 wait。
+    // 归一化去掉「最终/再次/重复」等修饰词，避免 step N「确认 X」与 step M「最终确认 X」重复打断。
+    const normalizeReason = (r) => (r || '').replace(/(最终|再次|重复|最后|首|初次|首次)/g, '').trim()
+    const currentReason = normalizeReason(currentStepDef.waitReason)
+    const priorConfirmed = currentReason && steps.slice(0, currentIdx).some(s =>
+      s.waitAnswer && s.status === 'completed' && normalizeReason(s.waitReason) === currentReason
+    )
+    if (priorConfirmed) {
+      currentStep.status = 'waiting'
+      currentStep.waitAnswer = '前置步骤已对同一问题确认 — 自动跳过重复 wait'
+      currentStep.waitReason = currentStepDef.waitReason || '等待用户输入'
+      console.log(`⚠️  Step "${currentStep.name}" 的确认（${currentStepDef.waitReason}）已在前置步骤完成，自动跳过。`)
+    } else if (doneAnswer) {
       currentStep.status = 'waiting'
       currentStep.waitAnswer = doneAnswer
       currentStep.waitReason = currentStepDef.waitReason || '等待用户输入'
@@ -3096,7 +3125,7 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
               executeRunId = generateExecuteRunId()
             }
 
-            const reviewResult = validateTaskReviews({ planContent, runtimeRoot, executeRunId })
+            const reviewResult = validateTaskReviews({ planContent, runtimeRoot, executeRunId, changeDir: planFile })
             printReviewResult(reviewResult)
 
             if (!reviewResult.ok) {
@@ -3292,7 +3321,7 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
   return { stageCompleted: false, currentIdx, nextPendingIdx }
 }
 
-async function skipStep(pm, progress, stageName, cwd, changeName) {
+async function skipStep(pm, progress, stageName, cwd, changeName, platformOpts = {}) {
   const stageData = progress.stages[stageName]
   if (!stageData || !stageData.steps) {
     console.error(`❌ 阶段 ${stageName} 未初始化`)

package/src/stage-contract.js

@@ -253,14 +253,21 @@ function validateBrainstormOutputs(cwd, changeName, context = {}) {
       warnings.push('design.md 缺少「自审」章节')
     }
 
-    // P1: 涉及生命周期关键词时，design.md 必须包含生命周期契约表
+    // P1: 涉及生命周期关键词时，design.md 必须包含生命周期契约表（除非显式声明不涉及）
     const hasLifecycleKeyword = /\b(session|lease|agent[._-]?run|daemon|lifecycle|state[._-]?transition|claim|heartbeat)\b/i.test(content)
     if (hasLifecycleKeyword) {
-      const hasLifecycleTable =
-        /生命周期契约表|lifecycle[._-]?contract|lifecycle[._-]?matrix|Lifecycle Contract/i.test(content) ||
-        /事件.*发起方.*接收方.*必需字段.*状态变化/.test(content)
-      if (!hasLifecycleTable) {
-        errors.push('design.md 涉及生命周期关键词（session/lease/agent_run/daemon/lifecycle）但缺少「生命周期契约表」— 必须列出完整的事件×状态转换矩阵')
+      // 显式声明本变更不涉及生命周期契约（覆盖字段名/错误码/否定声明场景）：
+      // 历史教训：design 提到 daemon_id 字段名或 daemon_not_owned 错误码就触发，被迫加空表（B3a）
+      const declaresNotApplicable = /(生命周期|lifecycle)[^\n]{0,40}(n\/?a|不涉及|无|none|not[ _-]?applicable)|(不涉及|无需|没有)[^\n]{0,40}(生命周期|lifecycle)/i.test(content)
+      if (declaresNotApplicable) {
+        warnings.push('design.md 显式声明不涉及生命周期契约 — 已豁免「生命周期契约表」要求')
+      } else {
+        const hasLifecycleTable =
+          /生命周期契约表|lifecycle[._-]?contract|lifecycle[._-]?matrix|Lifecycle Contract/i.test(content) ||
+          /事件.*发起方.*接收方.*必需字段.*状态变化/.test(content)
+        if (!hasLifecycleTable) {
+          errors.push('design.md 涉及生命周期关键词（session/lease/agent_run/daemon/lifecycle）但缺少「生命周期契约表」— 必须列出完整的事件×状态转换矩阵；或显式声明「不涉及生命周期契约」并附理由豁免')
+        }
       }
     }
   }
@@ -380,6 +387,22 @@ function validatePlanOutputs(cwd, changeName, context = {}) {
 
   return { ok: errors.length === 0, errors, warnings }
 }
+/**
+ * 从 verify-result.md 提取结论关键词（PASS / PASS WITH NOTES / FAIL）。
+ * 标题放宽：含「结论/Conclusion/Result/结果」的二级标题均可（B3c），
+ * PASS/FAIL 可在标题行本身（如「## 验收结论：✅ PASS」）或紧邻标题的正文里。
+ * 历史教训：原正则锚定确切「## 结论」，用户写「## 验收结论：✅ 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, ' ') : ''
+}
+
 function validateVerifyOutputs(cwd, changeName, context = {}) {
   const { specRoot } = context
   const changeDir = resolveChangeDir(cwd, changeName, specRoot)
@@ -419,12 +442,11 @@ function validateVerifyOutputs(cwd, changeName, context = {}) {
     // ── FAIL 结论门控（适用于所有变更，不限风险等级）──
     // verify-result.md 结论为 FAIL 时，verify 阶段不能 completed。
     // 历史教训：CLI 曾不校验结论，AI 写 FAIL 后 verify 仍被标记完成并提示"验证通过可以归档"。
-    const conclusionLine = verify.match(/^##\s*结论\s*\n\s*(PASS(?:\s+WITH\s+NOTES)?|FAIL)/im)
-    const conclusionStr = conclusionLine ? conclusionLine[1].toUpperCase().replace(/\s+/g, ' ') : ''
+    const conclusionStr = extractVerifyConclusion(verify)
     if (conclusionStr === 'FAIL') {
       errors.push('verify-result.md 结论为 FAIL — 验证未通过，不能标记 verify 完成；请修复后重新运行验证')
     } else if (!conclusionStr) {
-      warnings.push('verify-result.md 未识别到「## 结论」章节（应为 PASS / PASS WITH NOTES / FAIL）')
+      warnings.push('verify-result.md 未识别到结论章节（含 结论/Conclusion/Result/结果 的二级标题，后跟 PASS / PASS WITH NOTES / FAIL）')
     }
 
     // ── P0: Change Risk Gate — 核心功能缺少真实集成验证时 FAIL ──
@@ -433,8 +455,7 @@ function validateVerifyOutputs(cwd, changeName, context = {}) {
       planContent: readIfExists(join(changeDir, 'plan.md')),
     })
     if (['integration-critical', 'deployment-critical'].includes(changeRiskProfile.level)) {
-      const conclusionMatch = verify.match(/^## 结论\s*\n\s*(PASS|PASS WITH NOTES|FAIL)/im)
-      const conclusion = conclusionMatch ? conclusionMatch[1] : ''
+      const conclusion = extractVerifyConclusion(verify)
       if (conclusion === 'PASS WITH NOTES' || conclusion === 'PASS') {
         const evidenceCheck = checkIntegrationEvidence(verify, changeRiskProfile.requiredVerification)
         if (!evidenceCheck.ok) {

package/src/task-review.js

@@ -128,8 +128,26 @@ export function readReview(reviewPath) {
  * @param {boolean} [opts.allowCannotVerify=true] - 是否允许 cannot_verify（默认允许，给 warning）
  * @returns {{ ok: boolean, errors: string[], warnings: string[], requiredEvidence: Array<{task: string, verdict: string, evidence: string[]}> }}
  */
+/**
+ * 读取 task-XX.md frontmatter，判断是否声明 low_risk: true（type-only/机械迁移等低逻辑风险）。
+ * 声明 low_risk 的 task 缺 review.json 时只 warning 不 error（B2：免逐个评审仪式）。
+ */
+function isTaskLowRisk(changeDir, taskId) {
+  if (!changeDir) return false
+  const taskFile = join(changeDir, 'tasks', `${taskId}.md`)
+  if (!existsSync(taskFile)) return false
+  try {
+    const content = readFileSync(taskFile, 'utf8')
+    const fm = content.match(/^---\n([\s\S]*?)\n---/)
+    if (!fm) return false
+    return /^low_risk:\s*true\s*$/im.test(fm[1])
+  } catch {
+    return false
+  }
+}
+
 export function validateTaskReviews(opts) {
-  const { planContent, runtimeRoot, executeRunId, allowCannotVerify = true } = opts
+  const { planContent, runtimeRoot, executeRunId, allowCannotVerify = true, changeDir = null } = opts
 
   const taskIds = parseTaskIdsFromPlan(planContent)
 
@@ -156,8 +174,12 @@ export function validateTaskReviews(opts) {
         // review.json 存在且 JSON 合法，但 schema 校验失败
         errors.push(`${taskId}: review.json 校验失败 — ${result.errors.join('; ')}`)
       } else {
-        // review.json 不存在
-        errors.push(`${taskId}: 缺少 review.json — task 未经过评审`)
+        // review.json 不存在：声明 low_risk 的 task 豁免（B2：type-only/机械迁移免逐个评审）
+        if (isTaskLowRisk(changeDir, taskId)) {
+          warnings.push(`${taskId}: 缺少 review.json — task 声明 low_risk: true，已豁免评审（type-only/机械迁移）`)
+        } else {
+          errors.push(`${taskId}: 缺少 review.json — task 未经过评审`)
+        }
       }
       continue
     }

package/src/worktree-apply.js

@@ -13,7 +13,7 @@
  */
 
 import { execSync } from 'child_process';
-import { existsSync, unlinkSync, writeFileSync, mkdtempSync, rmSync } from 'fs';
+import { existsSync, unlinkSync, writeFileSync, mkdtempSync, rmSync, readdirSync, readFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { tmpdir } from 'os';
 import { createHash } from 'crypto';
@@ -362,7 +362,6 @@ export function assessApplyRisk(changeName, { cwd } = {}) {
   const tasksDir = join(projectRoot, CHANGES_REL, changeName, 'tasks');
   const allowedPaths = new Set();
   if (existsSync(tasksDir)) {
-    const { readdirSync, readFileSync } = require('fs');
     for (const tf of readdirSync(tasksDir).filter(f => /^task-\d+\.md$/.test(f))) {
       const content = readFileSync(join(tasksDir, tf), 'utf8');
       const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
@@ -511,8 +510,7 @@ export function formatExecuteSummary({ changeName, stepsCompleted, stepsTotal, a
     // worktree 还在，用 baselineCommit 或 baseHash 做 diff
     try {
       const diffBase = meta.baselineCommit || meta.baseHash;
-      const { execSync: es } = require('child_process');
-      const filesRaw = es(`git -C ${meta.worktreePath} diff --name-only ${diffBase} 2>/dev/null`, { encoding: 'utf8' });
+      const filesRaw = execSync(`git -C ${meta.worktreePath} diff --name-only ${diffBase} 2>/dev/null`, { encoding: 'utf8' });
       const files = filesRaw ? filesRaw.trim().split('\n').filter(Boolean) : [];
       if (files.length > 0) {
         lines.push(``);

package/src/worktree.js

@@ -9,7 +9,7 @@
  */
 
 import { execSync } from 'child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync, statSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync, statSync, lstatSync, readlinkSync, unlinkSync } from 'fs';
 import { join, resolve, dirname } from 'path';
 import { createHash } from 'crypto';
 import { provisionDeps, lockfileHash } from './worktree-deps.js';
@@ -590,6 +590,29 @@ export class WorktreeManager {
 
     const branch = (meta && meta.branch) || BRANCH_PREFIX + name;
 
+    // Windows 保护：先解链接 worktree/node_modules（junction 指向主 checkout），
+    // 否则后续 git worktree remove / rmSync recursive 会跟随 junction 误删主 node_modules 内容。
+    if (!isInPlace && existsSync(worktreePath)) {
+      const wtNodeModules = join(worktreePath, 'node_modules');
+      if (existsSync(wtNodeModules)) {
+        let isLink = false;
+        try { isLink = lstatSync(wtNodeModules).isSymbolicLink(); } catch {}
+        if (isLink) {
+          try {
+            if (process.platform === 'win32') {
+              // Windows rmdir 删 junction（reparse point）不跟随目标，保护主 checkout
+              execSync(`rmdir "${wtNodeModules}"`, { shell: 'cmd.exe' });
+            } else {
+              unlinkSync(wtNodeModules);
+            }
+            details.push('worktree node_modules junction/symlink removed (protect main checkout)');
+          } catch (e) {
+            details.push(`node_modules link remove failed: ${e.message}`);
+          }
+        }
+      }
+    }
+
     // 1. git worktree remove（带 retry）—— in-place 跳过：无 git worktree 注册，且 worktreePath 即主工作区
     let gitRemoveOk = false;
     if (!isInPlace && existsSync(worktreePath)) {

package/.claude/CLAUDE.md

@@ -1,23 +0,0 @@
-# Claude Code 指引
-
-# SillySpec工具定位
-1. SillySpec 是给 Agent 调用的 CLI 工具，不是给人类直接使用的产品
-2. SillySpec 是管理 Agent 工作流的 CLI 工具，不是处理业务逻辑的工具
-3. 你是 Agent。SillySpec 是你的流程控制器。你通过 CLI 命令告诉它"我在哪"，它告诉你"下一步该做什么"。你执行步骤，它校验产出、推进状态。人类用户只在关键决策点介入审批
-
-## 文件生命周期文档同步
-每次修改 `src/stages/` 下的阶段定义（prompt、步骤、输出文件名等）或 `src/run.js`、`src/progress.js` 等影响文件生命周期的代码后，**必须同步更新** `docs/sillyspec/file-lifecycle.md`，确保文档与代码一致。
-
-### 触发更新的典型改动
-- 新增/删除/重命名阶段步骤
-- 修改步骤 prompt 中的输出文件名（如 verify-result.md）
-- 修改阶段间的流转逻辑（如 archive 归档方式）
-- 新增/删除运行时文件类型（如 gate-status.json）
-- 修改 ProgressManager 的数据存储方式（如 SQLite 表结构变更）
-
-### 更新检查清单
-- [ ] 文件名引用一致（prompt 输出的文件名 == validateFileLocations 期望的文件名）
-- [ ] 阶段步骤描述与 `src/stages/*.js` 一致
-- [ ] 归档/清理流程描述与实际代码逻辑一致
-- [ ] 数据库 Schema 描述与 `src/db.js` 一致
-- [ ] 更新文档头部 `updated_at` 时间戳