sillyspec 3.33.3 → 3.33.5

package/src/run/command.js

@@ -54,6 +54,7 @@ const VALUE_FLAGS = new Set([
   '--session', // 显式会话标识（吃值；2026-09-14-change-ownership-guards task-02 所有权三级解析最高优先级层，启动 claim 消费）
   '--inherit-from', // wait 继承盖章锚点 <D-xxx@vN>（吃值；2026-09-18-preflight-slimming task-03 / D-003@v2：仅 --wait 场景合法，--wait 分发点校验消费）
   '--step', // --done --step <名|序号> 意图断言（吃值；:340 消费。漏登记死路同 --wait-interactive 前例：burst 说明书出示该形态却被未知参数 exit(2) 拦死，2026-09-23 执行会话实证）
+  '--answers', // --continue --answers k1=v1,k2=v2 批量回填多个 waiting 步骤（吃值；2026-10-21-protocol-tax task-04/FR-04：仅 --continue 场景合法，complete.js continueStep 消费）
 ])
 
 /**
@@ -272,8 +273,10 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
   // W1-B: run <stage> 暂不支持 --json。之前 --json 进 knownFlags 白名单却从不读取（静默吞），
   // agent 按 gate/derive 契约期望 envelope 实则拿到混合人类文本。显式 fail-fast 杜绝歧义；
   // 完整 run envelope 待 outputStep 重构（W6）后支持（prompt + nextAction 结构化）。
-  if (opts.json) {
-    console.error('❌ run <stage> 暂不支持 --json（静默吞是 bug，故显式拒绝）。')
+  // 例外（2026-10-21-protocol-tax task-04 / FR-04）：--wait --json 放行——waitStep 输出唯一
+  // JSON 对象（问询+选项结构化，agent 直连 ask_user_question），是明确的局部契约而非静默吞。
+  if (opts.json && !args.includes('--wait')) {
+    console.error('❌ run <stage> 暂不支持 --json（静默吞是 bug，故显式拒绝；--wait 场景除外）。')
     console.error('   查事实用 gate/derive（支持 --json envelope）；run 输出人类可读 prompt 供 agent 直接执行。')
     process.exit(2) // 用法错 → exit 2
   }
@@ -420,6 +423,15 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
     process.exit(2) // 用法错 → exit 2
   }
   const continueAnswer = getFlagValue('--answer')
+  // ── --answers 批量回填（2026-10-21-protocol-tax task-04 / FR-04）──
+  // 仅 --continue 场景合法（同 --inherit-from 模式：脱离 --continue 无消费点，静默吞会让
+  // agent 误以为已回填）；与 --answer 互斥校验在 complete.js 批路径入口（两值都解析完再判）。
+  const continueAnswers = getFlagValue('--answers')
+  if (continueAnswers !== null && !isContinue) {
+    console.error('❌ --answers 仅在 --continue 场景合法（一次回填多个 waiting 步骤：--answers k1=v1,k2=v2）')
+    console.error(`   用法: sillyspec run ${stageName} --continue --answers "1=答案A,3=答案B"`)
+    process.exit(2) // 用法错 → exit 2
+  }
   const resolvedSpecDir = specDir || getFlagValue('--spec-dir') || getFlagValue('--spec-root')
   const platformOpts = {
     specRoot: resolvedSpecDir ? resolve(resolvedSpecDir) : null,
@@ -747,6 +759,7 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
     '--skip-apply', // 归档收口跳过 apply 校验（task-02 只注册透传不改行为，消费归 task-03 archive 接线）
     '--inherit-from', // wait 继承盖章 <D-xxx@vN>（2026-09-18-preflight-slimming task-03：仅 --wait 场景合法，hasDecisionId 校验+盖章在 --wait 分发点/complete 层）
     '--step', // --done 意图断言 <名|序号>（吃值，VALUE_FLAGS 同步登记；:340 消费——漏登记则说明书出示的 --done --step 形态进命令即被未知参数拦死，2026-09-23 执行会话实证）
+    '--answers', // --continue 批量回填 k1=v1,k2=v2（吃值，VALUE_FLAGS 同步登记；2026-10-21-protocol-tax task-04：仅 --continue 场景合法，continueStep 消费）
     '--upgrade-thick', // 轻量→完整升档用户同意门（2026-09-25-thin-upgrade-consent：布尔 flag，混跑回退写侧 :1362 消费——无 flag 拒跑，带 flag 落 legacy_fallback+同意时点留痕）
     '--same-session', // R17 实验实证死路清偿（cli-protocol-trust）：STAGE_WALL 报错指引「加 --same-session 重跑」（stage.js 硬墙文案），消费在 runStage 逃生口——此前漏登记，照指引重跑即被本白名单 exit 2（指引指向死路的自我矛盾）
     '--force', // 同族第二实例（静态扫描新发现）：quick --cancel 强清消费点与报错指引（可用 --force）在场但未登记——同死路；一致性钉 test/flag-contract.test.mjs 守护整类
@@ -1726,7 +1739,9 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
   const changed = await ensureStageSteps(progress, stageName, cwd, specRoot)
   if (changed && effectiveChange) {
     pm._write(cwd, progress, effectiveChange)
-    triggerSync(cwd, effectiveChange, platformOpts)
+    // 只读查看（--status）不推平台（2026-10-21-protocol-tax task-06 / FR-06）：重播种是本地
+    // 自愈写（保留），平台同步面归写命令与 bg-sync——status 的同步语义对齐 progress show。
+    if (!isStatus) triggerSync(cwd, effectiveChange, platformOpts)
     progress = pm.read(cwd, effectiveChange) || progress
   }
   if (changed && _preReseedPending && (isDone || isSkip || isWait)
@@ -1795,12 +1810,12 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
       }
       inheritFrom = waitInheritFrom
     }
-    return await waitStep(pm, progress, stageName, cwd, outputText, waitReason, waitOptions, { changeName: effectiveChange, nonInteractive: isNonInteractive && !isInteractive, platformOpts, inheritFrom })
+        return await waitStep(pm, progress, stageName, cwd, outputText, waitReason, waitOptions, { changeName: effectiveChange, nonInteractive: isNonInteractive && !isInteractive, platformOpts, inheritFrom, waitJson: Boolean(opts.json) })
   }
 
   // --continue: 从 waiting 恢复
   if (isContinue) {
-    return await continueStep(pm, progress, stageName, cwd, continueAnswer, { changeName: effectiveChange, nonInteractive: isNonInteractive && !isInteractive, platformOpts, fromStep: fromStepValue })
+    return await continueStep(pm, progress, stageName, cwd, continueAnswer, { changeName: effectiveChange, nonInteractive: isNonInteractive && !isInteractive, platformOpts, fromStep: fromStepValue, answersSpec: continueAnswers })
   }
 
   // --done

package/src/run/complete-handlers.js

@@ -883,6 +883,26 @@ export async function bakeArchiveTimeline({ cwd, specBase, changeName, destDir,
  *
  * 纯函数（git 读数由调用方喂入），单测直接钉构成口径。
  * @param {{changeName:string, stagedNameStatus:string, headTreeFiles:string, existsFn?:(p:string)=>boolean}} p
+/**
+ * 归档落库判定（2026-10-23-flow-done-shared-repo-multi-session-frictions 缺陷③）：HEAD 树中
+ * 是否已含本变更的归档目录条目（.sillyspec/changes/archive/<changeName>/ 下一层首段）。
+ * 目录名口径：archiveDestDirName 现行=裸变更名；`-<changeName>` 后缀兼容历史日期前缀形态。
+ * 纯函数（headTreeFiles 由调用方 git ls-tree 取好传入，测试零 git 依赖）。
+ */
+export function archiveLandedInHeadTree({ headTreeFiles, changeName }) {
+  const prefix = '.sillyspec/changes/archive/'
+  const name = String(changeName || '')
+  if (!name) return false
+  for (const line of String(headTreeFiles || '').split('\n')) {
+    const p = line.trim().replace(/\\/g, '/')
+    if (!p.startsWith(prefix)) continue
+    const first = p.slice(prefix.length).split('/')[0]
+    if (first === name || first.endsWith('-' + name)) return true
+  }
+  return false
+}
+
+/**
  * @returns {{pathspecs:string[], dropped:string[]}}
  */
 export function resolveArchiveCommitPathspecs({ changeName, stagedNameStatus, headTreeFiles, existsFn }) {
@@ -1152,12 +1172,26 @@ try {
     existsFn: (p) => { try { return existsSync(join(cwd, p)) } catch { return false } },
   })
   if (pathspecs.length > 0) {
-    console.log(`🧾 归档提交一笔到位（src 锚 HEAD 树/归档侧目录 pathspec/共享面按在场——共享暂存区竞态加固）：`)
-    console.log(`   git commit -m "chore(archive): ${changeName} 归档留档" -- ${pathspecs.join(' ')}`)
+    // 落库断言（2026-10-23-flow-done-shared-repo-multi-session-frictions 缺陷③）：打印命令≠落库
+    // ——共享暂存区竞态下命令没人执行/被并行会话抢跑，都呈现「归档目录全 staged（A/R）+ 源侧
+    // 删除停 D + flow done 报成功」的半态（实测 pull/清理丢归档）。终态不得只以打印当成功：
+    // HEAD 树含本变更归档路径=已落库（ℹ️ 语义不变）；未落库=🚨 升级 stderr + 可复制命令 + 后果。
+    const landed = archiveLandedInHeadTree({ headTreeFiles: String(headTreeRaw || ''), changeName })
+    const out = landed ? console.log : console.error
+    if (!landed) {
+      console.error(`🚨 归档提交未落库：归档目录已进暂存区（A/R）但 HEAD 树中无 .sillyspec/changes/archive/ 下本变更路径——只打印不执行 ≠ 归档成功（共享仓竞态：命令未被本会话执行或被并行会话抢跑）`)
+      console.error(`   立即执行（幂等；pathspec 限本变更面）：`)
+    } else {
+      console.log(`🧾 归档提交一笔到位（归档路径已在 HEAD 树——余下 staged 面一笔带走；src 锚 HEAD 树/归档侧目录 pathspec/共享面按在场——共享暂存区竞态加固）：`)
+    }
+    out(`   git commit -m "chore(archive): ${changeName} 归档留档" -- ${pathspecs.join(' ')}`)
     if (dropped.length > 0) {
-      console.log(`   ⚠️ 丢弃 ${dropped.length} 个瞬时暂存条目（HEAD 不在册且工作区不在场——并行会话动了共享暂存区，未入命令）：${dropped.join('、')}`)
+      out(`   ⚠️ 丢弃 ${dropped.length} 个瞬时暂存条目（HEAD 不在册且工作区不在场——并行会话动了共享暂存区，未入命令）：${dropped.join('、')}`)
+    }
+    out(`   （若执行报 pathspec 不匹配：共享仓暂存区在打印→执行间又被并行会话改动——git diff --cached --name-only 全量重核，以实际面替换 pathspec 后再提交）`)
+    if (!landed) {
+      console.error(`   不执行的后果：归档件只存在于暂存区——下一次 pull/清理/工作区重置会丢归档。执行后核对：git log --oneline -1 应见「chore(archive): ${changeName} 归档留档」。`)
     }
-    console.log(`   （若执行报 pathspec 不匹配：共享仓暂存区在打印→执行间又被并行会话改动——git diff --cached --name-only 全量重核，以实际面替换 pathspec 后再提交）`)
   }
 } catch { /* 提示失败不阻断归档（advisory） */ }
       if (othersResidual.length > 0) {

package/src/run/complete.js

@@ -161,7 +161,34 @@ export function synthesizeStepOutput({ stageName, stepName, cwd, platformOpts =
   return `【CLI 合成】步骤「${stepName}」完成${windowNote}；门禁以本次 CLI 校验输出为准（方案取舍等语义说明需 --output 手写）`
 }
 
+/**
+ * --done 心跳可观测 wrapper（FR-03 / dsh z2 实证：verify 纯文档步骤 --done 静默挂起 >5 分钟，
+ * agent 无从分辨在跑还是死锁）：收口链（单步 --done 与阶段完成门全链）超过 60s 时每 60s 打一行
+ * stderr 进度行——stdout 保持纯净（--json envelope 消费方 JSON.parse(stdout) 不被污染）；结束
+ * （任意 return/throw）finally 清理，interval unref（命令中断不残留定时器）。常规 <60s 路径
+ * 零输出零行为变化；intervalMs 可注入供测试。
+ */
+export async function withDoneHeartbeat(label, fn, { intervalMs = 60_000 } = {}) {
+  let beats = 0
+  const hb = setInterval(() => {
+    beats += 1
+    console.error(`⏳ ${label} 收口链仍在执行（已约 ${Math.round((beats * intervalMs) / 1000)}s）——实测门/探针/同步可能较慢；持续超 5 分钟可用 sillyspec flow status / progress show 旁路核对状态（非死锁判定）`)
+  }, intervalMs)
+  hb.unref?.()
+  try {
+    return await fn()
+  } finally {
+    clearInterval(hb)
+  }
+}
+
 export async function completeStep(pm, progress, stageName, cwd, outputText, inputText = null, options = {}) {
+  return withDoneHeartbeat(`${stageName} --done`,
+    () => _completeStepInner(pm, progress, stageName, cwd, outputText, inputText, options),
+    { intervalMs: options.heartbeat?.intervalMs })
+}
+
+async function _completeStepInner(pm, progress, stageName, cwd, outputText, inputText = null, options = {}) {
   const { printNext = true, confirm = false, changeName, platformOpts = {}, nonInteractive = false, isForceBaseline = false, isAllowNew = false, isAllowDelete = false, isNoDocs = false, isSkipApply = false, sessionFlag = null, quickFiles = [], linkedChanges = [], linkedChangesAuto = [] } = options
   // specRoot(平台) > specDriftAnchor(worktree 漂移锚定主仓) > cwd/.sillyspec(本地)——
   // 与 prompt.js resolvePromptSpecBase 同序：--done 收尾的 user-inputs.md/超长 artifact 落盘
@@ -697,8 +724,16 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     // 批量保持单步推进（亲测步照 noAI 硬门走）——「批量省的是上下文往返，不省任何门」承诺恢复成立。
     // 判定经 hasPendingVerifyScanStep：DB 步骤行只有 {name,status}（_cliAction 不持久化——评审
     // P1 修复：初版直接读 s._cliAction 恒 false 死代码），按 stageRegistry 定义索引对齐判。
+    // 资格先行（2026-10-21-verify-reuse-large-repo FR-02）：isVerifyBatchEligible 纯判定（只查
+    // 不改）先于亲测——批量不会触发时（报告未就绪/锚定步未过）中间步 --done 不再预跑整轮实测
+    // （dsh 0ff6f1c8 取证：step 3/4/5 各烧一轮 10~13.5 分钟全量实测只为随后单步推进）。资格成立
+    // 时行为不变：先亲测后批量；detectVerifyBatchFinish 内部全量复检不消费本判定，无 TOCTOU。
     let _skipBatch = false
-    if (hasPendingVerifyScanStep(stageName, steps)) {
+    const _batchEligible = isVerifyBatchEligible({ changeName, specBase, steps })
+    if (!_batchEligible.eligible && hasPendingVerifyScanStep(stageName, steps)) {
+      console.log(`   ℹ️ 批量对齐未就绪（${_batchEligible.reason}）——亲测归质量扫描步与收口门，本步不预跑`)
+    }
+    if (_batchEligible.eligible && hasPendingVerifyScanStep(stageName, steps)) {
       try {
         const { executeVerifyQualityScan } = await import('./verify-quality-scan.js')
         console.log('   🧪 批量对齐面含 noAI 亲测步——先亲测（幂等，有记录秒回）…')
@@ -1372,6 +1407,12 @@ function prefetchDiffFileSet(ctx) {
  * @returns {Promise<object|undefined>} 末轮 completeStep 返回值
  */
 export async function completeStepBurst(pm, progress, stageName, cwd, outputText, inputText = null, options = {}) {
+  return withDoneHeartbeat(`${stageName} --done(burst)`,
+    () => _completeStepBurstInner(pm, progress, stageName, cwd, outputText, inputText, options),
+    { intervalMs: options.heartbeat?.intervalMs })
+}
+
+async function _completeStepBurstInner(pm, progress, stageName, cwd, outputText, inputText = null, options = {}) {
   if (outputText) console.log(`📦 burst 收口摘要：${outputText}`)
   let roundOptions = { ...options, printNext: false }
   // burst 单调时钟基准（坑 stage-burst ①）：null=首轮（用真实时刻），此后每轮保严格递增
@@ -1735,24 +1776,42 @@ export function hasPendingVerifyScanStep(stageName, steps) {
   }
 }
 
-export function detectVerifyBatchFinish({ changeName, specBase, steps }) {
-  if (!changeName) return { batched: false, aligned: 0 }
+/**
+ * 批量资格纯判定（2026-10-21-verify-reuse-large-repo FR-02，从 detectVerifyBatchFinish 抽出）：
+ * 只查不改（不 mutating 步骤状态）——verify --done 批量对齐块用它做「预跑亲测」的前置闸：
+ * 资格不成立时中间步 --done 不预跑 executeVerifyQualityScan（实测归亲测步自身与收口门；
+ * dsh 0ff6f1c8 取证：报告未就绪的每个中间步 --done 都整轮实测 10~13.5 分钟纯浪费）。
+ * 判据与 detectVerifyBatchFinish 逐字同源（那边消费本函数，理由串不变）。
+ */
+export function isVerifyBatchEligible({ changeName, specBase, steps }) {
+  if (!changeName) return { eligible: false, reason: '无 changeName' }
   try {
     const changeDir = join(specBase, 'changes', changeName)
     const reportPath = join(changeDir, 'verify-result.md')
-    if (!existsSync(reportPath)) return { batched: false, aligned: 0, reason: 'verify-result.md 缺席（报告未写不批量）' }
+    if (!existsSync(reportPath)) return { eligible: false, reason: 'verify-result.md 缺席（报告未写不批量）' }
     const report = readFileSync(reportPath, 'utf8')
     if (!/结论枚举[：:]\s*`?\s*(PASS WITH NOTES|PASS|FAIL)/.test(report)) {
-      return { batched: false, aligned: 0, reason: '结论枚举未填（待填占位不批量）' }
+      return { eligible: false, reason: '结论枚举未填（待填占位不批量）' }
     }
     if (!existsSync(join(changeDir, 'verify-facts.json'))) {
-      return { batched: false, aligned: 0, reason: 'verify-facts.json 缺席（探针未跑不批量）' }
+      return { eligible: false, reason: 'verify-facts.json 缺席（探针未跑不批量）' }
     }
-    const firstPendingIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
-    if (firstPendingIdx === -1) return { batched: false, aligned: 0, reason: '无剩余 step' }
+    const firstPendingIdx = (steps || []).findIndex(s => s.status === 'pending' || s.status === 'in-progress')
+    if (firstPendingIdx === -1) return { eligible: false, reason: '无剩余 step' }
     if (firstPendingIdx < 2) {
-      return { batched: false, aligned: 0, reason: '锚定步未过（step 1-2 须逐步完成，语义锚定不批量）' }
+      return { eligible: false, reason: '锚定步未过（step 1-2 须逐步完成，语义锚定不批量）' }
     }
+    return { eligible: true }
+  } catch (e) {
+    return { eligible: false, reason: `批量资格判定异常（fail-open 不批量）：${e && e.message ? e.message : e}` }
+  }
+}
+
+export function detectVerifyBatchFinish({ changeName, specBase, steps }) {
+  if (!changeName) return { batched: false, aligned: 0 }
+  const pre = isVerifyBatchEligible({ changeName, specBase, steps })
+  if (!pre.eligible) return { batched: false, aligned: 0, reason: pre.reason }
+  try {
     const now = new Date().toLocaleString('zh-CN', { hour12: false })
     let aligned = 0
     for (const step of steps) {
@@ -2041,6 +2100,31 @@ export async function waitStep(pm, progress, stageName, cwd, outputText, waitRea
     return
   }
 
+  // ── --wait --json（2026-10-21-protocol-tax task-04 / FR-04）──
+  // stdout 输出唯一一个可 JSON.parse 的对象（问询+选项结构化，agent 直连 ask_user_question，
+  // 免解析长文本）；退出码与文本模式一致（成功 0）。仅非盖章路径——--inherit-from 保持文本契约
+  //（盖章路径无问询语义，JSON 化无对象可给）。
+  if (options.waitJson && !inheritFrom) {
+    let waitOptionList = []
+    try {
+      const raw = stageData.steps[currentIdx].waitOptions
+      if (raw) waitOptionList = JSON.parse(raw)
+    } catch { /* 解析失败按无选项处理——JSON 面宁缺勿错 */ }
+    console.log(JSON.stringify({
+      ok: true,
+      command: 'wait',
+      change: changeName || null,
+      stage: stageName,
+      step: currentIdx + 1,
+      stepName: stageData.steps[currentIdx].name,
+      question: outputText || waitReason || null,
+      reason: waitReason || null,
+      options: (Array.isArray(waitOptionList) ? waitOptionList : []).map((o) => ({ label: String(o), description: '' })),
+      resumeCommand: `sillyspec run ${stageName} --continue --answer "你的选择"${changeName ? ` --change ${changeName}` : ''}`,
+    }))
+    return
+  }
+
   console.log(`⏸️  Step ${currentIdx + 1}/${stageData.steps.length} 已暂停等待：${stageData.steps[currentIdx].name}`)
   if (waitReason) console.log(`   原因：${waitReason}`)
   if (waitOptions) console.log(`   选项：${formatWaitOptions(waitOptions)}`)
@@ -2057,8 +2141,36 @@ export async function waitStep(pm, progress, stageName, cwd, outputText, waitRea
   }
 }
 
+/**
+ * --answers 批量回填键值解析（2026-10-21-protocol-tax task-04 / FR-04）。
+ * 形态：k1=v1,k2=v2；值含逗号用引号 k="v,含逗号"（引号包裹段内逗号不切分，引号字符本身不保留）。
+ * 纯函数：解析失败返回 null（调用方 exit 2）；空键/空值/无等号 token 均视为格式错。
+ */
+function parseAnswersSpec(spec) {
+  const parts = []
+  let cur = ''
+  let inQuote = false
+  for (const ch of String(spec)) {
+    if (ch === '"') { inQuote = !inQuote; continue }
+    if (ch === ',' && !inQuote) { parts.push(cur); cur = ''; continue }
+    cur += ch
+  }
+  parts.push(cur)
+  const pairs = []
+  for (const p of parts) {
+    const t = p.trim()
+    const eq = t.indexOf('=')
+    if (!t || eq <= 0) return null
+    const key = t.slice(0, eq).trim()
+    const value = t.slice(eq + 1).trim()
+    if (!key || !value) return null
+    pairs.push({ key, value })
+  }
+  return pairs.length > 0 ? pairs : null
+}
+
 export async function continueStep(pm, progress, stageName, cwd, answer, options = {}) {
-  const { changeName, platformOpts = {}, fromStep } = options
+  const { changeName, platformOpts = {}, fromStep, answersSpec = null } = options
   const specBase = platformOpts.specRoot || join(cwd, '.sillyspec')
   const stageData = progress.stages[stageName]
 
@@ -2067,16 +2179,75 @@ export async function continueStep(pm, progress, stageName, cwd, answer, options
     process.exit(1)
   }
 
-  if (!answer) {
-    console.error('❌ --continue 需要 --answer 参数')
+  // --answers 格式错 fail-fast（先于幂等分支：格式错是用法错误，与等待态无关——
+  // 幂等放行的是「合法调用但无等待对象」，不是「任何调用都吞」）
+  if (answersSpec != null && parseAnswersSpec(answersSpec) == null) {
+    console.error('❌ --answers 格式无法解析（期望 k1=v1,k2=v2 形态，值含逗号用引号 k="v,含逗号"）')
     process.exit(2) // 用法错 → exit 2
   }
 
   // 查找 waiting 的步骤
   const waitingSteps = stageData.steps.map((s, i) => ({ ...s, idx: i })).filter(s => s.status === 'waiting')
+  // ── 幂等 no-op（2026-10-21-protocol-tax task-05 / FR-05）──
+  // 无 waiting 步骤时 --continue 从 exit=1 报错改为 exit 0 + 指引行：会话考古（z1）实证
+  // 4 次「无等待步骤」失败全部来自 agent 在两次 --wait 之间干活后的链式防御写法误撞——
+  // 等待态不存在本身不是协议错误，失败化只迫使 agent 多一轮试错。答案不落盘（无对象可回填）。
   if (waitingSteps.length === 0) {
-    console.error(`没有处于等待状态的步骤（阶段 ${stageName} 当前无 waiting 步骤，--continue 无目标）。当前阶段状态：${stageData?.status ?? '未知'}。用 \`sillyspec run ${stageName} --status\` 查看进度，或 \`sillyspec progress show\` 看全局下一步。`)
-    process.exit(1)
+    console.log(`ℹ️ 当前无等待中的步骤，--continue 幂等跳过（${answersSpec != null ? '--answers 未回填任何答案' : '--answer 未落盘'}）。用 \`sillyspec run ${stageName} --status\` 查看进度，或 \`sillyspec progress show\` 看全局下一步。`)
+    const firstActive = stageData.steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress' || s.status === 'blocked')
+    const firstPending = stageData.steps.findIndex(s => s.status === 'pending')
+    return { stageCompleted: false, currentIdx: firstActive, nextPendingIdx: firstPending }
+  }
+
+  // 有 waiting 步骤时 answer 仍是必填（用法错 exit 2）——放在幂等分支之后：裸 --continue
+  // 无等待对象时幂等放行（FR-05），有等待对象时缺答案照旧硬拦（回填语义不容空答案）。
+  if (!answer && answersSpec == null) {
+    console.error('❌ --continue 需要 --answer 参数（批量回填用 --answers k1=v1,k2=v2）')
+    process.exit(2) // 用法错 → exit 2
+  }
+
+  // ── --answers 批量回填（2026-10-21-protocol-tax task-04 / FR-04）──
+  // 一次调用回填多个 waiting 步骤：k=步骤名或 1-based 序号，值含逗号用引号 k="v,含逗号"。
+  // 契约：全键命中才动状态——任一键未命中/重复命中同一 步骤，整单拒绝 exit 1 并列出可用键
+  //（禁止部分回填：半程状态比一次可重试的失败更难收拾）。
+  // 实现：校验通过后按序号升序逐个递归单答路径（--from-step <序号> + --answer），记录/回当前步
+  // 语义/收尾 gate/回放全部复用单答实现——批路径不复制状态机逻辑。
+  if (answersSpec != null) {
+    const pairs = parseAnswersSpec(answersSpec)
+    if (!pairs) {
+      console.error('❌ --answers 格式无法解析（期望 k1=v1,k2=v2 形态，值含逗号用引号 k="v,含逗号"）')
+      process.exit(2) // 用法错 → exit 2
+    }
+    if (answer) {
+      console.error('❌ --answers 与 --answer 互斥（批量回填与单步回答是两条路径，不要同时给）')
+      process.exit(2)
+    }
+    const targets = []
+    const unmatched = []
+    for (const { key, value } of pairs) {
+      const idx = /^\d+$/.test(key)
+        ? parseInt(key, 10) - 1
+        : stageData.steps.findIndex(s => s.name === key)
+      const step = idx >= 0 ? stageData.steps[idx] : null
+      if (!step || step.status !== 'waiting' || targets.some(t => t.idx === idx)) unmatched.push(key)
+      else targets.push({ idx, value })
+    }
+    if (unmatched.length > 0) {
+      console.error(`❌ --answers 键未命中等待中的步骤：${unmatched.join('、')}——整单拒绝，未回填任何步骤。`)
+      console.error(`   可用键（步骤名或 1-based 序号）：${waitingSteps.map(ws => `${ws.idx + 1}="${ws.name}"`).join('、')}`)
+      process.exit(1)
+    }
+    console.log(`📦 --answers 批量回填开始：${targets.length} 个等待步骤（升序逐个回填）`)
+    let lastResult = null
+    for (const t of [...targets].sort((a, b) => a.idx - b.idx)) {
+      lastResult = await continueStep(pm, progress, stageName, cwd, t.value, {
+        ...options,
+        answersSpec: null,
+        fromStep: String(t.idx + 1),
+      })
+    }
+    console.log(`📦 --answers 批量回填完成：${targets.length} 步`)
+    return lastResult
   }
 
   // --from-step 支持在多个 waiting 时指定恢复哪一个（避免被迫 --reset 破坏性重置）。

package/src/run/gates.js

@@ -28,6 +28,7 @@
  * 不搬：ensureDepsFreshness（execute 入口 deps 自检，调用方 runStage 非 completeStep，归属未来 execute-handler）
  */
 import { basename, join, relative, dirname } from 'node:path'
+import { timedAsync } from '../timing.js'
 import { runtimeStatePath } from '../runtime-paths.js'
 import { createHash } from 'node:crypto'
 import { execFileSync } from 'node:child_process'
@@ -1227,6 +1228,29 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       printVerifyTestCheck(testCheck)
       _obsJournal('green-cache', true, null)
     } else {
+      // ── 失败签名复用（2026-10-21-verify-reuse-large-repo FR-03）：真跑前先咨询上次失败──
+      // 同签名（代码指纹×豁免面×快照口径全等）+ 30min 窗口内 → 不重跑，合成 failed 照常阻断
+      // （dsh 0ff6f1c8 取证：文档门修复循环里每轮 --done 都整轮重测同签名失败 10~13.5 分钟）。
+      // fail-closed：任一判据不可得/失配/TTL 过期 → 照旧真跑。RERUN 逃生阀与 noAI 闸同阀对称。
+      let _failedReuse = null
+      try {
+        const { consultFailedScanReuse, synthesizeReusedFailedCheck } = await import('./verify-quality-scan.js')
+        const consult = consultFailedScanReuse({
+          specBase, cwd, changeName,
+          plannedSnapshot: Boolean(verifyGateSnap),
+          forceRerun: Boolean(process.env.SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN),
+        })
+        if (consult.reuse) _failedReuse = synthesizeReusedFailedCheck(consult.record)
+        else if (consult.reason && consult.reason !== 'no-failed-record') {
+          _obsJournal('quality-scan-failed', false, consult.reason)
+        }
+      } catch { /* 咨询异常 → 真跑（复用是优化不是正确性依赖） */ }
+      if (_failedReuse) {
+        testCheck = _failedReuse
+        console.log(`\n♻️ Verify 测试对账：失败签名复用——上次实测 failed 且签名未变，免重跑（阻断照常，出路见下）`)
+        printVerifyTestCheck(testCheck)
+        _obsJournal('quality-scan-failed', true, null)
+      } else {
       // 测试实测是同步 execSync，长套件可跑 2~10min 且中途无输出——先预告避免 agent 误判卡死
       console.log(`\n⏳ Verify 测试对账：CLI 亲自执行 local.yaml 的 commands.test（同步，耗时可能较长，请等待…）`)
       // restrictFiles 接线（2026-09-26-verify-gate-restrictfiles，评审 P2 留痕缺口的清偿）：
@@ -1287,6 +1311,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
           }
         }
       } catch { /* auto-bind fail-soft */ }
+      } // 失败签名复用分支到此为止——下方记账层对 failed 复用结果是 no-op（passed 守卫）
       // P2 记账（fail-closed 层②：只有通过结果落账本——失败永不缓存，修复后重跑才能记）
       if (!traceHasActiveRows) {
       try {
@@ -1916,7 +1941,11 @@ function readDesignOwnFiles(specBase, changeName) {
  *          null = 全部通过，调用方继续自管收尾（如下一步提示）；
  *          非 null = gate/handler 失败已 rollback，调用方直接 return。
  */
-export async function completeStageGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx, outputText, ctx = null }) {
+export async function completeStageGates(args) {
+  return timedAsync('gates', () => completeStageGatesImpl(args))
+}
+
+async function completeStageGatesImpl({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx, outputText, ctx = null }) {
   // 整体 try/catch（task-04 / review-2026-08-09 #2）：收尾段（execute 预检 + scan handler + validate* +
   // auxiliary 重置 + runStageCompletionGates）任一段抛非结构化异常 → rollbackCompletionAndReturn
   // （回滚 in-progress + 落盘 + 返回未完成对象），不冒顶 exit 1。正常的 _scanResult/_gateEarlyReturn

package/src/run/prompt.js

@@ -19,6 +19,7 @@
  *   - loadModuleContextIndex/buildModuleContextInjection 内 require('fs'/'path') 改顶部静态 import
  */
 import { basename, dirname, join } from 'node:path'
+import { timedAsync } from '../timing.js'
 import { runtimeStatePath } from '../runtime-paths.js'
 import { existsSync, readFileSync, mkdirSync, readdirSync, writeFileSync, rmSync } from 'node:fs'
 import { createHash } from 'node:crypto'
@@ -921,6 +922,10 @@ async function recordPromptInjectLedger({ runtimeRoot, changeName, stageName, fi
 }
 
 export async function outputStep(stageName, stepIndex, steps, cwd, changeName, dbProjectName, platformOpts = {}, prevStepAnswer = null, waitHistory = null, autoMeta = null) {
+  return timedAsync('render', () => outputStepImpl(stageName, stepIndex, steps, cwd, changeName, dbProjectName, platformOpts, prevStepAnswer, waitHistory, autoMeta))
+}
+
+async function outputStepImpl(stageName, stepIndex, steps, cwd, changeName, dbProjectName, platformOpts = {}, prevStepAnswer = null, waitHistory = null, autoMeta = null) {
   const step = steps[stepIndex]
   const total = steps.length
   // ── 越界防御 ──
@@ -941,7 +946,10 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
   // 网络阻塞；未连接平台静默 / quick 会话降级跳过 / 8s 熔断 / 失败只 warn，契约全在
   // triggerStepStartSync 内（shared.js docstring 即本接线点的说明），Node 事件循环保证在飞
   // POST 落地后进程才退出。
-  triggerStepStartSync(cwd, changeName, platformOpts)
+  // 例外（2026-10-21-protocol-tax task-06 / FR-06）：status 是只读查看阶段，不推——消费仓
+  // 实测该推送（进程退出等在飞 POST）占 status 命令耗时的大头（10-20s 量级，平台慢时更甚）；
+  // 查看态无步骤起点语义，平台停滞信号的新鲜度交给写命令。
+  if (stageName !== 'status') triggerStepStartSync(cwd, changeName, platformOpts)
 
   // ── 阶段产物模板落盘（R16 减负批次 2026-09-24）：模板出上下文——prompt 只留指针，模板
   //    幂等落盘 <specBase>/.runtime/templates/ 供 agent 写产物前 Read 一次。best-effort：

package/src/run/quick-audit.js

@@ -358,8 +358,10 @@ export async function resolveQuickLinkedChanges({ pm, cwd, specDir, quickFiles,
 // 无 /g 标志无状态，提级零行为差）：
 //   ① 路径段匹配：任意层出现 src / test / tests / __tests__ 段（src-guide 等长名不误蹭——按段全等）
 //   ② 代码扩展名兜底：src/test 目录约定外的代码（backend/app/**.py、scripts/*.go 等）
-const CODE_PATH_SEGMENT_RE = /(^|\/)(src|tests?|__tests__)(\/|$)/
-const CODE_EXTENSION_RE = /\.(?:js|mjs|cjs|ts|tsx|jsx|py|pyw|go|rs|java|kt|kts|rb|php|cs|c|h|cpp|cc|hpp|swift|scala|groovy|vue|svelte)$/
+// export（2026-10-23-turbo-docs-auto）：flow.js docs-auto 档纯文档面判定同源消费——
+// 分类器单一源（宁可多跑不可漏跑口径），本体零变化
+export const CODE_PATH_SEGMENT_RE = /(^|\/)(src|tests?|__tests__)(\/|$)/
+export const CODE_EXTENSION_RE = /\.(?:js|mjs|cjs|ts|tsx|jsx|py|pyw|go|rs|java|kt|kts|rb|php|cs|c|h|cpp|cc|hpp|swift|scala|groovy|vue|svelte)$/
 
 // 测试文件判定：目录段（test/tests/__tests__——比 quick-gate-profile 的 TEST_DIR_RE 多认裸
 // test/ 段，本仓 test/ 下即有无 .test. 后缀的 .mjs）+ basename test_ 前缀 + .test./_test./.spec.

package/src/run/shared.js

@@ -11,6 +11,7 @@
  *     本模块仅 re-export，run/ 层现有调用方路径与行为不变。
  */
 import { basename, join, resolve, dirname, sep } from 'node:path'
+import { timedAsync } from '../timing.js'
 import { runtimeTempPath } from '../runtime-paths.js'
 import { existsSync, readdirSync, readFileSync, statSync, mkdirSync, writeFileSync, appendFileSync, realpathSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
@@ -981,6 +982,10 @@ function warnPlatformNotConnectedDaily(cwd, platformOpts = {}) {
 }
 
 export async function triggerSync(cwd, changeName, platformOpts = {}, opts = {}) {
+  return timedAsync('sync', () => triggerSyncImpl(cwd, changeName, platformOpts, opts))
+}
+
+async function triggerSyncImpl(cwd, changeName, platformOpts = {}, opts = {}) {
   // ── 后台异步化（2026-09-20 用户反馈：--done 被网络尾巴拖住分钟级）──
   // 默认把同步整体挪进 detached 后台子进程：17 个调用点全部 fire-and-forget，但进程
   // 退出要等事件循环排空，在飞 fetch 拖住命令返回。回落 inline 的三条件：
@@ -1066,9 +1071,13 @@ export async function triggerSync(cwd, changeName, platformOpts = {}, opts = {})
  * @returns {{confirmed: boolean, delegated?: boolean, skipped?: string, result?: object}}
  */
 export async function triggerSyncTerminalStrict(cwd, changeName, platformOpts = {}, opts = {}) {
+  return timedAsync('sync', () => triggerSyncTerminalStrictImpl(cwd, changeName, platformOpts, opts))
+}
+
+async function triggerSyncTerminalStrictImpl(cwd, changeName, platformOpts = {}, opts = {}) {
   // quick 会话无实体变更目录（无归档/删除终态）——沿用既有 best-effort 语义
   if (changeName && QUICK_SID_RE.test(changeName)) {
-    await triggerSync(cwd, changeName, platformOpts, opts)
+    await triggerSyncImpl(cwd, changeName, platformOpts, opts)
     return { confirmed: false, delegated: true }
   }
   const syncMod = await import('../sync.js')
@@ -1139,6 +1148,10 @@ export async function triggerSyncTerminalStrict(cwd, changeName, platformOpts =
  * 每任务上报指引）覆盖。
  */
 export async function triggerStepStartSync(cwd, changeName, platformOpts = {}, opts = {}) {
+  return timedAsync('sync', () => triggerStepStartSyncImpl(cwd, changeName, platformOpts, opts))
+}
+
+async function triggerStepStartSyncImpl(cwd, changeName, platformOpts = {}, opts = {}) {
   try {
     // 无 changeName（渲染层个别路径/测试 fixture）直接静默——sync(null) 只会打 warn 噪音
     if (!changeName) return
@@ -1226,6 +1239,10 @@ export async function triggerPull(cwd, changeName, platformOpts = {}, opts = {})
  * 供 index.js 在 stage 命令（run/--done/archive）与 approve 决策点注入一行调用。
  */
 export async function triggerPullActiveChange(cwd, platformOpts = {}) {
+  return timedAsync('sync', () => triggerPullActiveChangeImpl(cwd, platformOpts))
+}
+
+async function triggerPullActiveChangeImpl(cwd, platformOpts = {}) {
   // 平台模式走自己的链路，跳过；自指回环（repo-native junction）按本地模式处理
   if (isPlatformMode(platformOpts, cwd)) return
   // 先检查是否连接平台：未连接直接 return，避免 _ensureDB 在无 local.yaml 的 cwd 创建空 DB 污染

package/src/run/stage.js

@@ -100,29 +100,32 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
     const effectiveChange = changeName
     const { WorktreeManager } = await import('../worktree.js')
     const wm = new WorktreeManager({ cwd })
-    const existingMeta = wm.getMeta(effectiveChange)
-    if (existingMeta) {
-      console.log(`🔗 worktree 已存在: ${existingMeta.worktreePath} (${existingMeta.mode})`)
+    // ensure（2026-10-21-brainstorm-proto-worktree）：meta 已登记即复用——头脑风暴原型期
+    // 早建的 worktree / native 复用形态与 execute 首建走同一幂等入口，原 getMeta 短路语义收敛于此。
+    let wtResult
+    try {
+      wtResult = wm.ensure(effectiveChange, { adoptBranch: !!(quickOpts && quickOpts.adoptBranch) })
+    } catch (e) {
+      console.error(`❌ worktree 创建失败: ${e.message}`)
+      // 修复建议不再无条件推荐 git branch -D（坑 worktree-user-branch-conflict，2026-08-24：
+      // 同名分支可能是用户有意创建的——分支冲突时 create 报错已带三选一决策菜单，删不删
+      // 交由菜单/人工判断；doctor 的分支删除也有 review 锚点 + 无库保守双保护）。
+      console.error(`   修复建议：`)
+      console.error(`   1. 同名分支冲突/收编：按上方报错内三选一菜单处置（遗留分支确认作废后才删；用户指定分支用 --adopt-branch 收编）`)
+      console.error(`   2. worktree 状态异常：sillyspec worktree doctor --fix（分支删除有 review 锚点保护，不会误删在用分支）`)
+      console.error(`   3. 目录残留：确认无未提交改动后清理 .sillyspec/.runtime/worktrees/${effectiveChange}/ 再重试`)
+      process.exit(1)
+    }
+    if (wtResult.existing) {
+      console.log(`🔗 worktree 已存在: ${wtResult.worktreePath} (${wtResult.mode})`)
     } else {
-      try {
-        const result = wm.create(effectiveChange, { adoptBranch: !!(quickOpts && quickOpts.adoptBranch) })
-        console.log(`🔗 worktree 已创建: ${result.worktreePath} (分支: ${result.branch}, 模式: ${result.mode}${result.adoptedBranch ? ', 收编既有分支' : ''})`)
-      } catch (e) {
-        console.error(`❌ worktree 创建失败: ${e.message}`)
-        // 修复建议不再无条件推荐 git branch -D（坑 worktree-user-branch-conflict，2026-08-24：
-        // 同名分支可能是用户有意创建的——分支冲突时 create 报错已带三选一决策菜单，删不删
-        // 交由菜单/人工判断；doctor 的分支删除也有 review 锚点 + 无库保守双保护）。
-        console.error(`   修复建议：`)
-        console.error(`   1. 同名分支冲突/收编：按上方报错内三选一菜单处置（遗留分支确认作废后才删；用户指定分支用 --adopt-branch 收编）`)
-        console.error(`   2. worktree 状态异常：sillyspec worktree doctor --fix（分支删除有 review 锚点保护，不会误删在用分支）`)
-        console.error(`   3. 目录残留：确认无未提交改动后清理 .sillyspec/.runtime/worktrees/${effectiveChange}/ 再重试`)
-        process.exit(1)
-      }
+      console.log(`🔗 worktree 已创建: ${wtResult.worktreePath} (分支: ${wtResult.branch}, 模式: ${wtResult.mode}${wtResult.adoptedBranch ? ', 收编既有分支' : ''})`)
     }
     // 入口 deps 自检（D-002）：已存在 worktree（create short-circuit 不供给）时重供给
-    if (existingMeta) {
+    //（existing 标志置 undefined：JSON.stringify 丢弃，不随 deps 写回污染 meta.json）
+    if (wtResult.existing) {
       const execSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
-      await ensureDepsFreshness(cwd, effectiveChange, execSpecBase, existingMeta)
+      await ensureDepsFreshness(cwd, effectiveChange, execSpecBase, { ...wtResult, existing: undefined })
     }
 
     // ── 跨仓仓 worktree 隔离（坑 cross-repo-no-worktree-isolation，2026-08-27 用户实证）──