sillyspec 3.18.5 → 3.19.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)
+}