sillyspec 3.18.5 → 3.18.6

package/package.json

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

package/src/index.js

@@ -289,6 +289,21 @@ async function main() {
       await runCommand(filteredArgs.slice(1), resolveEffectiveDir(dir), specDir)
       break
     }
+    // task-10: 顶层命令别名，转发 runCommand，与 case 'run': 路径行为一致
+    // help 文本(:44-46)已宣称这些 stage 可直接使用，这里补齐路由避免落 default 分支。
+    // 注意：filteredArgs[0] === command，直接透传 filteredArgs 即可让 runCommand
+    // 从 args[0] 取到 stage 名（run.js:1036）。与 case 'run': 的 filteredArgs.slice(1)
+    // 区别只在于 slice(1) 去掉的是 'run' 字面量，这里 command 本身就是 stage 名不能丢。
+    case 'doctor':
+    case 'scan':
+    case 'status':
+    case 'quick':
+    case 'explore': {
+      const { runCommand } = await import('./run.js')
+      const stageArgs = [command, ...filteredArgs.slice(1)]
+      await runCommand(stageArgs, resolveEffectiveDir(dir), specDir)
+      break
+    }
     case 'dashboard': {
       // Parse dashboard options
       let port = 3456;

package/src/run.js

@@ -11,6 +11,22 @@ const require = createRequire(import.meta.url)
 import { ProgressManager } from './progress.js'
 import { SCAN_STATUS, POINTER_STATUS, isPointerCorrupted } from './constants.js'
 
+/**
+ * 清洗项目名：只保留 ASCII 字母/数字/横线/下划线/点，过滤中文和特殊字符。
+ * - 必须含至少一个字母（拒绝纯数字 "0"/"7"/"07"，避免 scan-projects.json 脏数据）
+ * - 长度必须 ≥ 2（拒绝单字符 "a"/"0"）
+ * @param {string} name - 原始项目名候选
+ * @returns {string | null} 合法项目名或 null（拒绝）
+ */
+export function sanitizeProjectName(name) {
+  if (!name) return null
+  const clean = String(name).replace(/[^a-zA-Z0-9_\-.]/g, '').trim()
+  if (!clean) return null
+  if (!/[a-zA-Z]/.test(clean)) return null    // 纯数字/符号拒绝（"0"/"7"/"07"）
+  if (clean.length < 2) return null           // 单字符拒绝（"a"/"0"）
+  return clean
+}
+
 /**
  * 在容器/Docker 环境下，git 可能因目录所有权不匹配报 dubious ownership。
  * 使用 -c safe.directory= 临时参数，不污染全局 git config。
@@ -666,6 +682,12 @@ async function outputStep(stageName, stepIndex, steps, cwd, changeName, dbProjec
       `2. **不允许**用 cat >、tee、heredoc 等 Bash 方式绕过 Write 工具。\n` +
       `3. 如果 Write 和 Read 均失败，记录失败并停止当前 step。\n` +
       `\n` +
+      `### 📍 Workflow YAML 占位符映射（task-05）\n` +
+      `读取 \`{WORKFLOWS_ROOT}/scan-docs.yaml\` 时，yaml 内的占位符按以下映射替换为绝对路径：\n` +
+      `- \`{SPEC_ROOT}\` → \`${specSillyspec}\`（规范目录根）\n` +
+      `- \`<project>\` → 当前项目名（见下方 step 提示，等于 \`${projectName}\`）\n` +
+      `- 例：\`{SPEC_ROOT}/docs/<project>/scan/ARCHITECTURE.md\` → \`${docsRoot}/scan/ARCHITECTURE.md\`\n` +
+      `\n` +
       `创建目录: \`mkdir -p ${docsRoot}/{scan,modules,flows} ${projectsRoot} ${changesRoot}\`\n`
     )
     if (platformOpts.runtimeRoot) {
@@ -1416,7 +1438,9 @@ async function runStage(pm, progress, stageName, cwd, changeName, skipApproval =
   const specBase = platformOpts.specRoot || join(cwd, '.sillyspec')
   // 状态转换校验
   const prevStage = progress.currentStage || ''
-  const transition = checkTransition(prevStage, stageName)
+  // task-07: 提取 prevStage 的 stageData，传给 checkTransition 检测 failed_post_check 门控
+  const fromStageData = (progress.stages && prevStage && progress.stages[prevStage]) || undefined
+  const transition = checkTransition(prevStage, stageName, fromStageData ? { fromStageData } : {})
   if (!transition.allowed) {
     console.error(`❌ 阶段转换不允许: ${prevStage || '(起始)'} → ${stageName}`)
     console.error(`   原因: ${transition.reason}`)
@@ -2150,16 +2174,15 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
   if (stageName === 'scan' && steps[currentIdx]?.name === '构建扫描项目列表') {
     // 解析项目列表：从 step 2 输出提取，或回退读取 projects/*.yaml
     let projectNames = []
-    // 项目名清洗：只保留 ASCII 字母/数字/横线/下划线/点，过滤中文和特殊字符
-    const sanitizeProjectName = (name) => {
-      const clean = name.replace(/[^a-zA-Z0-9_\-.]/g, '').trim()
-      return clean || null
-    }
+    // sanitizeProjectName 已提取到模块顶层（含字母校验 + 长度≥2）
     if (outputText) {
       // 匹配方式 1: "1. project-name" 编号列表
-      const numbered = outputText.match(/^\s*\d+\.\s+(\S+)/gm)
+      // 正则收紧：token 必须以字母开头，避免误捕获纯数字 "0"/"7" 和步骤说明中英文行
+      const numbered = outputText.match(/^\s*\d+\.\s+([a-zA-Z][\w\-.]*)/gm)
       if (numbered) {
-        const raw = numbered.map(m => m.replace(/^\s*\d+\.\s+/, '').replace(/[—\-:].*$/, '').trim())
+        // task-05 B2 延伸修正：原 /[—\-:].*$/ 会把 ASCII 连字符当后缀分隔符，
+        // 把 order-service 切成 order。现只针对中文长破折号 `—`（LLM 输出列表时常作分隔符）。
+        const raw = numbered.map(m => m.replace(/^\s*\d+\.\s+/, '').replace(/—.*$/, '').trim())
         projectNames = raw.map(sanitizeProjectName).filter(Boolean)
         if (projectNames.length > 0) { stageData.scanMeta = stageData.scanMeta || {}; stageData.scanMeta.projectListParsed = true; }
       }
@@ -2434,8 +2457,18 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
           stageData.status = SCAN_STATUS.FAILED_POST_CHECK
           stageData.completedAt = new Date().toLocaleString('zh-CN',{hour12:false})
           await pm._write(cwd, progress, changeName)
+          triggerSync(cwd, changeName, platformOpts)
           console.error(`\n❌ scan post-check 失败，状态设为 failed_post_check。不允许 clean success。`)
           console.error(`   请检查上方错误信息并修复后重新 scan。`)
+          // 平台模式：exit(1) 让 daemon/SillyHub 感知非 0 退出码（manifest.json 已落盘，不会被撤销）
+          if (platformOpts.specRoot || platformOpts.runtimeRoot) {
+            console.error('   平台模式：CLI 将以 exit code 1 退出，通知 SillyHub scan 失败。')
+            process.exit(1)
+          }
+          // 接口与 plan contract (run.js:2551 附近 plan 失败分支) 对齐：
+          // 返回 { stageCompleted:false, currentIdx, nextPendingIdx: currentIdx }
+          // 让上层 runStage 走"完成但不推进"分支，--done 被拒
+          return { stageCompleted: false, currentIdx, nextPendingIdx: currentIdx }
         } else if (postResult.status === 'completed_with_warnings') {
           // 警告不阻止完成，但记录
           stageData.status = 'completed'
@@ -2623,8 +2656,17 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
       const { loadWorkflow, runPostCheck, formatCheckReport, saveWorkflowRun } = await import('./workflow.js')
       const wf = loadWorkflow(cwd, 'scan-docs')
       if (wf) {
-        // 确定当前项目：优先从 step metadata 读取，回退从 display name 提取
-        const currentProjectName = steps[currentIdx].project
+        // 确定当前项目（优先级链）：
+        //   progress.project (dbProjectName，平台模式真实项目名，与 outputStep 占位符渲染对齐)
+        //   > change?.project (变更对象的项目字段，平台模式 change 创建时传入)
+        //   > steps[idx].project (perProject 展开标记，兼容旧模式)
+        //   > steps[idx].name 正则提取 [xxx] 后缀
+        //   > null（回退检查所有项目）
+        // task-05 修复：日志显示项目名变 frontend 是 perProject 误展开 bug，
+        // 用 progress.project（与 outputStep 占位符渲染路径一致）修正 myaaa/frontend 分裂。
+        const currentProjectName = progress.project
+          || (typeof change !== 'undefined' && change ? change.project : null)
+          || steps[currentIdx].project
           || (steps[currentIdx].name.match(/\[([^\]]+)\]\s*$/) || [])[1]
           || null
 
@@ -2644,7 +2686,7 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
 
         let anyFailed = false
         for (const pName of projectsToCheck) {
-          const result = runPostCheck(wf, cwd, pName)
+          const result = runPostCheck(wf, cwd, pName, {}, specBase)
           const report = formatCheckReport(result)
           console.log(report)
           if (result.status === 'fail') {
@@ -2667,6 +2709,10 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
         }
         if (anyFailed) {
           console.log(`\n⚠️ 存在检查失败项，请按上面的重试提示修复后再继续。`)
+          // task-07: 阻断推进（与 task-06 平台模式 scan-postcheck 失败分支 return 结构对齐）
+          // scan 深度扫描产物校验未通过时，不允许 clean success / 进入下一 step，
+          // 让上层走"完成但不推进"分支，--done 被拒。
+          return { stageCompleted: false, currentIdx, nextPendingIdx: currentIdx }
         }
       }
     } catch (e) {
@@ -2682,7 +2728,7 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
       if (wf && changeName) {
         const raw = JSON.stringify(wf)
         const resolved = JSON.parse(raw.replace(/<change-name>/g, changeName))
-        const result = runPostCheck(resolved, cwd, 'sillyspec')
+        const result = runPostCheck(resolved, cwd, 'sillyspec', {}, specBase)
         // 只报告 impact-analyzer 的结果（doc-syncer 是后续步骤）
         const impactResult = (result.roles || []).find(r => r.id === 'impact-analyzer')
         if (impactResult) {

package/src/stage-contract.js

@@ -587,9 +587,11 @@ export function getContract(stageName) {
  * 校验状态转换是否允许
  * @param {string} fromStage - 当前阶段（空字符串表示变更起始）
  * @param {string} toStage - 目标阶段
+ * @param {{ fromStageData?: { status?: string } | undefined }} [options] - 可选，从 progress.stages[prevStage] 提取
  * @returns {{ allowed: boolean, reason?: string }}
  */
-export function checkTransition(fromStage, toStage) {
+export function checkTransition(fromStage, toStage, options = {}) {
+  const { fromStageData } = options  // { status?: string } | undefined
   const contract = contracts[toStage]
   if (!contract) {
     return { allowed: false, reason: `未知阶段: ${toStage}` }
@@ -605,6 +607,17 @@ export function checkTransition(fromStage, toStage) {
     return { allowed: true }
   }
 
+  // task-07: failed_post_check 门控
+  // scan post-check 未通过时，禁止进入主流程的下游阶段（brainstorm/plan/execute/verify/archive）
+  // 必须先重跑 scan 修复。toStage === 'scan' 的重跑路径已被上方 fromStage === toStage 放行。
+  // fromStageData.status 缺失（旧数据）时门控不触发（向后兼容）。
+  if (fromStage === 'scan' && fromStageData?.status === 'failed_post_check' && toStage !== 'scan') {
+    return {
+      allowed: false,
+      reason: 'scan post-check 未通过（failed_post_check），需修复后重跑 scan 再进入 ' + toStage,
+    }
+  }
+
   // archive 特殊处理：从 verify 来的允许，从其他主流程阶段来的需要校验
   if (toStage === 'archive') {
     if (fromStage === 'verify') {

package/src/workflow.js

@@ -149,10 +149,13 @@ function replaceProjectPlaceholder(wf, projectName) {
  * @param {string} cwd - 项目根目录
  * @returns {CheckResult}
  */
-function checkOutput(outputDef, projectName, cwd) {
+function checkOutput(outputDef, projectName, cwd, specBase) {
+  // specBase 优先（平台模式 platformOpts.specRoot，已含或不含 .sillyspec 语义）；
+  // 未传时回退 join(cwd, '.sillyspec')，等价于旧行为 resolve(cwd, '.sillyspec/...')
+  const effectiveBase = specBase || join(cwd, '.sillyspec')
   // 将 <project> 替换为实际项目名
   const rawPath = (outputDef.path || '').replace(/<project>/g, projectName)
-  const fullPath = resolve(cwd, rawPath)
+  const fullPath = resolve(effectiveBase, rawPath)
   const checks = outputDef.checks || []
   const results = []
 
@@ -241,7 +244,7 @@ function checkOutput(outputDef, projectName, cwd) {
  *   retry_prompts: [{ role_id, role_name, prompt }]
  * }
  */
-export function runPostCheck(wf, cwd, projectName, placeholders = {}) {
+export function runPostCheck(wf, cwd, projectName, placeholders = {}, specBase) {
   let resolved = replaceProjectPlaceholder(wf, projectName)
   if (Object.keys(placeholders).length > 0) {
     let json = JSON.stringify(resolved)
@@ -250,10 +253,11 @@ export function runPostCheck(wf, cwd, projectName, placeholders = {}) {
     }
     resolved = JSON.parse(json)
   }
-  return _checkWorkflow(resolved, cwd, projectName)
+  return _checkWorkflow(resolved, cwd, projectName, specBase)
 }
 
-function _checkWorkflow(wf, cwd, projectName) {
+function _checkWorkflow(wf, cwd, projectName, specBase) {
+  const effectiveBase = specBase || join(cwd, '.sillyspec')
   const workflowName = wf.name || 'unknown'
   const specVersion = wf.spec_version || wf.version || 0
   const workflowChecks = wf.checks?.workflow_level || []
@@ -270,7 +274,7 @@ function _checkWorkflow(wf, cwd, projectName) {
 
     for (const outputDef of outputDefs) {
       const rawPath = (outputDef.path || '').replace(/<project>/g, projectName)
-      const checkResults = checkOutput(outputDef, projectName, cwd)
+      const checkResults = checkOutput(outputDef, projectName, cwd, effectiveBase)
       const outputPassed = checkResults.every(c => c.passed)
 
       outputs.push({
@@ -309,7 +313,7 @@ function _checkWorkflow(wf, cwd, projectName) {
   for (const check of workflowChecks) {
     switch (check.type) {
       case 'file_count': {
-        const scanDir = join(cwd, '.sillyspec', 'docs', projectName, check.path || 'scan/')
+        const scanDir = join(effectiveBase, 'docs', projectName, check.path || 'scan/')
         if (existsSync(scanDir)) {
           const files = readdirSync(scanDir).filter(f => f.endsWith('.md'))
           const min = check.min || 0
@@ -328,7 +332,7 @@ function _checkWorkflow(wf, cwd, projectName) {
         break
       }
       case 'no_empty_files': {
-        const scanDir = join(cwd, '.sillyspec', 'docs', projectName, check.path || 'scan/')
+        const scanDir = join(effectiveBase, 'docs', projectName, check.path || 'scan/')
         if (existsSync(scanDir)) {
           const files = readdirSync(scanDir).filter(f => f.endsWith('.md'))
           let anyEmpty = false

package/templates/workflows/scan-docs.yaml

@@ -13,7 +13,7 @@ roles:
       hints:
         grep_patterns: ["class ", "export ", "import ", "schema", "CREATE TABLE"]
     outputs:
-      - path: ".sillyspec/docs/<project>/scan/ARCHITECTURE.md"
+      - path: "{SPEC_ROOT}/docs/<project>/scan/ARCHITECTURE.md"
         required: true
         checks:
           - type: file_exists
@@ -33,7 +33,7 @@ roles:
       hints:
         grep_patterns: ["function ", "const ", "async ", "try ", "catch "]
     outputs:
-      - path: ".sillyspec/docs/<project>/scan/CONVENTIONS.md"
+      - path: "{SPEC_ROOT}/docs/<project>/scan/CONVENTIONS.md"
         required: true
         checks:
           - type: file_exists
@@ -53,13 +53,13 @@ roles:
       hints:
         grep_patterns: ["fetch", "http", "WebSocket", "ws", "chokidar"]
     outputs:
-      - path: ".sillyspec/docs/<project>/scan/STRUCTURE.md"
+      - path: "{SPEC_ROOT}/docs/<project>/scan/STRUCTURE.md"
         required: true
         checks:
           - type: file_exists
           - type: min_lines
             min: 15
-      - path: ".sillyspec/docs/<project>/scan/INTEGRATIONS.md"
+      - path: "{SPEC_ROOT}/docs/<project>/scan/INTEGRATIONS.md"
         required: true
         checks:
           - type: file_exists
@@ -77,14 +77,14 @@ roles:
       hints:
         grep_patterns: ["TODO", "FIXME", "deprecated", "test", "describe"]
     outputs:
-      - path: ".sillyspec/docs/<project>/scan/TESTING.md"
+      - path: "{SPEC_ROOT}/docs/<project>/scan/TESTING.md"
         required: true
         checks:
           - type: file_exists
           - type: min_lines
             min: 10
           - type: no_placeholder
-      - path: ".sillyspec/docs/<project>/scan/CONCERNS.md"
+      - path: "{SPEC_ROOT}/docs/<project>/scan/CONCERNS.md"
         required: true
         checks:
           - type: file_exists
@@ -92,7 +92,7 @@ roles:
             min: 10
           - type: contains_sections
             sections: ["代码质量", "依赖风险"]
-      - path: ".sillyspec/docs/<project>/scan/PROJECT.md"
+      - path: "{SPEC_ROOT}/docs/<project>/scan/PROJECT.md"
         required: true
         checks:
           - type: file_exists
@@ -126,7 +126,7 @@ on_check_failure: prompt_retry
 permissions:
   write_mode: direct
   write_scope:
-    - ".sillyspec/docs/<project>/scan/"
+    - "{SPEC_ROOT}/docs/<project>/scan/"
   allow_shell: true
   allow_network: false
   allow_git: false

package/test/cli-top-level-aliases.test.mjs

@@ -0,0 +1,174 @@
+/**
+ * task-10: 顶层命令别名 doctor/scan/status/quick/explore 转发 runCommand
+ *
+ * 设计依据：task-10.md §TDD + §验收标准
+ *   - sillyspec doctor / scan / status / quick / explore 不再落 default 分支报"未知命令"
+ *   - 行为与 sillyspec run <stage> 字节一致
+ *   - sillyspec worktree doctor 仍走 worktree 分支
+ *   - sillyspec foobar 仍报未知命令
+ *
+ * 断言策略：
+ *   stage 在空目录下可能因无 .sillyspec 进度而 exit != 0（这是 stage 自身行为，
+ *   不属于本任务路由范围）。因此测试只验证"路由正确"——即 stderr 不含"未知命令"
+ *   字样（default 分支的特征文案），并且 doctor/scan 两路 stdout 字节一致。
+ */
+
+import { spawnSync } from 'node:child_process'
+import { mkdirSync, rmSync } from 'node:fs'
+import { join, resolve, dirname } from 'node:path'
+import { tmpdir } from 'node:os'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const cliBin = resolve(__dirname, '..', 'bin', 'sillyspec.js')
+
+let passed = 0
+let failed = 0
+
+function assert(cond, msg) {
+  if (cond) {
+    console.log(`  ✅ PASS: ${msg}`)
+    passed++
+  } else {
+    console.log(`  ❌ FAIL: ${msg}`)
+    failed++
+  }
+}
+
+function runCLI(args, cwd) {
+  const res = spawnSync(process.execPath, [cliBin, ...args], {
+    cwd,
+    encoding: 'utf8',
+    timeout: 15000,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  })
+  return {
+    stdout: res.stdout || '',
+    stderr: res.stderr || '',
+    status: res.status,
+    combined: (res.stdout || '') + (res.stderr || ''),
+  }
+}
+
+function cleanSillySpec(cwd) {
+  // 清掉 sillyspec 写入 cwd 的进度副作用，保证两路字节级环境一致
+  try { rmSync(join(cwd, '.sillyspec'), { recursive: true, force: true }) } catch {}
+  try { rmSync(join(cwd, '.sillyspec-platform.json'), { force: true }) } catch {}
+}
+
+const tmpRoot = join(tmpdir(), `sillyspec-cli-aliases-${Date.now()}`)
+mkdirSync(tmpRoot, { recursive: true })
+
+try {
+  // ── Red/Green: 5 个顶层命令不再报"未知命令" ──
+  const aliases = ['doctor', 'scan', 'status', 'quick', 'explore']
+  console.log('\n=== Test 1: 顶层命令别名不落 default 分支 ===')
+  for (const stage of aliases) {
+    const res = runCLI([stage], tmpRoot)
+    const hitUnknown =
+      res.combined.includes('未知命令') ||
+      /unknown command/i.test(res.combined)
+    assert(
+      !hitUnknown,
+      `sillyspec ${stage} 不报"未知命令" (exit=${res.status})`
+    )
+  }
+
+  // ── Green: doctor 顶层别名 与 sillyspec run doctor 字节一致 ──
+  // 两路必须在字节级相同环境下运行：同 cwd + 每次跑前清空 .sillyspec
+  // （否则 progress 持久化会让第二次跑读到旧数据触发平台同步检查）
+  console.log('\n=== Test 2: sillyspec doctor 与 sillyspec run doctor 等价 ===')
+  {
+    const cwd = join(tmpRoot, 'doctor-cmp')
+    mkdirSync(cwd, { recursive: true })
+    cleanSillySpec(cwd)
+    const top = runCLI(['doctor'], cwd)
+    cleanSillySpec(cwd)
+    const viaRun = runCLI(['run', 'doctor'], cwd)
+    assert(
+      top.status === viaRun.status,
+      `exit code 一致: doctor=${top.status}, run doctor=${viaRun.status}`
+    )
+    assert(
+      top.stdout === viaRun.stdout,
+      `stdout 字节一致 (len=${top.stdout.length})`
+    )
+    assert(
+      top.stderr === viaRun.stderr,
+      `stderr 字节一致 (len=${top.stderr.length})`
+    )
+  }
+
+  // ── Green: scan 顶层别名 与 sillyspec run scan 字节一致 ──
+  console.log('\n=== Test 3: sillyspec scan 与 sillyspec run scan 等价 ===')
+  {
+    const cwd = join(tmpRoot, 'scan-cmp')
+    mkdirSync(cwd, { recursive: true })
+    cleanSillySpec(cwd)
+    const top = runCLI(['scan'], cwd)
+    cleanSillySpec(cwd)
+    const viaRun = runCLI(['run', 'scan'], cwd)
+    assert(
+      top.status === viaRun.status,
+      `exit code 一致: scan=${top.status}, run scan=${viaRun.status}`
+    )
+    assert(
+      top.stdout === viaRun.stdout,
+      `stdout 字节一致 (len=${top.stdout.length})`
+    )
+  }
+
+  // ── 回归: worktree doctor 走 worktree 分支（与顶层 doctor 不同） ──
+  console.log('\n=== Test 4: sillyspec worktree doctor 走 worktree 分支 ===')
+  {
+    const res = runCLI(['worktree', 'doctor'], tmpRoot)
+    // worktree doctor 不应报顶层 default 的"未知命令"，也不应报"未知阶段"
+    const hitUnknownCmd =
+      res.combined.includes('未知命令') && !/worktree/.test(res.combined)
+    assert(!hitUnknownCmd, `worktree doctor 不报顶层未知命令`)
+    // worktree 子命令 default 分支会输出"未知子命令: worktree"，这里 doctor 合法不应出现
+    assert(
+      !res.combined.includes('未知子命令'),
+      `worktree doctor 不是未知子命令`
+    )
+  }
+
+  // ── 回归: foobar 仍落 default 报未知命令 ──
+  console.log('\n=== Test 5: sillyspec foobar 仍报未知命令 ===')
+  {
+    const res = runCLI(['foobar'], tmpRoot)
+    assert(
+      res.combined.includes('未知命令'),
+      `foobar 命中 default 分支，报"未知命令"`
+    )
+    assert(
+      res.status !== 0,
+      `foobar exit code 非 0 (got ${res.status})`
+    )
+  }
+
+  // ── 选项透传: sillyspec doctor --json 与 sillyspec run doctor --json 等价 ──
+  console.log('\n=== Test 6: doctor --json 选项透传正确 ===')
+  {
+    const top = runCLI(['doctor', '--json'], tmpRoot)
+    const viaRun = runCLI(['run', 'doctor', '--json'], tmpRoot)
+    assert(
+      top.stdout === viaRun.stdout,
+      `doctor --json stdout 与 run doctor --json 一致 (len=${top.stdout.length})`
+    )
+    assert(
+      top.status === viaRun.status,
+      `doctor --json exit 与 run doctor --json 一致`
+    )
+  }
+} finally {
+  try {
+    rmSync(tmpRoot, { recursive: true, force: true })
+  } catch {}
+}
+
+console.log(`\n${'='.repeat(50)}`)
+console.log(`✅ 通过: ${passed}  ❌ 失败: ${failed}`)
+console.log(`${'='.repeat(50)}`)
+process.exit(failed > 0 ? 1 : 0)

package/test/run-sanitize-project-name.test.mjs

@@ -0,0 +1,51 @@
+/**
+ * task-09: sanitizeProjectName 字母校验 + 长度≥2 + 编号正则收紧
+ *
+ * 覆盖：
+ * - 纯数字 "0"/"7" → null（核心目标，scan-projects.json 脏数据来源）
+ * - "0/7" 清洗 "07" 无字母 → null
+ * - "a" 长度<2 → null
+ * - "fe" 含字母长度≥2 → 通过
+ * - "frontend" / "order-service" → 通过
+ * - "前端项目" 全中文清洗后 "" → null
+ * - "" → null
+ */
+import { sanitizeProjectName } from '../src/run.js'
+
+let passed = 0
+let failed = 0
+function assertEqual (actual, expected, msg) {
+  const ok = actual === expected
+  if (ok) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}\n   expected: ${JSON.stringify(expected)}\n   actual:   ${JSON.stringify(actual)}`); failed++ }
+}
+
+// 通过用例
+assertEqual(sanitizeProjectName('frontend'), 'frontend', '"frontend" 含字母长度≥2 通过')
+assertEqual(sanitizeProjectName('order-service'), 'order-service', '"order-service" 含字母+横线 通过')
+assertEqual(sanitizeProjectName('fe'), 'fe', '"fe" 最小长度 2 通过')
+assertEqual(sanitizeProjectName('user_service'), 'user_service', '"user_service" 含下划线 通过')
+assertEqual(sanitizeProjectName('app.v2'), 'app.v2', '"app.v2" 含点+数字 通过')
+
+// 拒绝用例（核心目标）
+assertEqual(sanitizeProjectName('0'), null, '"0" 纯数字拒绝')
+assertEqual(sanitizeProjectName('7'), null, '"7" 纯数字拒绝')
+assertEqual(sanitizeProjectName('07'), null, '"07" 纯数字拒绝（无字母）')
+assertEqual(sanitizeProjectName('0/7'), null, '"0/7" 清洗后 "07" 无字母拒绝')
+assertEqual(sanitizeProjectName('123'), null, '"123" 纯数字拒绝')
+
+// 长度<2
+assertEqual(sanitizeProjectName('a'), null, '"a" 长度<2 拒绝（即使含字母）')
+assertEqual(sanitizeProjectName('z'), null, '"z" 长度<2 拒绝')
+
+// 中文 / 空
+assertEqual(sanitizeProjectName('前端项目'), null, '"前端项目" 全中文清洗后 "" 拒绝')
+assertEqual(sanitizeProjectName(''), null, '空字符串拒绝')
+assertEqual(sanitizeProjectName('   '), null, '纯空白拒绝')
+assertEqual(sanitizeProjectName(null), null, 'null 拒绝')
+assertEqual(sanitizeProjectName(undefined), null, 'undefined 拒绝')
+
+console.log(`\n${'='.repeat(50)}`)
+console.log(`✅ 通过: ${passed}  ❌ 失败: ${failed}`)
+console.log(`${'='.repeat(50)}`)
+if (failed > 0) process.exit(1)

package/test/run-scan-postcheck-fail.test.mjs

@@ -0,0 +1,64 @@
+/**
+ * task-06: scan post-check 失败补 return + completed 标记推迟 + 平台模式 exit(1)
+ *
+ * 验证点：
+ * - AC-1: run.js:2433-2438 失败分支末尾补 return { stageCompleted:false, currentIdx, nextPendingIdx: currentIdx }
+ * - AC-2: 平台模式 (platformOpts.specRoot || platformOpts.runtimeRoot) 时 process.exit(1)
+ * - AC-3: 返回结构与 plan contract (run.js:2551 附近) 完全一致
+ * - AC-4: 非平台模式不 exit（只有 if platformOpts 守卫内的 exit）
+ */
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const runPath = join(__dirname, '..', 'src', 'run.js')
+const src = readFileSync(runPath, 'utf8')
+
+let passed = 0
+let failed = 0
+function check (cond, msg) {
+  if (cond) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}`); failed++ }
+}
+
+// 定位 scan post-check failed_post_check 分支
+// 已知关键锚：stageData.status = SCAN_STATUS.FAILED_POST_CHECK
+const failedAnchor = src.indexOf("postResult.status === 'failed_post_check'")
+check(failedAnchor > 0, "源码含 'failed_post_check' 失败分支锚点")
+
+// 从锚点向后 800 字符内应该有 return { stageCompleted: false ... }
+const tail = src.slice(failedAnchor, failedAnchor + 1200)
+const hasReturnFalse = /return\s*\{\s*stageCompleted:\s*false/.test(tail)
+check(hasReturnFalse, '失败分支末尾补 return { stageCompleted: false, ... }')
+
+// nextPendingIdx: currentIdx 字面出现（与 plan contract 一致）
+const hasNextPendingCurrent = /nextPendingIdx:\s*currentIdx/.test(tail)
+check(hasNextPendingCurrent, '失败分支返回 nextPendingIdx: currentIdx（plan contract 对齐）')
+
+// 平台模式 process.exit(1)
+const hasExitGuard = /platformOpts\.specRoot\s*\|\|\s*platformOpts\.runtimeRoot/.test(tail)
+const hasExitOne = /process\.exit\(1\)/.test(tail)
+check(hasExitGuard && hasExitOne, '失败分支含平台模式守卫 + process.exit(1)')
+
+// 验证 exit(1) 在 if 守卫内（不是裸调）—— 取 exit(1) 位置向前回溯到最近的 } 或 {
+const exitPos = tail.indexOf('process.exit(1)')
+const segmentBeforeExit = tail.slice(0, exitPos)
+const lastOpenBrace = segmentBeforeExit.lastIndexOf('{')
+const lastCloseBrace = segmentBeforeExit.lastIndexOf('}')
+check(lastOpenBrace > lastCloseBrace, 'process.exit(1) 在某个 if 块的 { ... } 内（受守卫保护）')
+
+// 验证 exit 守卫表达式在 exit 之前的同一块内
+const guardSegment = tail.slice(Math.max(0, exitPos - 300), exitPos)
+check(/platformOpts\.(specRoot|runtimeRoot)/.test(guardSegment),
+  'process.exit(1) 前的代码块内含平台模式守卫条件')
+
+// 对照 plan contract（run.js 内 plan 失败分支 return 结构）
+// 定位 plan 阶段失败分支的 stageCompleted:false return
+const planFailMatch = src.match(/plan[\s\S]{0,2000}?return\s*\{\s*stageCompleted:\s*false[\s\S]{0,200}?\}/)
+check(!!planFailMatch, 'plan contract 存在 stageCompleted:false return（对照基准）')
+
+console.log(`\n${'='.repeat(50)}`)
+console.log(`✅ 通过: ${passed}  ❌ 失败: ${failed}`)
+console.log(`${'='.repeat(50)}`)
+if (failed > 0) process.exit(1)

package/test/run-scan-project-parse.test.mjs

@@ -0,0 +1,77 @@
+/**
+ * task-09 集成：编号正则收紧 + sanitize 联动
+ *
+ * 模拟 run.js:2176 处的解析逻辑（正则 + raw 处理 + sanitizeProjectName + filter(Boolean)）
+ * 验证：
+ * - "1. frontend\n2. 0\n3. 7\n4. order-service" → ['frontend', 'order-service']（"0"/"7" 被拒）
+ * - 步骤说明"1. 执行 init"不进 projectNames（中文不匹配 [a-zA-Z] 开头）
+ * - 兜底分支不被污染（outputText 为空 → 走兜底）
+ */
+import { sanitizeProjectName } from '../src/run.js'
+
+let passed = 0
+let failed = 0
+function assertDeepEqual (actual, expected, msg) {
+  const a = JSON.stringify(actual)
+  const e = JSON.stringify(expected)
+  if (a === e) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}\n   expected: ${e}\n   actual:   ${a}`); failed++ }
+}
+
+// 复刻 run.js:2175-2179 的解析链路
+// task-05 B2 延伸修正：编号解析链 .replace 只针对中文长破折号 `—`，
+// 不再误伤 ASCII `-`（否则 order-service 会被切成 order）。
+function parseNumberedList(outputText) {
+  if (!outputText) return []
+  const numbered = outputText.match(/^\s*\d+\.\s+([a-zA-Z][\w\-.]*)/gm)
+  if (!numbered) return []
+  const raw = numbered.map(m => m.replace(/^\s*\d+\.\s+/, '').replace(/—.*$/, '').trim())
+  return raw.map(sanitizeProjectName).filter(Boolean)
+}
+
+// 用例 1：脏数据列表（task-09 核心场景）+ ASCII 连字符保留（task-05 B2 延伸修正）
+assertDeepEqual(
+  parseNumberedList('扫描项目列表：\n1. frontend\n2. 0\n3. 7\n4. order-service\n'),
+  ['frontend', 'order-service'],
+  '脏数据列表：纯数字被拒（task-09）；order-service 完整保留（ASCII - 不再被误切）'
+)
+
+// 用例 2：步骤说明干扰（方案 A 边界）
+assertDeepEqual(
+  parseNumberedList('以下是步骤：\n1. 执行 init\n2. 启动 scan\n3. frontend\n'),
+  ['frontend'],
+  '步骤说明中"1. 执行 init"中文不匹配，仅"3. frontend"入选'
+)
+
+// 用例 3：英文步骤说明干扰（方案 A 已知边界，task-09 §TDD 第 5 步）
+// 注：英文"1. Run scan"会匹配到 "Run"，经 sanitize 通过。这是方案 A 的已知边界，
+// task-09 §实现要求 2 选 A 的前提是"sanitizeProjectName 字母校验双保险"——
+// 纯数字场景已解决（本任务目标），英文步骤误匹配留待 execute 发现再切方案 B。
+const r3 = parseNumberedList('Steps:\n1. Run scan first\n2. backend\n')
+assertDeepEqual(
+  r3,
+  ['Run', 'backend'],
+  '英文步骤会误匹配（方案 A 已知边界，纯数字目标已达成）'
+)
+
+// 用例 4：空 outputText
+assertDeepEqual(parseNumberedList(''), [], '空 outputText 返回空列表')
+
+// 用例 5：含下划线/点的项目名（避开既有 -replace bug，专测 sanitize）
+assertDeepEqual(
+  parseNumberedList('1. app.v2\n2. web_api\n'),
+  ['app.v2', 'web_api'],
+  '合法项目名（点/下划线）保留'
+)
+
+// 用例 6：0/7 这种斜杠分隔的会被单条编号捕获再 sanitize 拒绝
+assertDeepEqual(
+  parseNumberedList('1. 0/7\n2. frontend\n'),
+  ['frontend'],
+  '"0/7" 单条：正则匹配失败（首字符 0 非字母）→ 整条丢弃'
+)
+
+console.log(`\n${'='.repeat(50)}`)
+console.log(`✅ 通过: ${passed}  ❌ 失败: ${failed}`)
+console.log(`${'='.repeat(50)}`)
+if (failed > 0) process.exit(1)

package/test/scan-docs-yaml-placeholders.test.mjs

@@ -0,0 +1,84 @@
+/**
+ * task-05: scan-docs.yaml 占位符 {SPEC_ROOT} + 项目名优先级
+ *
+ * 覆盖：
+ * - AC-01: 8 处 outputs.path 均为 {SPEC_ROOT}/docs/<project>/scan/*.md
+ * - AC-02: write_scope 含 {SPEC_ROOT}/docs/<project>/scan/
+ * - AC-07: 旧 yaml（无 {SPEC_ROOT}）兼容，replace 不命中也不报错
+ */
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const yamlPath = join(__dirname, '..', 'templates', 'workflows', 'scan-docs.yaml')
+const yaml = readFileSync(yamlPath, 'utf8')
+
+let passed = 0
+let failed = 0
+function assert (cond, msg) {
+  if (cond) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}`); failed++ }
+}
+
+// AC-01: 8 处 outputs.path 改占位符
+const expectedDocs = [
+  'ARCHITECTURE.md',
+  'CONVENTIONS.md',
+  'STRUCTURE.md',
+  'INTEGRATIONS.md',
+  'TESTING.md',
+  'CONCERNS.md',
+  'PROJECT.md',
+]
+console.log('=== AC-01: outputs.path 改占位符 {SPEC_ROOT} ===')
+for (const doc of expectedDocs) {
+  const expectedLine = `path: "{SPEC_ROOT}/docs/<project>/scan/${doc}"`
+  assert(yaml.includes(expectedLine), `outputs.path 含 {SPEC_ROOT} 占位符 → ${doc}`)
+}
+
+// AC-01 反向：不应再有硬编码 .sillyspec/docs/<project>/scan/X.md
+console.log('\n=== AC-01 反向：不再有硬编码 .sillyspec/docs/<project>/scan/ ===')
+const hardcodedMatches = yaml.match(/\.sillyspec\/docs\/<project>\/scan\//g) || []
+assert(hardcodedMatches.length === 0,
+  `outputs.path/write_scope 不再含 ".sillyspec/docs/<project>/scan/"（找到 ${hardcodedMatches.length} 处）`)
+
+// AC-02: write_scope 含 {SPEC_ROOT}
+console.log('\n=== AC-02: write_scope 含 {SPEC_ROOT} ===')
+assert(yaml.includes('- "{SPEC_ROOT}/docs/<project>/scan/"'),
+  'write_scope 含 {SPEC_ROOT}/docs/<project>/scan/')
+
+// AC-07 兼容：旧 yaml（无 {SPEC_ROOT}）replace 不命中（用代码模拟）
+console.log('\n=== AC-07: 旧 yaml 占位符兼容性 ===')
+{
+  const legacyPrompt = '写文件到 .sillyspec/docs/<project>/scan/X.md'
+  const replaced = legacyPrompt.replace(/\{SPEC_ROOT\}/g, '/tmp/spec')
+  assert(!replaced.includes('{SPEC_ROOT}'), '旧 yaml 无 {SPEC_ROOT} 字面：replace 后无残留')
+  assert(replaced.includes('.sillyspec/docs/'), '旧 yaml 行为：保留原 .sillyspec/docs/ 路径（向后兼容）')
+}
+
+// AC-03: 新 yaml 替换后路径正确
+console.log('\n=== AC-03: 新 yaml 占位符替换 ===')
+{
+  const newPrompt = '写文件到 {SPEC_ROOT}/docs/<project>/scan/X.md'
+  const step1 = newPrompt.replace(/\{SPEC_ROOT\}/g, '/tmp/spec')
+  const step2 = step1.replace(/<project>/g, 'myaaa')
+  assert(step2 === '写文件到 /tmp/spec/docs/myaaa/scan/X.md',
+    `占位符替换正确：${step2}`)
+  assert(!step2.includes('{SPEC_ROOT}'), '替换后无 {SPEC_ROOT} 残留')
+  assert(!step2.includes('<project>'), '替换后无 <project> 残留')
+}
+
+// 结构完整性：其他字段未动
+console.log('\n=== 结构完整性：其他字段未变 ===')
+assert(yaml.includes('name: scan-docs'), 'yaml name 字段保留')
+assert(yaml.includes('checks:'), 'checks 段保留')
+assert(yaml.includes('path: "scan/"'), 'workflow_level.path "scan/" 相对子路径保留（不动）')
+assert(yaml.includes('retry:'), 'retry 段保留')
+assert(yaml.includes('on_check_failure: prompt_retry'), 'on_check_failure 保留')
+assert(yaml.includes('allow_shell: true'), 'permissions.allow_shell 保留')
+
+console.log(`\n${'='.repeat(50)}`)
+console.log(`✅ 通过: ${passed}  ❌ 失败: ${failed}`)
+console.log(`${'='.repeat(50)}`)
+if (failed > 0) process.exit(1)

package/test/scan-postcheck-project-priority.test.mjs

@@ -0,0 +1,85 @@
+/**
+ * task-05: run.js post-check 项目名优先级链
+ *
+ * 覆盖 AC-04/05/06/10: currentProjectName 优先级 =
+ *   progress.project (dbProjectName) > change.project > steps[idx].project > name 正则 > null
+ *
+ * 由于 runStage 是大函数,这里用源码字符串校验关键优先级链顺序,
+ * 并通过控制台 fixture 模拟实际行为。
+ */
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const runPath = join(__dirname, '..', 'src', 'run.js')
+const src = readFileSync(runPath, 'utf8')
+
+let passed = 0
+let failed = 0
+function assert (cond, msg) {
+  if (cond) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}`); failed++ }
+}
+
+// AC-10: 定位 workflow post_check 段的 currentProjectName 赋值
+console.log('=== AC-10: currentProjectName 优先级链 ===')
+
+// 锚点：workflow post_check 段特征字符串
+const anchor = src.indexOf("Workflow post_check：scan 深度扫描完成后自动检查产物")
+assert(anchor > 0, '找到 workflow post_check scan 锚点')
+
+// 取该段后 2000 字符内的 currentProjectName 赋值块
+const tail = src.slice(anchor, anchor + 3000)
+const assignStart = tail.indexOf('const currentProjectName')
+assert(assignStart > 0, 'post_check 段含 currentProjectName 赋值')
+
+// 赋值块（到下一行 const 或 let 前）
+const assignBlock = tail.slice(assignStart, assignStart + 600)
+
+// 验证优先级链：progress.project 必须在 steps[idx].project 之前出现
+const ppPos = assignBlock.indexOf('progress.project')
+const stepsPos = assignBlock.indexOf('steps[currentIdx].project')
+assert(ppPos > 0 && stepsPos > 0, 'currentProjectName 链含 progress.project + steps[currentIdx].project')
+assert(ppPos < stepsPos,
+  `优先级正确：progress.project (pos=${ppPos}) 在 steps[idx].project (pos=${stepsPos}) 之前`)
+
+// 验证保留兜底：name 正则提取
+assert(/\[([^\]]+)\]\s*\$\//.test(assignBlock) || /\\\[/i.test(assignBlock),
+  '保留兜底：steps[idx].name 正则提取仍存在')
+
+// AC-05/06: 行为模拟 — 优先级链实际执行结果
+console.log('\n=== AC-05/06: 优先级链行为模拟 ===')
+// 复刻 run.js:2650 修正后的优先级链
+function pickProjectName (progressProject, changeProject, stepProject, stepName) {
+  return progressProject
+    || changeProject
+    || stepProject
+    || (stepName && (stepName.match(/\[([^\]]+)\]\s*$/) || [])[1])
+    || null
+}
+
+// AC-05: progress.project='myaaa' 优先于 steps[idx].project='frontend'
+const r1 = pickProjectName('myaaa', undefined, 'frontend', '深度扫描 [frontend]')
+assert(r1 === 'myaaa', `AC-05: progress.project='myaaa' 优先 → ${r1}`)
+
+// AC-06: progress.project 缺失 → 回退 steps[idx].project
+const r2 = pickProjectName(undefined, undefined, 'frontend', '深度扫描 [frontend]')
+assert(r2 === 'frontend', `AC-06: 兜底 steps[idx].project='frontend' → ${r2}`)
+
+// 兜底 2: progress/change/step.project 均缺 → name 正则
+const r3 = pickProjectName(undefined, undefined, undefined, '深度扫描 [backend]')
+assert(r3 === 'backend', `兜底 name 正则提取 → ${r3}`)
+
+// 全 null
+const r4 = pickProjectName(undefined, undefined, undefined, '深度扫描')
+assert(r4 === null, `全缺 → null（检查所有项目分支）`)
+
+// change.project 优先于 steps[idx].project（progress.project 缺失时）
+const r5 = pickProjectName(undefined, 'myaaa', 'frontend', '深度扫描 [frontend]')
+assert(r5 === 'myaaa', `change.project='myaaa' 优先于 steps[idx].project='frontend' → ${r5}`)
+
+console.log(`\n${'='.repeat(50)}`)
+console.log(`✅ 通过: ${passed}  ❌ 失败: ${failed}`)
+console.log(`${'='.repeat(50)}`)
+if (failed > 0) process.exit(1)

package/test/scan-workflow-anyfailed-block.test.mjs

@@ -0,0 +1,52 @@
+/**
+ * task-07: run.js workflow post_check anyFailed 阻断
+ *
+ * 覆盖：
+ * - AC: workflow post_check anyFailed 时返回 { stageCompleted:false, currentIdx, nextPendingIdx: currentIdx }
+ *       （与 task-06 平台模式 scan-postcheck 失败分支 return 结构对齐）
+ *
+ * 用源码字符串匹配 + 行为模拟。
+ */
+import { readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const runPath = join(__dirname, '..', 'src', 'run.js')
+const src = readFileSync(runPath, 'utf8')
+
+let passed = 0
+let failed = 0
+function assert (cond, msg) {
+  if (cond) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}`); failed++ }
+}
+
+console.log('=== workflow post_check anyFailed 阻断 ===')
+
+// 锚点：scan 深度扫描 workflow post_check 段
+const anchor = src.indexOf('if (anyFailed)')
+assert(anchor > 0, '找到 if (anyFailed) 锚点')
+
+// 取该 if 块前后 500 字符（向前找变量声明，向后找 return）
+const tail = src.slice(anchor, anchor + 500)
+
+// 必须有 return { stageCompleted: false ... }
+assert(/return\s*\{\s*stageCompleted:\s*false/.test(tail),
+  'anyFailed 分支含 return { stageCompleted: false }')
+
+// 必须有 nextPendingIdx: currentIdx
+assert(/nextPendingIdx:\s*currentIdx/.test(tail),
+  'anyFailed 分支返回 nextPendingIdx: currentIdx')
+
+// 必须有 currentIdx（保持当前 step 不推进）
+assert(/currentIdx/.test(tail), 'anyFailed 分支保留 currentIdx 字段')
+
+// 必须有 console.log 警告（保留用户可见提示）
+assert(/console\.log/.test(tail) && /存在检查失败项|重试提示/.test(src.slice(anchor - 200, anchor + 300)),
+  'anyFailed 分支保留 console.log 用户提示')
+
+console.log(`\n${'='.repeat(50)}`)
+console.log(`✅ 通过: ${passed}  ❌ 失败: ${failed}`)
+console.log(`${'='.repeat(50)}`)
+if (failed > 0) process.exit(1)

package/test/stage-contract-failed-post-check.test.mjs

@@ -0,0 +1,102 @@
+/**
+ * task-07: checkTransition failed_post_check 门控
+ *
+ * 覆盖：
+ * - AC-1: scan → brainstorm (failed_post_check) → allowed=false, reason 含"scan post-check 未通过"
+ * - AC-2: scan → scan (重跑修复) → allowed=true
+ * - AC-3: scan → doctor/status (辅助阶段) → allowed=true
+ * - AC-4: 旧数据无 status 字段 → 行为同旧版（按 allowedFrom）
+ * - AC-5: status='completed' 不被拦
+ */
+import { checkTransition } from '../src/stage-contract.js'
+
+let passed = 0
+let failed = 0
+function assertEqual (actual, expected, msg) {
+  const ok = actual === expected
+  if (ok) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}\n   expected: ${JSON.stringify(expected)}\n   actual:   ${JSON.stringify(actual)}`); failed++ }
+}
+function assertMatch (actual, regex, msg) {
+  if (regex.test(actual)) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}\n   actual: ${JSON.stringify(actual)} 不匹配 ${regex}`); failed++ }
+}
+function assert (cond, msg) {
+  if (cond) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}`); failed++ }
+}
+
+console.log('=== AC-1: failed_post_check 状态下进 brainstorm/plan/execute 被拦 ===')
+
+// scan → brainstorm, failed_post_check
+{
+  const r = checkTransition('scan', 'brainstorm', { fromStageData: { status: 'failed_post_check' } })
+  assertEqual(r.allowed, false, "scan→brainstorm failed_post_check: allowed=false")
+  assertMatch(r.reason || '', /scan post-check 未通过/, 'reason 含 "scan post-check 未通过"')
+  assertMatch(r.reason || '', /重跑\s*scan|重跑\s*scan/, 'reason 含 "重跑 scan" 提示')
+}
+
+// scan → plan / execute 同样被拦
+{
+  const r1 = checkTransition('scan', 'plan', { fromStageData: { status: 'failed_post_check' } })
+  assertEqual(r1.allowed, false, "scan→plan failed_post_check: allowed=false")
+  const r2 = checkTransition('scan', 'execute', { fromStageData: { status: 'failed_post_check' } })
+  assertEqual(r2.allowed, false, "scan→execute failed_post_check: allowed=false")
+}
+
+console.log('\n=== AC-2: 允许 scan → scan 重跑修复（fromStage===toStage） ===')
+{
+  const r = checkTransition('scan', 'scan', { fromStageData: { status: 'failed_post_check' } })
+  assertEqual(r.allowed, true, "scan→scan failed_post_check: allowed=true（允许重跑修复）")
+}
+
+console.log('\n=== AC-3: failed_post_check 下辅助阶段（doctor/status）仍可执行 ===')
+{
+  const r1 = checkTransition('scan', 'doctor', { fromStageData: { status: 'failed_post_check' } })
+  assertEqual(r1.allowed, true, "scan→doctor failed_post_check: allowed=true（辅助阶段）")
+  const r2 = checkTransition('scan', 'status', { fromStageData: { status: 'failed_post_check' } })
+  assertEqual(r2.allowed, true, "scan→status failed_post_check: allowed=true（辅助阶段）")
+  const r3 = checkTransition('scan', 'quick', { fromStageData: { status: 'failed_post_check' } })
+  assertEqual(r3.allowed, true, "scan→quick failed_post_check: allowed=true（辅助阶段）")
+  const r4 = checkTransition('scan', 'explore', { fromStageData: { status: 'failed_post_check' } })
+  assertEqual(r4.allowed, true, "scan→explore failed_post_check: allowed=true（辅助阶段）")
+}
+
+console.log('\n=== AC-4: 旧数据兼容（无 options 或 status 缺失，行为同旧版） ===')
+{
+  // 无 options（旧调用）— scan→brainstorm 按 allowedFrom 规则允许（scan 是辅助阶段，可进主流程）
+  const r1 = checkTransition('scan', 'brainstorm')
+  assertEqual(r1.allowed, true, "scan→brainstorm 无 options: 行为同旧版（allowed=true）")
+
+  // options 提供 fromStageData 但 status 为 undefined
+  const r2 = checkTransition('scan', 'brainstorm', { fromStageData: { /* 无 status */ } })
+  assertEqual(r2.allowed, true, "scan→brainstorm status=undefined: 行为同旧版（allowed=true）")
+
+  // options 为空对象
+  const r3 = checkTransition('scan', 'brainstorm', {})
+  assertEqual(r3.allowed, true, "scan→brainstorm options={}: 行为同旧版（allowed=true）")
+}
+
+console.log('\n=== AC-5: status="completed" 不被门控拦截 ===')
+{
+  const r = checkTransition('scan', 'brainstorm', { fromStageData: { status: 'completed' } })
+  assertEqual(r.allowed, true, "scan→brainstorm status=completed: allowed=true")
+}
+
+console.log('\n=== AC-6: fromStage 非 scan 时门控不触发（门控只针对 scan 源） ===')
+{
+  const r = checkTransition('brainstorm', 'plan', { fromStageData: { status: 'failed_post_check' } })
+  assertEqual(r.allowed, true, "brainstorm→plan failed_post_check: 门控不触发（非 scan 源）")
+}
+
+console.log('\n=== 接口向后兼容：options 第 3 位可选 ===')
+{
+  // 仅 2 参调用（最常见旧用法）
+  const r = checkTransition('brainstorm', 'plan')
+  assert(r && typeof r.allowed === 'boolean', '2 参调用返回 { allowed: boolean }')
+}
+
+console.log(`\n${'='.repeat(50)}`)
+console.log(`✅ 通过: ${passed}  ❌ 失败: ${failed}`)
+console.log(`${'='.repeat(50)}`)
+if (failed > 0) process.exit(1)

package/test/workflow-spec-base.test.mjs

@@ -0,0 +1,142 @@
+/**
+ * task-04: workflow.js checkOutput / _checkWorkflow / runPostCheck 支持 specBase
+ *
+ * 覆盖：
+ * - AC-01/AC-03: 平台模式 specBase 透传，scanDir = join(specBase, 'docs', project, 'scan/')
+ * - AC-02/AC-04: 非平台模式 specBase 缺省，回退 join(cwd, '.sillyspec')（旧行为）
+ * - AC-05: runPostCheck(wf, cwd, name, {}, specBase) 显式传 specBase 透传到 _checkWorkflow/checkOutput
+ * - AC-06: archive 同样支持
+ */
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'fs'
+import { tmpdir } from 'os'
+import { join, resolve } from 'node:path'
+import { runPostCheck } from '../src/workflow.js'
+
+let passed = 0
+let failed = 0
+function assert (cond, msg) {
+  if (cond) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}`); failed++ }
+}
+function assertEqual (actual, expected, msg) {
+  const ok = actual === expected
+  if (ok) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}\n   expected: ${JSON.stringify(expected)}\n   actual:   ${JSON.stringify(actual)}`); failed++ }
+}
+
+// ── 用例 1: 平台模式 specBase — workflow_level file_count 检查 join(specBase, 'docs', project, 'scan/') ──
+{
+  const specBase = mkdtempSync(join(tmpdir(), 'spec-base-platform-'))
+  const projectName = 'frontend'
+  const scanDir = join(specBase, 'docs', projectName, 'scan')
+  mkdirSync(scanDir, { recursive: true })
+  writeFileSync(join(scanDir, 'a.md'), '# A\ncontent\n')
+
+  const wf = {
+    name: 'scan-docs',
+    checks: { workflow_level: [ { type: 'file_count', path: 'scan/', min: 1 } ] },
+    roles: [],
+  }
+  const result = runPostCheck(wf, '/fake/cwd', projectName, {}, specBase)
+  const fc = (result.workflow_checks || []).find(c => c.type === 'file_count')
+  assert(!!fc, '平台模式 file_count 检查被执行')
+  assertEqual(fc && fc.status, 'pass', '平台模式 specBase 下 file_count 通过（找到 1 个 md）')
+  assert(!(fc && fc.detail && fc.detail.includes('/fake/cwd')),
+    '平台模式 detail 不含 cwd（说明用 specBase 而非裸 cwd）')
+  rmSync(specBase, { recursive: true, force: true })
+}
+
+// ── 用例 2: 平台模式 specBase — 目录不存在时失败且 detail 含 specBase 路径 ──
+{
+  const specBase = mkdtempSync(join(tmpdir(), 'spec-base-empty-'))
+  const projectName = 'backend'
+  const wf = {
+    name: 'scan-docs',
+    checks: { workflow_level: [ { type: 'file_count', path: 'scan/', min: 1 } ] },
+    roles: [],
+  }
+  const result = runPostCheck(wf, '/fake/cwd', projectName, {}, specBase)
+  const fc = (result.workflow_checks || []).find(c => c.type === 'file_count')
+  assertEqual(fc && fc.status, 'fail', '平台模式 specBase 下目录不存在时 file_count 失败')
+  assert(!!(fc && fc.detail && fc.detail.includes(specBase.replace(/\\/g, '/'))) ||
+         !!(fc && fc.detail && fc.detail.includes(specBase)),
+    '平台模式 detail 含 specBase 路径（说明用 specBase）')
+  assert(!(fc && fc.detail && fc.detail.includes('/fake/cwd/.sillyspec')),
+    'detail 不含 fake/cwd/.sillyspec（未回退裸 cwd）')
+  rmSync(specBase, { recursive: true, force: true })
+}
+
+// ── 用例 3: 非平台模式 specBase 缺省 — 回退 join(cwd, '.sillyspec')（旧行为） ──
+{
+  const cwd = mkdtempSync(join(tmpdir(), 'legacy-cwd-'))
+  const sillyspecDir = join(cwd, '.sillyspec')
+  const projectName = 'sillyspec'
+  const scanDir = join(sillyspecDir, 'docs', projectName, 'scan')
+  mkdirSync(scanDir, { recursive: true })
+  writeFileSync(join(scanDir, 'a.md'), '# A\n')
+
+  const wf = {
+    name: 'scan-docs',
+    checks: { workflow_level: [ { type: 'file_count', path: 'scan/', min: 1 } ] },
+    roles: [],
+  }
+  // 不传 specBase（第 5 位留空）
+  const result = runPostCheck(wf, cwd, projectName)
+  const fc = (result.workflow_checks || []).find(c => c.type === 'file_count')
+  assertEqual(fc && fc.status, 'pass', '非平台模式 specBase 缺省时回退 cwd/.sillyspec 通过')
+  rmSync(cwd, { recursive: true, force: true })
+}
+
+// ── 用例 4: 平台模式 role-level checkOutput — specBase 下产出文件存在 ──
+{
+  const specBase = mkdtempSync(join(tmpdir(), 'spec-base-role-'))
+  const projectName = 'myproj'
+  const docAbsPath = join(specBase, 'docs', projectName, 'scan', 'ARCHITECTURE.md')
+  mkdirSync(join(specBase, 'docs', projectName, 'scan'), { recursive: true })
+  writeFileSync(docAbsPath, '# Arch\nline1\nline2\nline3\nline4\nline5\n')
+
+  // outputDef.path 模拟 run.js:645 把 {SPEC_ROOT} 替换为 specBase 后的绝对路径
+  const wf = {
+    name: 'scan-docs',
+    roles: [
+      {
+        id: 'doc-writer',
+        name: 'Doc Writer',
+        outputs: [
+          { path: docAbsPath.replace(/\\/g, '/'), checks: [ { type: 'file_exists' }, { type: 'min_lines', min: 3 } ] },
+        ],
+      },
+    ],
+  }
+  const result = runPostCheck(wf, '/fake/cwd', projectName, {}, specBase)
+  const role = (result.roles || [])[0]
+  assertEqual(role && role.status, 'pass', '平台模式 role-level checkOutput 用 specBase 解析绝对路径通过')
+  rmSync(specBase, { recursive: true, force: true })
+}
+
+// ── 用例 5: 接口向后兼容 — 不传 specBase 时 placeholders 仍工作 ──
+{
+  const cwd = mkdtempSync(join(tmpdir(), 'ph-cwd-'))
+  const projectName = 'demo'
+  const scanDir = join(cwd, '.sillyspec', 'docs', projectName, 'scan')
+  mkdirSync(scanDir, { recursive: true })
+  writeFileSync(join(scanDir, 'a.md'), '# A\n')
+
+  const wf = {
+    name: 'scan-docs',
+    checks: { workflow_level: [ { type: 'file_count', path: 'scan/', min: 1 } ] },
+    roles: [],
+  }
+  // 旧调用方式：runPostCheck(wf, cwd, name, placeholders)
+  const result = runPostCheck(wf, cwd, projectName, { SOME_KEY: 'value' })
+  const fc = (result.workflow_checks || []).find(c => c.type === 'file_count')
+  assertEqual(fc && fc.status, 'pass', '向后兼容：旧 4 参调用（带 placeholders）仍工作')
+  rmSync(cwd, { recursive: true, force: true })
+}
+
+console.log(`\n${'='.repeat(50)}`)
+console.log(`✅ 通过: ${passed}  ❌ 失败: ${failed}`)
+console.log(`${'='.repeat(50)}`)
+if (failed > 0) {
+  process.exit(1)
+}