sillyspec 3.20.1 → 3.20.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sillyspec",
-  "version": "3.20.1",
+  "version": "3.20.2",
   "description": "SillySpec CLI — 流程状态机，让 AI 严格按步骤来",
   "icon": "logo.jpg",
   "homepage": "https://sillyspec.ppdmq.top/",
@@ -37,4 +37,4 @@
     "sql.js": "^1.14.1",
     "ws": "^8.18"
   }
-}
+}

package/src/index.js

@@ -189,7 +189,7 @@ async function main() {
       break;
     case 'progress': {
       const pm = new ProgressManager();
-      const progDir = resolveEffectiveDir(dir);
+      const progDir = specDir ? dir : resolveEffectiveDir(dir);
       const subCommand = filteredArgs[1];
       const stageIdx = filteredArgs.indexOf('--stage');
       const stage = stageIdx >= 0 && filteredArgs[stageIdx + 1] ? filteredArgs[stageIdx + 1] : null;
@@ -293,7 +293,9 @@ async function main() {
     }
     case 'run': {
       const { runCommand } = await import('./run.js')
-      await runCommand(filteredArgs.slice(1), resolveEffectiveDir(dir), specDir)
+      // 平台模式（--spec-dir 已指定）时，--dir 是明确的 source_root，不应被 resolveEffectiveDir 纠正
+      const effectiveDir = specDir ? dir : resolveEffectiveDir(dir)
+      await runCommand(filteredArgs.slice(1), effectiveDir, specDir)
       break
     }
     // task-10: 顶层命令别名，转发 runCommand，与 case 'run': 路径行为一致
@@ -308,12 +310,13 @@ async function main() {
     case 'explore': {
       const { runCommand } = await import('./run.js')
       const stageArgs = [command, ...filteredArgs.slice(1)]
-      await runCommand(stageArgs, resolveEffectiveDir(dir), specDir)
+      const effectiveDir = specDir ? dir : resolveEffectiveDir(dir)
+      await runCommand(stageArgs, effectiveDir, specDir)
       break
     }
     case 'knowledge': {
       const { cmdKnowledge } = await import('./stages/knowledge.js')
-      await cmdKnowledge(filteredArgs.slice(1), resolveEffectiveDir(dir), { specDir })
+      await cmdKnowledge(filteredArgs.slice(1), specDir ? dir : resolveEffectiveDir(dir), { specDir })
       break
     }
     case 'dashboard': {

package/src/run.js

@@ -27,6 +27,52 @@ export function sanitizeProjectName(name) {
   return clean
 }
 
+/**
+ * 校验从 step 2 解析出的项目列表。
+ * 不通过则不落盘 projects/*.yaml、不展开 perProject 步骤。
+ *
+ * @param {Array<{id: string, path?: string}>} projects - 项目列表（含可选 path）
+ * @param {string} sourceRoot - 源码根目录，用于 path 安全校验
+ */
+export function validateParsedProjects(projects, sourceRoot) {
+  const errors = []
+  if (!projects || projects.length === 0) {
+    return { ok: false, errors: ['项目列表为空'] }
+  }
+  if (projects.length > 10) {
+    return { ok: false, errors: [`项目数量 ${projects.length} 超过上限 10，疑似误解析`] }
+  }
+  const safeRoot = resolve(sourceRoot)
+  const seen = new Set()
+  for (const proj of projects) {
+    const id = proj.id || proj
+    if (seen.has(id)) {
+      errors.push(`重复项目名: ${id}`)
+    }
+    seen.add(id)
+    // slug 合法性：只允许 a-z 0-9 _ - .，长度 2-64
+    if (!/^[a-zA-Z][\w\-.]{1,63}$/.test(id)) {
+      errors.push(`项目名 "${id}" 不合法（需 slug 格式：字母开头，只含 a-zA-Z0-9_-., 长度 2-64）`)
+    }
+    // path 安全校验（如果提供了 path）
+    if (proj.path) {
+      if (proj.path.includes('..')) {
+        errors.push(`项目 "${id}" 的 path 包含 .. ，拒绝越界`)
+      } else {
+        const absPath = resolve(safeRoot, proj.path)
+        if (!absPath.startsWith(safeRoot + '/') && absPath !== safeRoot) {
+          errors.push(`项目 "${id}" 的 path "${proj.path}" 解析后超出 source_root`)
+        }
+        if (!existsSync(absPath)) {
+          errors.push(`项目 "${id}" 的 path "${proj.path}" 不存在`)
+        }
+      }
+    }
+  }
+  if (errors.length > 0) return { ok: false, errors }
+  return { ok: true, errors: [] }
+}
+
 /**
  * 在容器/Docker 环境下，git 可能因目录所有权不匹配报 dubious ownership。
  * 使用 -c safe.directory= 临时参数，不污染全局 git config。
@@ -2254,91 +2300,132 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
 
   // scan 阶段 step 2 "构建扫描项目列表" 完成后，按项目展开 perProject 步骤
   if (stageName === 'scan' && steps[currentIdx]?.name === '构建扫描项目列表') {
-    // 解析项目列表：从 step 2 输出提取，或回退读取 projects/*.yaml
-    let projectNames = []
-    // sanitizeProjectName 已提取到模块顶层（含字母校验 + 长度≥2）
+    // 解析项目列表：只接受结构化输出（YAML block 或 BEGIN_PROJECT_LIST 标记）
+    // 不再从自由文本猜测项目名——自由文本列表的误解析会导致垃圾项目落盘
+    let parsedProjects = [] // Array<{id, path?}>
+    let parsedFromStructuredOutput = false
     if (outputText) {
-      // 匹配方式 1: "1. project-name" 编号列表
-      // 正则收紧：token 必须以字母开头，避免误捕获纯数字 "0"/"7" 和步骤说明中英文行
-      const numbered = outputText.match(/^\s*\d+\.\s+([a-zA-Z][\w\-.]*)/gm)
-      if (numbered) {
-        // 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; }
-      }
-      // 匹配方式 2: 括号枚举 "子项目frontend/order-service/user-service" 或 "项目: a, b, c"
-      if (projectNames.length === 0) {
-        const parenMatch = outputText.match(/(?:子项目|项目)[\s:：]*(\S+(?:[\/、,，]+\S+)*)/)
-        if (parenMatch) {
-          const raw = parenMatch[1].split(/[\/、,，]+/).map(s => s.trim()).filter(Boolean)
-          projectNames = raw.map(sanitizeProjectName).filter(Boolean)
-          if (projectNames.length > 0) { stageData.scanMeta = stageData.scanMeta || {}; stageData.scanMeta.projectListParsed = true; }
+      // 格式 A: YAML block — 匹配 scan_projects: 下所有 - id: xxx 条目（含多行属性）
+      const yamlBlock = outputText.match(/scan_projects:\s*\n([\s\S]+?)(?=$|\n[^\s])/)
+      if (yamlBlock) {
+        const entries = [...yamlBlock[1].matchAll(/-\s+id:\s*(\S+)(?:[\s\S]*?)(?=\n\s+-\s+id:|$)/g)]
+        for (const m of entries) {
+          const id = sanitizeProjectName(m[1])
+          if (!id) continue
+          // 提取可选 path 字段
+          const pathMatch = m[0].match(/path:\s*(\S+)/)
+          const entry = pathMatch ? { id, path: pathMatch[1].trim() } : { id }
+          parsedProjects.push(entry)
         }
-      }
-      // 匹配方式 3: 结构化 YAML block "scan_projects:\n  - id: name"
-      if (projectNames.length === 0) {
-        const yamlMatch = outputText.match(/scan_projects:\s*\n((?:\s+-\s+id:\s+\S+\s*\n?)+)/)
-        if (yamlMatch) {
-          const raw = [...yamlMatch[1].matchAll(/-\s+id:\s*(\S+)/g)].map(m => m[1])
-          projectNames = raw.map(sanitizeProjectName).filter(Boolean)
-          if (projectNames.length > 0) { stageData.scanMeta = stageData.scanMeta || {}; stageData.scanMeta.projectListParsed = true; }
+        parsedFromStructuredOutput = parsedProjects.length > 0
+      }
+      // 格式 B: BEGIN_PROJECT_LIST ... END_PROJECT_LIST 标记块
+      if (!parsedFromStructuredOutput) {
+        const blockMatch = outputText.match(/BEGIN_PROJECT_LIST\s*\n([\s\S]*?)\n*END_PROJECT_LIST/)
+        if (blockMatch) {
+          const raw = [...blockMatch[1].matchAll(/^-\s+(\S+)/gm)].map(m => m[1])
+          parsedProjects = raw.map(s => sanitizeProjectName(s)).filter(Boolean).map(id => ({ id }))
+          parsedFromStructuredOutput = parsedProjects.length > 0
         }
       }
     }
-    if (projectNames.length === 0) {
-      // 回退：读取所有已注册项目
-      console.warn('⚠️ 未能从 step 2 输出解析项目列表，回退扫描所有注册项目')
-      stageData.scanMeta = stageData.scanMeta || {}; stageData.scanMeta.projectListParsed = false;
+
+    const projectNames = parsedProjects.map(p => p.id)
+
+    if (parsedFromStructuredOutput) {
+      stageData.scanMeta = stageData.scanMeta || {}
+      stageData.scanMeta.projectListParsed = true
+    } else {
+      // 结构化输出未解析到 → 回退读取已有 projects/*.yaml
+      // 读取时也校验：path 不存在的 yaml 视为垃圾，直接跳过
+      console.warn('⚠️  step 2 未输出结构化项目列表，回退扫描已注册项目')
+      stageData.scanMeta = stageData.scanMeta || {}
+      stageData.scanMeta.projectListParsed = false
       const projectsDir = join(specBase, 'projects')
       if (existsSync(projectsDir)) {
-        projectNames = readdirSync(projectsDir)
-          .filter(f => f.endsWith('.yaml'))
-          .map(f => f.replace(/\.yaml$/, ''))
+        const yamlFiles = readdirSync(projectsDir).filter(f => f.endsWith('.yaml'))
+        const fallbackProjects = []
+        const fallbackSkipped = []
+        for (const yf of yamlFiles) {
+          const pName = yf.replace(/\.yaml$/, '')
+          const yamlContent = readFileSync(join(projectsDir, yf), 'utf8')
+          const pathMatch = yamlContent.match(/^path:\s*(.+)/m)
+          const pPath = pathMatch ? pathMatch[1].trim() : pName
+          // 校验 path 是否存在且在 source_root 内
+          const absPath = resolve(cwd, pPath)
+          if (pPath.includes('..') || (!absPath.startsWith(resolve(cwd)) && absPath !== resolve(cwd))) {
+            fallbackSkipped.push(`${pName} (path 越界: ${pPath})`)
+            continue
+          }
+          if (!existsSync(absPath)) {
+            fallbackSkipped.push(`${pName} (path 不存在: ${pPath})`)
+            continue
+          }
+          fallbackProjects.push({ id: pName, path: pPath })
+        }
+        if (fallbackSkipped.length > 0) {
+          console.warn(`⚠️  跳过 ${fallbackSkipped.length} 个垃圾/过期项目配置：${fallbackSkipped.join(', ')}`)
+          console.warn('   建议清理 projects/ 下的无效 yaml 文件')
+        }
+        parsedProjects = fallbackProjects
+        projectNames.length = 0
+        projectNames.push(...fallbackProjects.map(p => p.id))
+      }
+      if (parsedProjects.length === 0) {
+        // 无结构化输出 + 无合法已有项目 → step 2 失败
+        console.error('❌ step 2 未输出结构化项目列表，且 projects/ 下无合法项目配置')
+        console.error('   请在 --output 中输出 scan_projects YAML block 或 BEGIN_PROJECT_LIST 标记块')
+        steps[currentIdx].validationError = '未输出结构化项目列表且无合法 fallback'
+        // 不展开 perProject 步骤，直接跳到下一步
       }
     }
-    if (projectNames.length === 0) {
-      projectNames = ['sillyspec'] // 最终兜底
+
+    // 校验解析出的项目列表（原子守卫：不通过就不落盘）
+    const validation = validateParsedProjects(parsedProjects, cwd)
+    if (!validation.ok) {
+      console.error(`❌ 项目列表校验失败: ${validation.errors.join('; ')}`)
+      console.error('   step 2 完成，但不展开 perProject 步骤。请检查 --output 中的项目列表。')
+      steps[currentIdx].validationError = validation.errors.join('; ')
     }
 
-    // 自动注册未注册的子项目（确保 projects/*.yaml 存在，避免展开时 projectRoot 缺失）
+    // 自动注册 + 保存 runtime + 展开 perProject 步骤（仅在校验通过时）
     const projectsDir = join(specBase, 'projects')
-    for (const pName of projectNames) {
-      const projYaml = join(projectsDir, `${pName}.yaml`)
-      if (!existsSync(projYaml)) {
-        mkdirSync(projectsDir, { recursive: true })
-        // 子项目路径推测：检查 cwd 下是否有同名目录
-        const candidates = [
-          join(cwd, pName),                              // cwd/frontend
-          join(cwd, 'backend', pName),                 // cwd/backend/user-service
-          join(cwd, 'packages', pName),                // monorepo packages
-          join(cwd, 'apps', pName),                     // monorepo apps
-          join(cwd, 'services', pName),                // monorepo services
-        ]
-        const detected = candidates.find(c => existsSync(c))
-        const regPath = detected || join(cwd, pName)
-        writeFileSync(projYaml, `name: ${pName}\npath: ${regPath}\nstatus: active\n`)
-        console.log(`  📝 自动注册子项目: ${pName} → ${regPath}`)
-      }
-    }
-
-    // 保存到 runtime 供后续使用 + 防重复展开
-    const scanStatePath = join(specBase, '.runtime', 'scan-projects.json')
-    mkdirSync(join(specBase, '.runtime'), { recursive: true })
-    let scanState = { projects: projectNames, expanded: false }
-    if (existsSync(scanStatePath)) {
-      try { scanState = JSON.parse(readFileSync(scanStatePath, 'utf8')) } catch {}
-    }
-
-    // 收集当前步骤之后所有 perProject 步骤
-    const stageDef = stageRegistry[stageName]
-    const allSteps = stageDef?.steps || []
-    const perProjectSteps = allSteps.filter(s => s.perProject)
+    if (validation.ok) {
+      for (const proj of parsedProjects) {
+        const pName = proj.id
+        const projYaml = join(projectsDir, `${pName}.yaml`)
+        if (!existsSync(projYaml)) {
+          mkdirSync(projectsDir, { recursive: true })
+          const candidates = [
+            join(cwd, pName),
+            join(cwd, 'backend', pName),
+            join(cwd, 'packages', pName),
+            join(cwd, 'apps', pName),
+            join(cwd, 'services', pName),
+          ]
+          const detected = candidates.find(c => existsSync(c))
+          const regPath = detected || join(cwd, pName)
+          writeFileSync(projYaml, `name: ${pName}\npath: ${regPath}\nstatus: active\n`)
+          console.log(`  📝 自动注册子项目: ${pName} → ${regPath}`)
+        }
+      }
+
+      // 保存 runtime 状态
+      const scanStatePath = join(specBase, '.runtime', 'scan-projects.json')
+      mkdirSync(join(specBase, '.runtime'), { recursive: true })
+      let scanState = { projects: projectNames, expanded: false }
+      if (existsSync(scanStatePath)) {
+        try { scanState = JSON.parse(readFileSync(scanStatePath, 'utf8')) } catch {}
+      }
 
-    // 防重复展开：runtime 标记 或 steps 已含项目标识
-    const alreadyExpanded = scanState.expanded || steps.some(s => s.name?.match(/\[.+\]\s*$/))
-    if (!alreadyExpanded && perProjectSteps.length > 0) {
+      // 收集当前步骤之后所有 perProject 步骤
+      const stageDef = stageRegistry[stageName]
+      const allSteps = stageDef?.steps || []
+      const perProjectSteps = allSteps.filter(s => s.perProject)
+
+      // 防重复展开
+      const alreadyExpanded = scanState.expanded || steps.some(s => s.name?.match(/\[.+\]\s*$/))
+      if (!alreadyExpanded && perProjectSteps.length > 0) {
       // 找到当前步骤（step 2）在动态 steps 中的位置
       const insertBase = currentIdx + 1
       let insertPos = insertBase
@@ -2377,8 +2464,9 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
       // 标记已展开，防止 resume 重复插入
       scanState.expanded = true
       writeFileSync(scanStatePath, JSON.stringify(scanState))
-    }
-  }
+    } // end !alreadyExpanded
+    } // end validation.ok
+  } // end step 2
 
   const nextPendingIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
 

package/src/scan-postcheck.js

@@ -151,19 +151,22 @@ export function runScanPostCheck({ cwd, specDir, outputText = '', scanMeta = {}
     }
   }
 
-  // 5. 检查 AI 输出中的错误标记
+  // 5. 检查 AI 输出中的真实错误标记
+  // 注意：不对 agent 描述性文本做全文正则匹配，防止误报。
+  // 只检测明显是 agent 运行时失败的信号（未被捕获的错误块），
+  // 而非 agent 正常描述中提到这些词。
   if (outputText) {
-    const errorPatterns = [
-      { pattern: /tool_use_error/i, name: 'tool_use_error', detail: 'AI 输出中包含 tool_use_error' },
-      { pattern: /API Error.*529/i, name: 'api_error_529', detail: 'AI 输出中包含 API Error 529' },
-      { pattern: /rate.?limit.*exhausted/i, name: 'rate_limit_exhausted', detail: 'AI 输出中包含 rate_limit exhausted' },
-      { pattern: /fallback|retry.*failed|skipped.*validat/i, name: 'fallback_or_skip', detail: 'AI 输出中出现 fallback/retry failed/skipped validation' },
-    ]
-    for (const ep of errorPatterns) {
-      if (ep.pattern.test(outputText)) {
-        checks.push({ name: ep.name, severity: CHECK_SEVERITY.WARNING, detail: ep.detail })
-      }
+    // 5a: 检测未被恢复的 API 错误（连续多次、非描述性提及）
+    const apiErrorCount = (outputText.match(/API Error\b.*?\b529\b/gi) || []).length
+    if (apiErrorCount >= 2) {
+      checks.push({ name: 'api_error_529', severity: CHECK_SEVERITY.WARNING, detail: 'AI 输出中包含多次 API Error 529' })
+    }
+    const rateLimitCount = (outputText.match(/rate.?limit.*?exhausted/gi) || []).length
+    if (rateLimitCount >= 2) {
+      checks.push({ name: 'rate_limit_exhausted', severity: CHECK_SEVERITY.WARNING, detail: 'AI 输出中包含多次 rate_limit exhausted' })
     }
+    // tool_use_error 和 fallback 已移除：agent 描述性文本中正常提及这些词
+    // 不应触发 warning。真正的问题会通过文档缺失、manifest 失败等其他检查捕获。
   }
 
   // 6. manifest 写入状态检查
@@ -300,7 +303,7 @@ export function formatStructuredResult(result, meta = {}) {
       structured.failure_categories.bad_references.push(entry)
     }
     // AI 输出质量类
-    else if (['tool_use_error', 'api_error_529', 'rate_limit_exhausted', 'fallback_or_skip'].includes(check.name)) {
+    else if (['api_error_529', 'rate_limit_exhausted'].includes(check.name)) {
       structured.failure_categories.quality_warnings.push(entry)
     }
     // manifest/project 列表问题

package/src/stages/scan.js

@@ -62,9 +62,26 @@ export const definition = {
 - 最终确定的项目列表将用于后续所有步骤
 - **后续每个需要生成文档的步骤，都必须对列表中的每个项目分别执行**
 
-### 输出
-确认后的扫描项目列表（项目名 + 扫描策略）`,
-      outputHint: '扫描项目列表',
+### 输出格式规范
+--output 必须使用以下结构化格式之一（CLI 只解析这些格式，**不要输出自由文本列表**）：
+
+**格式 A：scan_projects YAML block**
+在 --output 中输出：
+    scan_projects:
+      - id: backend
+      - id: frontend
+      - id: daemon
+
+**格式 B：BEGIN_PROJECT_LIST 标记块**
+在 --output 中输出：
+    BEGIN_PROJECT_LIST
+    - backend
+    - frontend
+    - daemon
+    END_PROJECT_LIST
+
+如果不需要解析项目列表（如单项目已明确），--output 写普通摘要即可。`,
+      outputHint: '结构化项目列表（YAML block 或 BEGIN_PROJECT_LIST）',
       optional: false
     },
     {

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

@@ -1,13 +1,13 @@
 /**
- * task-09 集成：编号正则收紧 + sanitize 联动
+ * scan step 2 项目列表解析 — 强契约测试
  *
- * 模拟 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 为空 → 走兜底）
+ * 解析只接受两种结构化格式：
+ *   A) YAML block: scan_projects:\n  - id: name
+ *   B) BEGIN_PROJECT_LIST ... END_PROJECT_LIST
+ *
+ * 自由文本列表不再解析，防止误识别垃圾项目名。
  */
-import { sanitizeProjectName } from '../src/run.js'
+import { sanitizeProjectName, validateParsedProjects } from '../src/run.js'
 
 let passed = 0
 let failed = 0
@@ -17,60 +17,183 @@ function assertDeepEqual (actual, expected, msg) {
   if (a === e) { console.log(`✅ PASS: ${msg}`); passed++ }
   else { console.error(`❌ FAIL: ${msg}\n   expected: ${e}\n   actual:   ${a}`); failed++ }
 }
+function assertEqual (actual, expected, msg) {
+  if (actual === expected) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}\n   expected: ${expected}\n   actual:   ${actual}`); failed++ }
+}
+function assertIncludes (str, sub, msg) {
+  if (str.includes(sub)) { console.log(`✅ PASS: ${msg}`); passed++ }
+  else { console.error(`❌ FAIL: ${msg}\n   expected to include: ${sub}\n   actual: ${str}`); 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)
+// ---- 复刻 run.js 中新的解析逻辑 ----
+function parseProjectListFromOutput(outputText) {
+  let parsedProjects = [] // Array<{id, path?}>
+  let parsedFromStructuredOutput = false
+  if (outputText) {
+    // 格式 A: YAML block
+    const yamlBlock = outputText.match(/scan_projects:\s*\n([\s\S]+?)(?=$|\n[^\s])/)
+    if (yamlBlock) {
+      const entries = [...yamlBlock[1].matchAll(/-\s+id:\s*(\S+)(?:[\s\S]*?)(?=\n\s+-\s+id:|$)/g)]
+      for (const m of entries) {
+        const id = sanitizeProjectName(m[1])
+        if (!id) continue
+        const pathMatch = m[0].match(/path:\s*(\S+)/)
+        const entry = pathMatch ? { id, path: pathMatch[1].trim() } : { id }
+        parsedProjects.push(entry)
+      }
+      parsedFromStructuredOutput = parsedProjects.length > 0
+    }
+    // 格式 B: BEGIN_PROJECT_LIST
+    if (!parsedFromStructuredOutput) {
+      const blockMatch = outputText.match(/BEGIN_PROJECT_LIST\s*\n([\s\S]*?)\n*END_PROJECT_LIST/)
+      if (blockMatch) {
+        const raw = [...blockMatch[1].matchAll(/^-\s+(\S+)/gm)].map(m => m[1])
+        parsedProjects = raw.map(s => sanitizeProjectName(s)).filter(Boolean).map(id => ({ id }))
+        parsedFromStructuredOutput = parsedProjects.length > 0
+      }
+    }
+  }
+  return { parsedProjects, parsedFromStructuredOutput }
 }
 
-// 用例 1：脏数据列表（task-09 核心场景）+ ASCII 连字符保留（task-05 B2 延伸修正）
+// ======== 解析测试 ========
+
+// 1. YAML block 正常解析
 assertDeepEqual(
-  parseNumberedList('扫描项目列表：\n1. frontend\n2. 0\n3. 7\n4. order-service\n'),
-  ['frontend', 'order-service'],
-  '脏数据列表：纯数字被拒（task-09）；order-service 完整保留（ASCII - 不再被误切）'
+  parseProjectListFromOutput(`scan_projects:
+  - id: backend
+  - id: frontend
+  - id: daemon
+`).parsedProjects,
+  [{ id: 'backend' }, { id: 'frontend' }, { id: 'daemon' }],
+  'YAML block 正常解析 3 个项目'
 )
 
-// 用例 2：步骤说明干扰（方案 A 边界）
+// 2. YAML block 带 path 字段（多行属性）
+const r2 = parseProjectListFromOutput(`scan_projects:
+  - id: api
+    path: backend/
+  - id: web
+    path: frontend/
+`).parsedProjects
+assertDeepEqual(r2, [{ id: 'api', path: 'backend/' }, { id: 'web', path: 'frontend/' }],
+  'YAML block 带 path 字段正常解析')
+
+// 3. BEGIN_PROJECT_LIST 正常解析
 assertDeepEqual(
-  parseNumberedList('以下是步骤：\n1. 执行 init\n2. 启动 scan\n3. frontend\n'),
-  ['frontend'],
-  '步骤说明中"1. 执行 init"中文不匹配，仅"3. frontend"入选'
+  parseProjectListFromOutput(`BEGIN_PROJECT_LIST
+- backend
+- frontend
+- daemon
+END_PROJECT_LIST`).parsedProjects,
+  [{ id: 'backend' }, { id: 'frontend' }, { id: 'daemon' }],
+  'BEGIN_PROJECT_LIST 标记块正常解析'
 )
 
-// 用例 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')
+// 4. 自由文本编号列表 → 不解析
+const { parsedProjects: fn, parsedFromStructuredOutput: fnParsed } =
+  parseProjectListFromOutput('扫描项目列表：\n1. scan1backendmulti-agent-platform-api FastAPI Python\n2. frontendmulti-agent-platform-web Next.js TS\n3. sillyhub-daemon Node.js TS')
+assertEqual(fnParsed, false, '自由文本编号列表不触发解析')
+assertDeepEqual(fn, [], '自由文本编号列表不产生任何项目名')
+
+// 5. 自由文本括号枚举 → 不解析
+const { parsedProjects: fn2, parsedFromStructuredOutput: fn2Parsed } =
+  parseProjectListFromOutput('子项目: backend / frontend / user-service')
+assertEqual(fn2Parsed, false, '自由文本括号枚举不触发解析')
+assertDeepEqual(fn2, [], '自由文本括号枚举不产生任何项目名')
+
+// 6. 空 outputText → 不解析
+const { parsedFromStructuredOutput: emptyParsed } = parseProjectListFromOutput('')
+assertEqual(emptyParsed, false, '空 outputText 不触发解析')
+
+// 7. 普通摘要文本 → 不解析
+const { parsedProjects: summary, parsedFromStructuredOutput: summaryParsed } =
+  parseProjectListFromOutput('确认扫描 3 个子项目：backend、frontend、daemon，全部重新扫描')
+assertEqual(summaryParsed, false, '普通摘要文本不触发解析')
+assertDeepEqual(summary, [], '普通摘要文本不产生任何项目名')
+
+// ======== validateParsedProjects — 基础校验 ========
+
+// 8. 正常列表（无 path）
 assertDeepEqual(
-  r3,
-  ['Run', 'backend'],
-  '英文步骤会误匹配（方案 A 已知边界，纯数字目标已达成）'
+  validateParsedProjects([{ id: 'backend' }, { id: 'frontend' }, { id: 'daemon' }], '/tmp/proj'),
+  { ok: true, errors: [] },
+  '正常列表校验通过（无 path）'
 )
 
-// 用例 4：空 outputText
-assertDeepEqual(parseNumberedList(''), [], '空 outputText 返回空列表')
-
-// 用例 5：含下划线/点的项目名（避开既有 -replace bug，专测 sanitize）
+// 9. 正常列表（有合法 path）——需要用真实路径
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'fs'
+import { join } from 'path'
+import os from 'os'
+const tmpDir = mkdtempSync(join(os.tmpdir(), 'sillyspec-test-'))
+mkdirSync(join(tmpDir, 'backend'))
+mkdirSync(join(tmpDir, 'frontend'))
 assertDeepEqual(
-  parseNumberedList('1. app.v2\n2. web_api\n'),
-  ['app.v2', 'web_api'],
-  '合法项目名（点/下划线）保留'
+  validateParsedProjects([
+    { id: 'backend', path: 'backend' },
+    { id: 'frontend', path: 'frontend' }
+  ], tmpDir),
+  { ok: true, errors: [] },
+  '合法 path 校验通过'
 )
 
-// 用例 6：0/7 这种斜杠分隔的会被单条编号捕获再 sanitize 拒绝
+// 10. path 不存在 → 失败
+const v10 = validateParsedProjects([{ id: 'backend', path: 'nonexistent' }], tmpDir)
+assertEqual(v10.ok, false, 'path 不存在校验失败')
+assertIncludes(v10.errors[0], '不存在', '错误提示包含"不存在"')
+
+// 11. path 含 .. 越界 → 失败
+const v11 = validateParsedProjects([{ id: 'backend', path: '../etc/passwd' }], tmpDir)
+assertEqual(v11.ok, false, 'path 包含 .. 校验失败')
+assertIncludes(v11.errors[0], '..', '错误提示包含 ..')
+
+// 12. path 解析后超出 source_root → 失败
+const v12 = validateParsedProjects([{ id: 'backend', path: '/etc/passwd' }], tmpDir)
+assertEqual(v12.ok, false, '绝对路径超出 source_root 校验失败')
+assertIncludes(v12.errors[0], '超出', '错误提示包含"超出"')
+
+// 13. 超过 10 个项目 → 失败
+const many = Array.from({ length: 11 }, (_, i) => ({ id: `project${i}` }))
+const v13 = validateParsedProjects(many, tmpDir)
+assertEqual(v13.ok, false, '超过 10 个项目校验失败')
+assertIncludes(v13.errors[0], '超过上限', '错误提示包含"超过上限"')
+
+// 14. 重复项目名 → 失败
+const v14 = validateParsedProjects([{ id: 'backend' }, { id: 'frontend' }, { id: 'backend' }], tmpDir)
+assertEqual(v14.ok, false, '重复项目名校验失败')
+assertIncludes(v14.errors[0], '重复', '错误提示包含"重复"')
+
+// 15. 非法 slug（中文）→ 失败
+const v15 = validateParsedProjects([{ id: 'backend' }, { id: '前端服务' }], tmpDir)
+assertEqual(v15.ok, false, '非法 slug 校验失败')
+
+// 16. 空列表 → 失败
+const v16 = validateParsedProjects([], tmpDir)
+assertEqual(v16.ok, false, '空列表校验失败')
+
+// 17. null 列表 → 失败
+const v17 = validateParsedProjects(null, tmpDir)
+assertEqual(v17.ok, false, 'null 列表校验失败')
+
+// 18. 单字符 → 失败
+const v18 = validateParsedProjects([{ id: 'a' }], tmpDir)
+assertEqual(v18.ok, false, '单字符项目名校验失败')
+
+// 19. 纯数字 → 失败
+const v19 = validateParsedProjects([{ id: '123' }], tmpDir)
+assertEqual(v19.ok, false, '纯数字项目名校验失败')
+
+// 20. 兼容旧 API（纯字符串数组）
 assertDeepEqual(
-  parseNumberedList('1. 0/7\n2. frontend\n'),
-  ['frontend'],
-  '"0/7" 单条：正则匹配失败（首字符 0 非字母）→ 整条丢弃'
+  validateParsedProjects(['backend', 'frontend'], tmpDir),
+  { ok: true, errors: [] },
+  '旧 API 兼容：纯字符串数组仍通过'
 )
 
+// 清理
+rmSync(tmpDir, { recursive: true, force: true })
+
 console.log(`\n${'='.repeat(50)}`)
 console.log(`✅ 通过: ${passed}  ❌ 失败: ${failed}`)
 console.log(`${'='.repeat(50)}`)

package/test/scan-postcheck.test.mjs

@@ -106,11 +106,10 @@ console.log('\n=== Test 4: local.yaml 命令不存在 → completed_with_warning
 }
 
 // ── 5-8: AI 输出错误标记 → warnings ──
+// 注意：tool_use_error 和 fallback 已移除（agent 描述性文本正常提及不应触发）
 const errorCases = [
-  { id: 'e5', name: 'tool_use_error', output: 'tool_use_error: file not found' },
-  { id: 'e6', name: 'API Error 529', output: 'API Error 529 server overloaded' },
-  { id: 'e7', name: 'rate_limit', output: 'rate limit exhausted' },
-  { id: 'e8', name: 'fallback', output: 'fallback to default, skipped validation' },
+  { id: 'e6', name: 'API Error 529', output: 'API Error 529 server overloaded. API Error 529 retry failed' },
+  { id: 'e7', name: 'rate_limit', output: 'rate limit exhausted, rate limit exhausted again' },
 ]
 for (const ec of errorCases) {
   console.log(`\n=== Test: ${ec.name} → completed_with_warnings ===`)
@@ -121,6 +120,21 @@ for (const ec of errorCases) {
   clean(cwd, spec)
 }
 
+// ── tool_use_error / fallback 不再触发 warning（描述性文本正常提及） ──
+const noWarnCases = [
+  { id: 'e5', name: 'tool_use_error', output: 'tool_use_error: file not found' },
+  { id: 'e8', name: 'fallback', output: '作为 fallback 方案，跳过了这个步骤' },
+]
+for (const ec of noWarnCases) {
+  console.log(`\n=== Test: ${ec.name} → 不触发 warning ===`)
+  const cwd = setup(ec.id), spec = specSetup(ec.id)
+  writeFull(cwd, spec)
+  const r = runScanPostCheck({ cwd, specDir: spec, outputText: ec.output })
+  assert(!r.checks.some(c => c.name === 'tool_use_error' || c.name === 'fallback_or_skip'),
+    `${ec.name}: 不应有 tool_use_error/fallback_or_skip warning`)
+  clean(cwd, spec)
+}
+
 // ── 9: 文档缺 header → warnings ──
 console.log('\n=== Test 9: 文档缺 header → completed_with_warnings ===')
 {

package/.npmrc-tmp

@@ -1 +0,0 @@
-//registry.npmjs.org/:_authToken=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