sillyspec 3.18.4 → 3.18.6

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)