sillyspec 3.26.5 → 3.26.6

package/package.json

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

package/src/db.js

@@ -93,8 +93,10 @@ export class DB {
    *  - 主库缺失/为空/损坏：尝试 .bak；成功则 warn 原因后 copy 回主库使用。
    *  - 都不可用：主库不存在→建全新空库；主库曾存在(空/损坏)→fail-loud 抛错(不静默建空库吞进度)。
    * node:sqlite 打开 0 字节文件不抛错：主库须 statSync 显式判空（截断信号→走回退，防静默吞进度）；
-   * .bak 作为恢复源只要存在且能打开即用（含 0 字节空库——node:sqlite 视其为合法空库，
-   * 生产环境 .bak 由原子写改名上一完整主库得来，永不为 0 字节，0 字节态仅出现在测试构造）。
+   * .bak 作为恢复源只要存在且能打开即用（含 0 字节空库——node:sqlite 视其为合法空库）。
+   * 注：node:sqlite 提交即持久化，不再写前备份主 .bak（sql.js 时代 _save/_atomicWriteSync 已随
+   * 2026-08-11 迁移移除）；此恢复分支是向后兼容兜底，仅对 sql.js 时代遗留的 .bak 生效，
+   * 全新 node:sqlite 项目不产生主 .bak）。
    */
   _openWithFallback() {
     const bakPath = `${this.dbPath}.bak`;

package/src/fs-atomic.js

@@ -4,8 +4,8 @@
  * 用于 .runtime/*.json、pointer、guard.json 等「会被其他进程 / hook 读取」的配置文件。
  * 保证读者要么看到旧完整内容、要么看到新完整内容，不会读到半截 JSON。
  *
- * 注意：db.js 有自己的 _atomicWriteSync（含 .bak 备份），那是 DB 专属持久化逻辑，
- * 已经过稳定性验证，此处不复用、不替换——保持 db.js 零改动。
+ * 注意：DB 持久化由 node:sqlite 引擎承担（提交即落盘 sillyspec.db + WAL 侧车），
+ * 不经此处的 writeAtomicSync；sillyspec.db 不走原子写改名。
  */
 import { writeFileSync, renameSync, unlinkSync } from 'fs';
 import { dirname, basename, join } from 'path';

package/src/index.js

@@ -1673,7 +1673,7 @@ SillySpec config — local.yaml 配置键速查
       // 已知产物 → 用途说明。agent 据此判断每份产物能否作为证据/该读哪个。
       const KNOWN = {
         'sillyspec.db': '进度库 SQLite（stages/steps/changes 表）',
-        'sillyspec.db.bak': '进度库备份（写前快照）',
+        'sillyspec.db.bak': '进度库备份（sql.js 时代写前快照遗留，node:sqlite 不再写入，仅 _openWithFallback 向后兼容恢复用）',
         'sillyspec.db.schema-version': '进度库 schema 版本标记',
         'doctor-diagnosis.json': 'doctor --json 结构化诊断快照',
         'doctor-dumps': 'doctor --dump-db 取证输出目录',

package/src/progress/stage-machine.js

@@ -3,7 +3,7 @@
 // 调 pm.read/_write/_ensureDB/_getSpecDir/readGlobal/_runtimePath/listChanges/_appendAuditLog/
 // _renderBatchProgress（persistence-core + 其他组 delegate）。组内方法互调保持 this.X（同 class）。
 // completeStage 五层（resolve/validate/force/tx/history/print）整体搬迁，不拆流水线（保行为、最低风险）。
-import { mkdirSync } from 'fs';
+import { mkdirSync, existsSync } from 'fs';
 import { join, resolve, basename } from 'path';
 import { writeAtomicSync } from '../fs-atomic.js';
 import { runValidators } from '../stage-contract.js';
@@ -140,21 +140,27 @@ export class StageMachine {
     console.log('');
     console.log('  ═══════════════════════════════════════');
     console.log(`  项目: ${(global?.project) || basename(cwd) || '(未命名)'}`);
-    console.log(`  活跃变更: ${changes.length} 个`);
+    // 当前操作目标与活跃列表区分（坑 status-change-pointer-ambiguous）：多活跃时不带
+    // --change 的 run/progress 不隐式选任何一个（index.js --change 解析多活跃报错），明确
+    // 说出来，防止把残留空壳（default/quick-xxx/目录缺失记录）误当操作目标跑错 change。
+    console.log(`  当前操作目标: （多活跃——不带 --change 时不隐式选定，run 须显式 --change <name>）`);
+    console.log(`  活跃变更记录: ${changes.length} 个（下列为 DB 中存在的活跃记录，非操作目标）`);
     console.log('  ═══════════════════════════════════════');
     console.log('');
 
+    const changesRoot = join(this.pm._getSpecDir(cwd), 'changes');
     for (const cn of changes) {
       const data = this.pm.read(cwd, cn);
+      const dirMissing = !existsSync(join(changesRoot, cn));
       if (!data) {
-        console.log(`  📂 ${cn} — (无法读取)`);
+        console.log(`  📂 ${cn} — (无法读取)${dirMissing ? ' ⚠️ 目录缺失（残留记录，可用 doctor 清理）' : ''}`);
         continue;
       }
       const currentStage = data.currentStage || '(无)';
       const stageLabel = STAGE_LABELS[data.currentStage] || currentStage;
       const lastActive = data.lastActive ? this._timeAgo(data.lastActive) : '未知';
 
-      console.log(`  📂 ${cn}`);
+      console.log(`  📂 ${cn}${dirMissing ? ' ⚠️ 目录缺失（残留记录，可用 doctor 清理）' : ''}`);
       console.log(`     当前阶段: ${stageLabel}  最近活跃: ${lastActive}`);
       console.log('');
     }

package/src/review-tier.js

@@ -13,8 +13,9 @@
  *   - tier=self         → 当前 agent 自审，CLI 放行（不要求 review.json）
  *   - tier=independent  → 强制独立审查子代理 + review.json，CLI 硬校验
  *
- * CLI 侧（run.js done gate）与 prompt 注入侧用同一个函数，保证两边判定一致——
- * 不信 agent 自报 tier。
+ * CLI 侧（run.js done gate）与 prompt 注入侧用同一个函数，保证两边判定一致。
+ * 判定权归 agent 的 plan_level 自主判断（CLI 只做确定性映射，见 classifyReviewTier 注释）；
+ * 无 plan_level 的阶段才退文件数启发式。
  */
 
 import { parseFileChangeList } from './change-list.js'
@@ -28,14 +29,21 @@ export const SELF_REVIEW_FILE_THRESHOLD = 3
 /**
  * 审查分级
  *
+ * 判定权归 agent 的 plan_level 判定（2026-08-14 tier-plan-level 改造）：plan_level 是 agent
+ * 在 plan step1 按 prompt 分级规则做的自主判断，tier 直接映射它——CLI 不再用文件数启发式
+ * 推翻 agent 判定（此前 light + 4 文件会被文件数强制 independent，两套标准打架且不透明，
+ * 实证：agent 判 light 自审通过，完成时 CLI 按 7 文件强制 independent review.json）。
+ *
  * 判定顺序（短路）：
- *   1. plan_level === 'none'                          → self（极小变更）
- *   2. design.md 变更文件数 ≤ SELF_REVIEW_FILE_THRESHOLD → self
- *   3. 否则                                            → independent
+ *   1. plan_level === 'none'  → self（极小变更）
+ *   2. plan_level === 'light' → self（agent 自主判定轻量，自审）
+ *   3. plan_level === 'full'  → independent（full 语义即大变更需独立审查，CLI 确定性强制）
+ *   4. 无 plan_level（brainstorm 等阶段 plan.md 未生成）→ 退文件数启发式：
+ *      design.md 变更文件数 ≤ SELF_REVIEW_FILE_THRESHOLD → self，否则 independent
  *
- * fail-safe：designPath 传了但解析不到文件清单（fileCount=0）按字面 0 处理（真无文件
- * 变更 = 极小）；designPath 完全没传（fileCount=null，无法证明规模）→ independent
- * （宁严勿松）。
+ * fail-safe：无 plan_level 且 designPath 传了但解析不到文件清单（fileCount=0）按字面 0
+ * 处理（真无文件变更 = 极小）；designPath 完全没传（fileCount=null，无法证明规模）→
+ * independent（宁严勿松）。
  *
  * @param {object} [opts]
  * @param {string} [opts.planLevel] - plan_level 分类结果（none/light/full）。brainstorm/propose 在 plan 之前，可能拿不到。
@@ -44,7 +52,13 @@ export const SELF_REVIEW_FILE_THRESHOLD = 3
  */
 export function classifyReviewTier({ planLevel, designPath } = {}) {
   if (planLevel === 'none') {
-    return { tier: 'self', reason: `plan_level=none（极小变更，≤${SELF_REVIEW_FILE_THRESHOLD} 文件等价）`, fileCount: null }
+    return { tier: 'self', reason: 'plan_level=none（极小变更，agent 自主判定自审）', fileCount: null }
+  }
+  if (planLevel === 'light') {
+    return { tier: 'self', reason: 'plan_level=light（agent 自主判定轻量变更，自审）', fileCount: null }
+  }
+  if (planLevel === 'full') {
+    return { tier: 'independent', reason: 'plan_level=full（agent 自主判定大变更，独立审查防确认偏差）', fileCount: null }
   }
 
   let fileCount = null
@@ -53,13 +67,11 @@ export function classifyReviewTier({ planLevel, designPath } = {}) {
   }
 
   if (fileCount !== null && fileCount <= SELF_REVIEW_FILE_THRESHOLD) {
-    return { tier: 'self', reason: `变更文件 ${fileCount} ≤ ${SELF_REVIEW_FILE_THRESHOLD}`, fileCount }
+    return { tier: 'self', reason: `无 plan_level，变更文件 ${fileCount} ≤ ${SELF_REVIEW_FILE_THRESHOLD}（启发式）`, fileCount }
   }
 
   const reason = fileCount === null
-    ? (planLevel
-        ? `plan_level=${planLevel}，无法解析变更文件数，按正常规模处理`
-        : '无法解析 design.md 变更文件清单，按正常规模处理')
-    : `变更文件 ${fileCount} > ${SELF_REVIEW_FILE_THRESHOLD}`
+    ? '无法解析 design.md 变更文件清单，按正常规模处理（fail-safe）'
+    : `无 plan_level，变更文件 ${fileCount} > ${SELF_REVIEW_FILE_THRESHOLD}（启发式）`
   return { tier: 'independent', reason, fileCount }
 }

package/src/run/complete.js

@@ -12,13 +12,17 @@
  * 依赖（completeStep 仅用已抽叶子 + 随搬 helper，零 run.js 闭包，零动态 import）：
  *   - shared.js: triggerSync/WAIT_MARKER_RE/getStageSteps；prompt.js: outputStep；gates.js: enforceDepsGate/runStageCompletionGates
  *   - complete-handlers.js: 8 handler；stages/index.js: stageRegistry；worktree-apply.js: formatExecuteSummary
+ *   - scan-profile.js: executeScanPreflight/executeScanPostcheck/computeScanProfile（noAI 硬门）
+ *   - stages/plan-postcheck.js: executePlanPostcheck（noAI 硬门）
  *   - node: join(path) + existsSync/readdirSync/readFileSync/mkdirSync/writeFileSync/appendFileSync/statSync(fs)
  */
 import { join } from 'node:path'
 import { existsSync, readFileSync, mkdirSync, writeFileSync, appendFileSync } from 'node:fs'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { withFileLock } from '../quicklog.js'
-import { triggerSync, WAIT_MARKER_RE, getStageSteps, formatWaitOptions, resolveRuntimeRoot, getOrCreateMultiRepoContext } from './shared.js'
+import { triggerSync, WAIT_MARKER_RE, getStageSteps, formatWaitOptions, resolveRuntimeRoot, getOrCreateMultiRepoContext, resolveChangeDir } from './shared.js'
+import { executeScanPreflight, executeScanPostcheck, computeScanProfile } from './scan-profile.js'
+import { executePlanPostcheck as runPlanPostcheckLib } from '../stages/plan-postcheck.js'
 import { outputStep } from './prompt.js'
 import { enforceDepsGate, enforceReviewJsonGate, completeStageGates, readDesignScale } from './gates.js'
 import { handleArchiveConfirmStep, handlePlanGeneratePlanStep, handleScanProjectListStep, handleWorkflowPostCheck, handleQuickStageCompletion, handleExecuteWaveArtifact } from './complete-handlers.js'
@@ -60,6 +64,32 @@ export function resolveWaitingStepWithAnswer(steps, doneAnswer, nowStr) {
   return waitIdx
 }
 
+/**
+ * wait 选项单选校验（坑 wait-choice-enforcement）：定义了 waitOptions 的 requiresWait/
+ * repeatableWait 步骤，--answer 必须命中预设选项之一——防止 agent 一句话代答绕过人工
+ * 选择（方案选择类 wait 的 answer 本就该是选项本身）。开放回答型步骤（澄清追问，answer
+ * 为自由文本）在 step 定义显式声明 waitFreeAnswer: true 豁免。
+ * 校验失败打印选项清单 + exit 1（fail-loud，与 requiresWait 门同风格）。
+ *
+ * waitOptions 优先取 stepDef（运行时构建的步骤定义，与 brainstorm/plan 静态定义同源），
+ * 回退 DB step entry（--continue 路径 waiting 步骤的 waitOptions 已落盘）。
+ */
+function enforceWaitChoice(stepDef, stepEntry, answer, stageName, changeName) {
+  if (answer == null) return
+  const opts = Array.isArray(stepDef?.waitOptions) ? stepDef.waitOptions
+    : (Array.isArray(stepEntry?.waitOptions) ? stepEntry.waitOptions : null)
+  if (!opts || opts.length === 0) return
+  if (stepDef?.waitFreeAnswer === true) return
+  if (opts.includes(answer)) return
+  console.error(`❌ Step "${stepEntry?.name || '当前步骤'}" 是封闭单选 wait，--answer 必须命中预设选项之一（防 AI 代答绕过人工选择）。`)
+  console.error(`   你的 --answer: ${JSON.stringify(answer)}`)
+  console.error(`   可选值（复制其一）: ${opts.join(' / ')}`)
+  console.error(`   自由文本回答的场景，该步骤应声明 waitFreeAnswer（当前未声明）。`)
+  if (changeName) console.error(`   重试：sillyspec run ${stageName} --done --answer "<选项>" --change ${changeName}`)
+  else console.error(`   重试：sillyspec run ${stageName} --done --answer "<选项>"`)
+  process.exit(1)
+}
+
 export async function completeStep(pm, progress, stageName, cwd, outputText, inputText = null, options = {}) {
   const { printNext = true, confirm = false, changeName, platformOpts = {}, nonInteractive = false, isForceBaseline = false, isAllowNew = false, isAllowDelete = false } = options
   const specBase = platformOpts.specRoot || join(cwd, '.sillyspec')
@@ -118,6 +148,10 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   const defStepsForCurrent = await getStageSteps(stageName, cwd, progress, platformOpts?.specRoot || null)
   const currentStepDef = defStepsForCurrent?.[currentIdx] || {}
   const currentStep = steps[currentIdx]
+  // --done --answer 解 waiting 的路径同样过单选校验（与下方 requiresWait doneAnswer 分支同规则）
+  if (_resolvedWaitIdx !== -1 && _doneAnswer) {
+    enforceWaitChoice(currentStepDef, currentStep, _doneAnswer, stageName, changeName)
+  }
   if (currentStepDef.requiresWait === true && !currentStep.waitAnswer) {
     // 检查 --done 是否带了 --answer：如果是，自动补全 waitAnswer 状态，一步完成
     const doneAnswer = typeof options !== 'undefined' && options.doneAnswer ? options.doneAnswer : null
@@ -134,6 +168,7 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
       currentStep.waitReason = currentStepDef.waitReason || '等待用户输入'
       console.log(`⚠️  Step "${currentStep.name}" 的确认（${currentStepDef.waitReason}）已在前置步骤完成，自动跳过。`)
     } else if (doneAnswer) {
+      enforceWaitChoice(currentStepDef, currentStep, doneAnswer, stageName, changeName)
       currentStep.status = 'waiting'
       currentStep.waitAnswer = doneAnswer
       currentStep.waitReason = currentStepDef.waitReason || '等待用户输入'
@@ -157,6 +192,27 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   // 提前到每次 --done 校验（而非等 Task Review Gate 在整阶段收尾才暴露，迫使用户事后批量补）。
   await enforceReviewJsonGate(stageName, cwd, changeName, steps[currentIdx], steps, currentIdx, specBase, platformOpts)
 
+  // ── noAI 步骤硬门（坑 noai-done-bypass）：noAI 步骤的确定性校验不可被 --done 绕过 ──
+  // 正常路径 agent 跑 `run <stage>` 推进到 noAI step 时，runStage 自动执行 _cliAction
+  // （stage.js noAI 分支，不写 step output）；若 agent 对 noAI step 直接 --done，此前
+  // completeStep 无 noAI 检测直接标 completed，executePlanPostcheck 等 CLI 确定性校验被
+  // 静默跳过（实证：multi-agent-platform 2026-08-13-spec-sync-visibility tasks/ 从未
+  // 生成但 plan 阶段 completed——step4 output 为 agent 口吻 178 字符而非 CLI 自动路径的
+  // 空 output）。修复：--done 落到 noAI step 时同样执行 _cliAction，校验 throw →
+  // completeStep 不推进（step 保持 pending）。分支对齐 stage.js 的 noAI 自动执行。
+  const _isNoAIStep = currentStepDef.noAI === true || currentStep?.noAI === true
+  if (_isNoAIStep) {
+    const _cliAction = currentStepDef._cliAction || currentStep?._cliAction
+    console.log(`⚙️ Step ${currentIdx + 1}/${steps.length}: ${steps[currentIdx].name}（noAI，--done 路径执行 CLI 校验）`)
+    if (_cliAction === 'scanPreflight') {
+      await executeScanPreflight(cwd, platformOpts, stageData.scanProfile || computeScanProfile(cwd, platformOpts))
+    } else if (_cliAction === 'scanPostcheck') {
+      await executeScanPostcheck(cwd, platformOpts, stageData.scanProfile || computeScanProfile(cwd, platformOpts))
+    } else if (_cliAction === 'planPostcheck') {
+      await runPlanPostcheckLib({ cwd, specRoot: platformOpts?.specRoot, resolveChangeDir, progress })
+    }
+  }
+
   steps[currentIdx].status = 'completed'
   steps[currentIdx].completedAt = new Date().toLocaleString('zh-CN',{hour12:false})
   if (outputText) {
@@ -688,6 +744,7 @@ export async function continueStep(pm, progress, stageName, cwd, answer, options
   const prevOutput = currentStep.output || ''
   const waitRound = (currentStep.waitRound || 0) + 1
   currentStep.waitRound = waitRound
+  enforceWaitChoice(currentStepDef, currentStep, answer, stageName, changeName)
   currentStep.waitAnswer = answer
   currentStep.waitAnswers = Array.isArray(currentStep.waitAnswers) ? currentStep.waitAnswers : []
   currentStep.waitAnswers.push({

package/src/stages/brainstorm-auto.js

@@ -66,6 +66,7 @@ export const definition = {
       maxWaitRounds: 5,
       waitReason: '等待用户回答需求问题',
       waitOptions: ['回答见--answer', '信息够了，进入设计'],
+      waitFreeAnswer: true, // 开放回答型：--answer 内容为自由文本（需求澄清回答），非封闭单选，豁免 enforceWaitChoice
       prompt: `分析需求，必要时追问，然后设计方案。
 
 ### 操作

package/src/stages/brainstorm.js

@@ -79,6 +79,7 @@ export const definition = {
       maxWaitRounds: 8,
       waitReason: '等待用户回答需求问题或澄清',
       waitOptions: ['回答见--answer', '信息够了，进入方案讨论'],
+      waitFreeAnswer: true, // 开放回答型：--answer 内容为自由文本（需求澄清回答），非封闭单选，豁免 enforceWaitChoice
       prompt: `通过对话探索需求细节、分析原型（如有）、判断拆分/批量、并对歧义点做需求澄清 Grill。本步骤合并了原有的对话探索、原型分析、需求范围评估、需求澄清 Grill 四个环节——按下方 A→D 顺序按需执行。提问遵守「一次只问一个」（见 D 节追问策略）：必须问的问题逐个问，能查代码/文档解决的不问；不要把多个歧义打包成一屏清单一次抛给用户（用户记不住、答不全，反而漏掉关键约束）；也不要为凑数把单个问题拖成多轮。
 
 ### A. 原型/设计图分析（如用户提供）