sillyspec 3.29.4 → 3.30.0

package/src/run/complete.js

@@ -45,12 +45,13 @@ import { executeProgressConfirm } from './progress-confirm.js'
 import { AUXILIARY_STAGES } from '../constants.js'
 import { executePlanPostcheck as runPlanPostcheckLib, parseRepoRegistry } from '../stages/plan-postcheck.js'
 import { outputStep, collectStageWaitHistory } from './prompt.js'
-import { enforceDepsGate, enforceReviewJsonGate, enforceSymbolImpactGate, warnMissingUiPrototype, completeStageGates, readDesignScale } from './gates.js'
+import { enforceDepsGate, enforceSymbolImpactGate, warnMissingUiPrototype, completeStageGates, readDesignScale } from './gates.js'
 import { handleArchiveConfirmStep, handlePlanGeneratePlanStep, handleScanProjectListStep, handleWorkflowPostCheck, handleQuickStageCompletion, handleExecuteWaveArtifact, assertWaveTasksComplete } from './complete-handlers.js'
 import { formatExecuteSummary } from '../worktree-apply.js'
 import { validateDecisionModuleRefs } from '../design-facts.js'
 import { isEndToEndTaskText } from '../change-risk-profile.js'
 import { deriveTitleFromLinkedChange } from '../quicklog.js'
+import { stageRegistry } from '../stages/index.js' // hasPendingVerifyScanStep 判定面（cli-protocol-trust；缺 import 时 ReferenceError 被 fail-open catch 吞成恒 false——本行即其修复）
 
 // validateMetadata / readDesignScale / validateFileLocations 已迁至 ./gates.js（completeStageGates
 // 共享收尾管线，消除 noAI 末步 / continueStep 完成分支绕过 gate 的 S1/S2/S3 不对称）。
@@ -61,6 +62,34 @@ import { deriveTitleFromLinkedChange } from '../quicklog.js'
 // step6 design.md 已落盘但阶段未完）与阶段完成同样刷新，治「brainstorm 全程 title 存英文 autoName
 // 兜底」。quick-<hex> 无 proposal/design 目录，deriveTitleFromLinkedChange 返回 '' 不刷新
 // （quick 走 handleQuickStageCompletion 的 extractTitleFromResult）。失败静默（不阻断流程）。
+// ── Wave 边界 handoff 纪律（2026-09-21 R5 接线 ql-20260921-007）──
+// rollout 实证（sess_418fc2bb，2026-09-21）：单会话跨 4 Wave 背 ~130K 上下文 ×176 请求，
+// ≈1/4 墙钟是肥上下文结构税（缓存 99% 救账单不救墙钟）。B4a 交接块已在场，缺的只是纪律——
+// 本 helper 维护「变更 × 会话 → 已完成 Wave 步计数」账本，同会话跨 ≥2 Wave 时升级提示语气。
+// 纯函数（IO 由调用方做）：返回更新后的账本 + 是否达 advisory 阈值。
+export function updateWaveSessionLedger(ledger, sessionId, waveName) {
+  const sid = String(sessionId || 'anon')
+  const prev = ledger && ledger.sessionId === sid ? (ledger.waveCount || 0) : 0
+  const next = { sessionId: sid, waveCount: prev + 1, lastWave: waveName || null, at: new Date().toISOString() }
+  return { ledger: next, crossWaveAdvisory: next.waveCount >= 2 }
+}
+
+/**
+ * 阶段-会话账本（token 减负④，2026-09-23 R9 实证后）：同一 SILLYSPEC_SESSION_ID 连续完成
+ * ≥2 个流程阶段 → 升级告警（同 Wave 账本的阶段粒度版）。R9 数据：单会话五阶段 53.5M 输入、
+ * 尾段单轮 30 万+、archive 3 分钟 7.2M——肥上下文税随会话内阶段数单调累积。架构约束
+ * （conventions 钉）：CLI 只产信号与接力载荷，不做会话编排——新会话创建者是用户或平台
+ * （session-fork 基建），升级块动作主体必须写明。纯函数（IO 由调用方做）。
+ */
+export function updateStageSessionLedger(ledger, sessionId, stageName) {
+  const sid = String(sessionId || 'anon')
+  const prev = ledger && ledger.sessionId === sid ? (ledger.stageCount || 0) : 0
+  const stages = ledger && ledger.sessionId === sid && Array.isArray(ledger.stages) ? [...ledger.stages] : []
+  stages.push(String(stageName || ''))
+  const next = { sessionId: sid, stageCount: prev + 1, stages: stages.slice(-8), lastStage: stageName || null, at: new Date().toISOString() }
+  return { ledger: next, crossStageAdvisory: next.stageCount >= 2 }
+}
+
 function refreshChangeTitleFromArtifacts(pm, cwd, specBase, changeName) {
   if (!changeName || /^quick-[0-9a-f]{8}$/.test(changeName)) return
   try {
@@ -105,22 +134,37 @@ export function resolveWaitingStepWithAnswer(steps, doneAnswer, nowStr) {
  * 纯事实零编造（无「通过/成功」等判断词——判断在 gate，不在摘要）；语义性说明（方案
  * 取舍/用户反馈）不合成，摘要自带手写指引。长度控制在 MAX_OUTPUT(200) 截断线内。
  */
-export function synthesizeStepOutput({ stageName, stepName, cwd }) {
+export function synthesizeStepOutput({ stageName, stepName, cwd, platformOpts = {} }) {
+  // 窗口归属性判定（坑 stage-burst-timeline-quality-collapse ②，2026-09-24 实证）：
+  // git 窗口只在能归属到本变更文件根时给出——worktree 内执行（specDriftAnchor 锚定）
+  // 时 git 向上发现 worktree 根，窗口本就归属正确；平台模式（specRoot 锚定 daemon spec
+  // 根，变更文件不在 cwd 仓——常为主仓根）取不到可归属根，窗口段整体缺省：错误窗口
+  // （列出主仓无关文件）比没有更误导。纯本地模式 cwd 即变更仓，维持原行为。
+  const windowAttributable = platformOpts.specDriftAnchor ? true : !platformOpts.specRoot
   let windowNote = ''
-  try {
-    const porcelain = gitQuiet(cwd, ['status', '--porcelain'])
-    if (porcelain !== null) {
-      const paths = porcelain.split('\n').filter(Boolean).map((l) => (l.slice(3) || '').trim()).filter(Boolean)
-      windowNote = paths.length === 0
-        ? '；工作区无未提交变更'
-        : `；变更窗口 ${paths.length} 文件（${paths.slice(0, 3).map((p) => p.split(/[\\/]/).pop()).join('、')}${paths.length > 3 ? ' 等' : ''}）`
-    }
-  } catch { /* git 不可读 → 窗口段缺省（摘要仍成立） */ }
+  if (windowAttributable) {
+    try {
+      const porcelain = gitQuiet(cwd, ['status', '--porcelain'])
+      if (porcelain !== null) {
+        const paths = porcelain.split('\n').filter(Boolean).map((l) => (l.slice(3) || '').trim()).filter(Boolean)
+        if (paths.length === 0) {
+          windowNote = '；工作区无未提交变更'
+        } else {
+          // basename 在 pop 之后再过滤（坑 stage-burst ②）：未跟踪目录条目 `?? dir/` 尾段
+          // 为空串，pop 得 ''，join 出「（、）」空名——先取后滤，全空时只报计数不报名单。
+          const names = paths.slice(0, 3).map((p) => p.split(/[\\/]/).pop()).filter(Boolean)
+          windowNote = names.length === 0
+            ? `；变更窗口 ${paths.length} 文件`
+            : `；变更窗口 ${paths.length} 文件（${names.join('、')}${paths.length > 3 ? ' 等' : ''}）`
+        }
+      }
+    } catch { /* git 不可读 → 窗口段缺省（摘要仍成立） */ }
+  }
   return `【CLI 合成】步骤「${stepName}」完成${windowNote}；门禁以本次 CLI 校验输出为准（方案取舍等语义说明需 --output 手写）`
 }
 
 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, isNoDocs = false, isSkipApply = false, sessionFlag = null, quickFiles = [] } = 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 落盘
   // 必须与 prompt 渲染同一根，否则写进 worktree 副本目录、随 cleanup 整目录删除。
@@ -144,8 +188,8 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   }
 
   const steps = stageData.steps
-  // blocked（deps/review.json 门控阻断标记）也视为当前步骤（坑 deps-gate-blocked-invisible，
-  // 2026-08-27 实证）：门控阻断时 enforceDepsGate/enforceReviewJsonGate 把当前步置 blocked 后
+  // blocked（deps 门控阻断标记）也视为当前步骤（坑 deps-gate-blocked-invisible，
+  // 2026-08-27 实证）：门控阻断时 enforceDepsGate 把当前步置 blocked 后
   // exit(1)，若谓词漏 blocked，被阻断步骤对 findIndex 永久隐身——重试 --done 落到其后第一个
   // pending 步骤上（错步记账，DB 显示与事实脱节），且 blocked 步骤无任何恢复路径（状态机卡死，
   // 只能 --reset 丢进度）。门控本身在下方会重新校验：deps 已修复 → 正常完成；未修复 → 再次
@@ -210,7 +254,7 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   // --output 手写——合成摘要自带该指引。quick 阶段除外（末步四字段硬契约
   // validateQuickResult，合成文本过不了四字段校验；quick 的省略提示由其阶段文案承担）。
   if (!outputText && stageName !== 'quick' && currentIdx !== -1 && steps[currentIdx]) {
-    outputText = synthesizeStepOutput({ stageName, stepName: steps[currentIdx].name, cwd })
+    outputText = synthesizeStepOutput({ stageName, stepName: steps[currentIdx].name, cwd, platformOpts })
     console.log(`🤖 --output 未提供——CLI 已按事实合成步骤摘要（gate 校验照常；方案取舍等语义说明下次带 --output 手写）。`)
   }
   // ── waiting 前置守卫（坑 archive-step3-wait-answer-hint-late）──
@@ -345,9 +389,8 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   // progress show/doctor 看到的仍是 pending，误导诊断）
   const persistBlocked = () => pm._write(cwd, progress, changeName)
   await enforceDepsGate(stageName, cwd, changeName, steps[currentIdx], steps, currentIdx, specBase, platformOpts, persistBlocked)
-  // review.json 字段硬门（坑 review-json-field-gap）：已勾 [x] task 的 review.json 必须 schema 完整，
-  // 提前到每次 --done 校验（而非等 Task Review Gate 在整阶段收尾才暴露，迫使用户事后批量补）。
-  await enforceReviewJsonGate(stageName, cwd, changeName, steps[currentIdx], steps, currentIdx, specBase, platformOpts, persistBlocked)
+  // review.json 字段硬门（enforceReviewJsonGate）已随 Task Review 层退役删除
+  // （2026-09-26-task-review-retire）——勾选回归 agent 手动（完成=实现+测试绿+wt-commit 即勾）。
   // 符号影响面报告硬门（ql-20260816-005-3d7f）：execute「加载上下文」步产出落盘核验——
   // symbol-impact.md 存在 + plan 每 task 有结论行；防前缀步被一句「上下文在会话内」盖章跳过。
   await enforceSymbolImpactGate(stageName, changeName, steps[currentIdx]?.name, specBase)
@@ -502,7 +545,12 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   }
 
   steps[currentIdx].status = 'completed'
-  steps[currentIdx].completedAt = new Date().toLocaleString('zh-CN',{hour12:false})
+  // burst 单调时钟（坑 stage-burst-timeline-quality-collapse ①，2026-09-24 实证）：
+  // completeStepBurst 毫秒级循环收口 + 秒级时间串会把剩余步骤全部戳成同一秒——平台
+  // 步骤时间线九步同秒不可读。burst 每轮传 completedAtOverride（轮间严格递增）；
+  // 单步路径不传，落真实时刻不变。
+  const _completedStamp = options.completedAtOverride instanceof Date ? options.completedAtOverride : new Date()
+  steps[currentIdx].completedAt = _completedStamp.toLocaleString('zh-CN',{hour12:false})
   if (outputText) {
     const MAX_OUTPUT = 200
     if (outputText.length > MAX_OUTPUT) {
@@ -546,45 +594,47 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
 
   // execute 批量完成检测：plan 全勾 + 代码客观核验通过 → 剩余 step 一次性标 completed，
   // 使本次 --done 直接进入阶段完成分支（治"3 Wave 做完仍逐次 +1、需重走 7 次 --done"）。
-  // 先按 review.json pass 自动勾 plan checkbox（复用 continueStep 同源逻辑），再判批量条件。
+  // per-task 自动勾选与 review 草稿兜底已随 Task Review 层退役（2026-09-26-task-review-retire）：
+  // 勾选回归 agent 手动（完成=实现+测试绿+wt-commit 即勾，同 thin 工作单元语义），假勾防线由
+  // detectExecuteBatchFinish 内 checkExecuteCodeEvidence 代码证据核验 + verify 测试对账承担。
   if (stageName === 'execute' && changeName) {
-    const _ac = await autoCheckPlanFromReviews({ stageName, changeName, cwd, platformOpts })
-    if (_ac.autoChecked) {
-      console.log(`   ✅ 自动勾选 ${_ac.checkedCount} 个 task checkbox（基于 review.json pass）`)
-    }
-    if (_ac.skippedCount > 0) {
-      console.warn(`   ⚠️ ${_ac.skippedCount} 个 task 未勾（review.json 缺失/fail）→ 批量完成条件不满足，仍按单步推进`)
-    }
-    const _bf = await detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, platformOpts, steps })
-    if (_bf.batched && _bf.aligned > 0) {
-      console.log(`\n🚀 execute 批量完成：plan 全勾 + 代码核验通过，一次性补完 ${_bf.aligned} 个剩余 step → 进入阶段完成分支`)
-    }
-
-    // per-task review 草稿兜底（坑 worktree-execute-apply-friction 坑2）：主 agent 直接实现模式
-    // 无子代理 review 落盘 → Task Review Gate 报缺 review.json 阻断。每次 execute --done 跑（幂等，
-    // 已存在跳过），据 git diff base..head 按 allowed_paths 归属生成 cannot_verify 草稿，进 gate 前就位。
+    // 自动勾选（full-autopilot-parity，R21 thin 实证迁移）：execute --done 时解析 run 内提交的
+    // task-NN token，自动勾选 tasks.md 未勾条目——agent 手动勾选是 R19/R20 的行为惯性（tick-loop-nudge
+    // 提示词无效），机器代勾与 thin 的 flow done 同逻辑。fail-soft。
     try {
-      const { generateTaskReviewDrafts } = await import('../task-review.js')
-      // W3 task-09：best-effort 构造 ctx 透传（D-013），跨仓 task 草稿用跨仓 gitDir 取 diff。
-      // 失败降级 null（不阻断 execute 完成——草稿兜底本就是 best-effort，gate 会复校验）。
-      let _draftCtx = null
-      try {
-        _draftCtx = await getOrCreateMultiRepoContext({ cwd, changeName, platformOpts })
-      } catch (e) {
-        console.warn('   ⚠️ 草稿 ctx 构造失败，降级单仓草稿（' + (e && e.message ? e.message : e) + '）')
-      }
-      const _drafts = await generateTaskReviewDrafts({ changeName, cwd, platformOpts, ctx: _draftCtx })
-      if (_drafts.generated > 0) {
-        console.log('   📄 自动补写 ' + _drafts.generated + ' 个 per-task review.json 草稿（cannot_verify，主 agent 实现模式兜底，需 agent 复核后升级为 pass/fail）')
-        if (_drafts.noAttribution > 0) {
-          console.warn('   ⚠️ 其中 ' + _drafts.noAttribution + ' 个 task 的 allowed_paths 未命中本次 diff（无归属草稿，changedFiles 为空）——需人工确认实际改动后升级 verdict，确属未实现则回 fail')
-        }
-        if (_drafts.unattributed && _drafts.unattributed.length > 0) {
-          console.warn('   ⚠️ ' + _drafts.unattributed.length + ' 个变更文件未归属任何 task（顺带修复/非源码），草稿未覆盖：' + _drafts.unattributed.join(', '))
+      const _tasksMdPath = join(specBase, 'changes', changeName, 'tasks.md')
+      if (existsSync(_tasksMdPath)) {
+        const _runIdFile = join(resolveRuntimeRoot(platformOpts, specBase), `current-execute-run-id-${changeName}`)
+        let _tickCommits = ''
+        try {
+          if (existsSync(_runIdFile)) {
+            _tickCommits = gitQuiet(cwd, ['log', '--format=%B%x1e', 'HEAD~20..HEAD']) || ''
+          }
+        } catch {}
+        if (!_tickCommits) _tickCommits = gitQuiet(cwd, ['log', '--format=%B%x1e', '-20']) || ''
+        if (_tickCommits) {
+          const _texts = String(_tickCommits).split('\x1e').map(x => x.trim()).filter(Boolean).join('\n')
+          const _evidenced = new Set()
+          for (const m of _texts.matchAll(/task-(\d{1,2})/gi)) _evidenced.add(String(Number(m[1])).padStart(2, '0'))
+          if (_evidenced.size > 0) {
+            let _md = readFileSync(_tasksMdPath, 'utf8')
+            let _ticked = 0
+            for (const nn of _evidenced) {
+              const re = new RegExp(`^- \\[ \\](.*task-${nn}[:\\s])`, 'm')
+              if (re.test(_md)) { _md = _md.replace(re, `- [x]$1`); _ticked++ }
+            }
+            if (_ticked > 0) {
+              const { writeAtomicSync } = await import('../fs-atomic.js')
+              writeAtomicSync(_tasksMdPath, _md)
+              console.log(`✅ [自动勾选] ${_ticked} 个任务有提交证据但未勾——已机器代勾（full-autopilot-parity）`)
+            }
+          }
         }
       }
-    } catch (e) {
-      console.warn('   ⚠️ per-task review 草稿生成失败（不阻断 execute 完成）：' + (e && e.message ? e.message : e))
+    } catch { /* auto-tick fail-soft */ }
+    const _bf = await detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, platformOpts, steps })
+    if (_bf.batched && _bf.aligned > 0) {
+      console.log(`\n🚀 execute 批量完成：plan 全勾 + 代码核验通过，一次性补完 ${_bf.aligned} 个剩余 step → 进入阶段完成分支`)
     }
   }
 
@@ -594,9 +644,30 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
   // （测试对账/验收矩阵/module-impact 死信/PASS 封顶）照常全跑：批量省的是 --done
   // 肥上下文往返，不省任何门。镜像 execute 批量模式（乐观预标戳 + 失败一并回滚）。
   if (stageName === 'verify' && changeName) {
-    const _vb = detectVerifyBatchFinish({ changeName, specBase, steps })
-    if (_vb.batched && _vb.aligned > 0) {
-      console.log(`\n🚀 verify 批量完成：报告结论已填 + facts 在场，一次性补完 ${_vb.aligned} 个剩余 step → 进入阶段完成分支（收尾门禁照常全跑）`)
+    // 批量对齐前补亲测（cli-protocol-trust / R17 臂3 拦截⑥实证）：乐观对齐会把 noAI 亲测步
+    // （step4 verifyRunQualityScan）一并标 completed → 亲测永不执行 → 收尾 PASS 封顶门因
+    // integrationRan≠ran 拒 → gate_rollback → --reopen 四步绕行。对齐面含该步时先亲跑
+    // executeVerifyQualityScan（幂等+指纹复用——已有有效记录时秒回零重复实测），失败则放弃
+    // 批量保持单步推进（亲测步照 noAI 硬门走）——「批量省的是上下文往返，不省任何门」承诺恢复成立。
+    // 判定经 hasPendingVerifyScanStep：DB 步骤行只有 {name,status}（_cliAction 不持久化——评审
+    // P1 修复：初版直接读 s._cliAction 恒 false 死代码），按 stageRegistry 定义索引对齐判。
+    let _skipBatch = false
+    if (hasPendingVerifyScanStep(stageName, steps)) {
+      try {
+        const { executeVerifyQualityScan } = await import('./verify-quality-scan.js')
+        console.log('   🧪 批量对齐面含 noAI 亲测步——先亲测（幂等，有记录秒回）…')
+        await executeVerifyQualityScan({ cwd, specBase, changeName, platformOpts })
+        console.log('   🧪 noAI 亲测完成（质量扫描记录落盘，亲测门不省）')
+      } catch (e) {
+        console.warn('   ⚠️ 亲测补跑失败——放弃批量对齐，保持单步推进（亲测步按 noAI 硬门走）：' + (e && e.message ? e.message : e))
+        _skipBatch = true
+      }
+    }
+    if (!_skipBatch) {
+      const _vb = detectVerifyBatchFinish({ changeName, specBase, steps })
+      if (_vb.batched && _vb.aligned > 0) {
+        console.log(`\n🚀 verify 批量完成：报告结论已填 + facts 在场，一次性补完 ${_vb.aligned} 个剩余 step → 进入阶段完成分支（收尾门禁照常全跑）`)
+      }
     }
   }
 
@@ -619,8 +690,11 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     }
     // quick 收尾（W6 Step6b 抽至 complete-handlers.js handleQuickStageCompletion）；
     // isNoDocs（task-02）--no-docs 豁免随链透传进 auditQuickCompletion options；
-    // sessionFlag（task-03）--session 随链透传进 quick 轻量归档链所有权校验
-    await handleQuickStageCompletion({ stageName, steps, currentIdx, cwd, progress, changeName, specBase, outputText, confirm, isForceBaseline, isAllowNew, isAllowDelete, isNoDocs, sessionFlag, platformOpts, pm, quickFiles })
+    // sessionFlag（task-03）--session 随链透传进 quick 轻量归档链所有权校验；
+    // linkedChanges/linkedChangesAuto（R4-S-Q 缺陷 B）：--done 时显式 --linked-changes 随链透传——
+    // 完成侧 guard 从落盘文件读，不接 opts 会静默丢弃 --done 时声明的关联（蒸馏尾/quicklog
+    // 关联变更行/closeQuickLinkedChanges 三处消费同断）
+    await handleQuickStageCompletion({ stageName, steps, currentIdx, cwd, progress, changeName, specBase, outputText, confirm, isForceBaseline, isAllowNew, isAllowDelete, isNoDocs, sessionFlag, platformOpts, pm, quickFiles, linkedChanges, linkedChangesAuto })
 
     // ── reopen --done 回填（坑 brainstorm-reopen-step-state-desync）──
     // nextPendingIdx === -1 且无 waiting，说明要进阶段完成分支。此时若存在 stale 步骤
@@ -709,7 +783,7 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
 
     // gate 全过：persist completed（task-01 移后）。此处到 _write 之间若崩，DB 仍 in-progress（内存已 completed 但未落盘），下次进 CLI 读 DB 即 in-progress，不产生"假 completed"。
     pm._write(cwd, progress, changeName)
-    triggerSync(cwd, changeName, platformOpts)
+    triggerSync(cwd, changeName, platformOpts, { completion: true })
 
     const total = steps.length
     console.log(`✅ ${stageName} 阶段已完成（${total}/${total} 步）`)
@@ -717,8 +791,54 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     // 瘦会话交接提示（P1-5 v1，2026-09-20 对撞实验驱动）：主流程阶段完成时点提示
     // 「下一阶段可新会话续跑」——CLI prompt 自足（进度/上下文全由进度库与注入提供），
     // 每阶段一个瘦会话省掉肥上下文 × N 请求的重发税。advisory 一行，不强制。
+    // ④（2026-09-23 R9 实证后）升级：同一会话连续完成 ≥2 阶段 → 肥上下文税升级告警
+    // （带实测数据 + handoff 机器预览态接力段引用 + 动作主体写明用户/平台——CLI 只产信号
+    // 不做编排，conventions 钉死的架构约束）。账本仿 wave-session-ledger（best-effort）。
     if (['brainstorm', 'plan', 'execute', 'verify'].includes(stageName) && changeName) {
-      console.log(`💡 瘦会话模式：下一阶段可在新会话续跑（sillyspec handoff --change ${changeName} 生成交接块；保持 SILLYSPEC_SESSION_ID 不变）——省肥上下文重发税`)
+      let stageLedger = null
+      let crossStage = false
+      try {
+        const ledgerPath = join(specBase, '.runtime', `stage-session-ledger-${changeName}.json`)
+        try { stageLedger = JSON.parse(readFileSync(ledgerPath, 'utf8')) } catch { /* 首阶段 */ }
+        const r = updateStageSessionLedger(stageLedger, process.env.SILLYSPEC_SESSION_ID, stageName)
+        stageLedger = r.ledger
+        crossStage = r.crossStageAdvisory
+        try { mkdirSync(join(specBase, '.runtime'), { recursive: true }); writeFileSync(ledgerPath, JSON.stringify(stageLedger, null, 1) + '\n', 'utf8') } catch { /* 账本 best-effort */ }
+      } catch { /* ④ 升级提示 best-effort 零副作用 */ }
+      // R16-b 修正（2026-09-25）：plan ⛔ 优先于 crossStage 升级告警——plan+brainstorm 同会话
+      // 完成时（stageCount=2）此前走告警分支把 ⛔ 压掉了，agent 只见建议不见断崖动作。
+      if (stageName === 'plan') {
+        // 阶段断崖 B（R16 减负批次 A 相位，2026-09-24）：plan→execute 是第二大跳变——
+        // execute 是最大单段（R15 45.6M/173r/均轮 263K，占全流程 53%），带着 brainstorm+plan
+        // 的 14-16M 历史跑 execute 每轮都在重放。⛔ directive 级（同 execute→verify 模板）。
+        console.log(``)
+        console.log(`⛔ 阶段断崖：plan 已收口，execute 建议在新的瘦会话执行。`)
+        console.log(`   本会话上下文已含 brainstorm+plan 全部历史（R15 实测 execute 段 45.6M/173 轮/均轮 263K——大头是历史重放税，活只有十几 M）。`)
+        console.log(`   execute 的全部输入在盘上（design.md/plan.md/tasks/task-*.md），新会话零背景可续跑。`)
+        console.log(`   动作：`)
+        console.log(`   1. sillyspec handoff --change ${changeName}   # 生成交接块（即切割凭证，stage.wall=hard 下生成后墙自动放行）`)
+        console.log(`   2. 新会话/子代理：粘贴交接块 → run execute --change ${changeName}`)
+        console.log(`   同会话硬续会被 stage.wall=hard 在 run 入口拒（--same-session 逃生口）。`)
+      } else if (stageName === 'execute') {
+        // 阶段断崖（2026-09-24 第一性原理落地）：execute→verify 是上下文最贵的跳变
+        // （R11 实测 verify 71 轮 × 300K/轮 = 21.3M，其中 ~17M 是 execute 历史重放税）。
+        // verify 的每一步输入都在盘上（design/tasks/review/verify-probes），零对话依赖。
+        // ⛔ directive 级——agent 看到应当执行 handoff 而非硬续。
+        console.log(``)
+        console.log(`⛔ 阶段断崖：execute 已收口，verify 必须在新的瘦会话执行。`)
+        console.log(`   本会话上下文已含 execute 全部历史（R11 实测 verify 阶段因历史重放多付 ~17M token——占总 24%）。`)
+        console.log(`   verify 的全部输入在盘上（design.md/tasks/review.json/verify-probes），新会话零背景可续跑。`)
+        console.log(`   动作：`)
+        console.log(`   1. sillyspec handoff --change ${changeName}   # 生成交接块（即切割凭证，stage.wall=hard 下生成后墙自动放行）`)
+        console.log(`   2. 新会话/子代理：粘贴交接块 → run verify --change ${changeName}`)
+        console.log(`   同会话硬续会被 stage.wall=hard 在 run 入口拒（--same-session 应急逃生口）。`)
+      } else if (crossStage && stageLedger) {
+        console.log(`\n⚠️ 肥上下文税升级告警：本会话（${stageLedger.sessionId}）已连续完成 ${stageLedger.stageCount} 个阶段（${(stageLedger.stages || []).join(' → ')}）——单上下文历史重放实测在累积（R9：五阶段 53.5M 输入、尾段单轮 30 万+、归档 3 分钟烧 7.2M）。`)
+        console.log(`   建议现在换会话：sillyspec handoff --change ${changeName}（交接块含机器预览态接力段——watcher 投影的进行态参考）→ 由**用户新开会话**（或平台 session-fork）续跑下一阶段；保持 SILLYSPEC_SESSION_ID 不变。`)
+        console.log(`   会话不能自建会话——编排权在用户/平台，CLI 只产信号与接力载荷（conventions 架构约束）。同会话硬续不阻断。`)
+      } else {
+        console.log(`💡 瘦会话模式：下一阶段可在新会话/子代理续跑（sillyspec handoff --change ${changeName} 生成交接块；保持 SILLYSPEC_SESSION_ID 不变）——CLI prompt 自足`)
+      }
     }
 
     // 平台模式产物落点指针（platform-docs-dual-location，2026-09-15 EHS 实证）：完成时点在
@@ -784,7 +904,7 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
       // 历史教训：曾因此让 agent 在 brainstorm 完成后被误导去跑 scan。
       const _bscale = readDesignScale(specBase, changeName)
       if (_bscale === 'small') {
-        console.log(`\n👉 brainstorm 已完成（small）。下一步：sillyspec run quick --linked-changes ${changeName}`)
+        console.log(`\n👉 brainstorm 已完成（small）。下一步：sillyspec flow start --change ${changeName}（轻量变更收编头脑风暴产物，2 调用收口）`)
       } else {
         console.log(`\n👉 brainstorm 已完成。下一步：sillyspec run plan${changeName ? ` --change ${changeName}` : ''}（scale=large 或未标 small 走完整 plan）`)
       }
@@ -812,7 +932,7 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
 
   progress.lastActive = new Date().toLocaleString('zh-CN',{hour12:false})
   pm._write(cwd, progress, changeName)
-  triggerSync(cwd, changeName, platformOpts)
+  triggerSync(cwd, changeName, platformOpts, { completion: true })
   // 单步完成也刷新 change title：design.md 在 brainstorm step6 落盘，此后每次 --done 都该让
   // changes.title 反映中文描述，不等阶段收尾（机制见 refreshChangeTitleFromArtifacts）。
   refreshChangeTitleFromArtifacts(pm, cwd, specBase, changeName)
@@ -844,6 +964,27 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     if (defSteps && defSteps[nextPendingIdx]) {
       console.log(`\n🚀 advanced to step ${nextPendingIdx + 1}/${steps.length}: ${defSteps[nextPendingIdx].name}`)
     }
+    // ── Wave 边界 handoff 默认动作（2026-09-21 R5 接线 ql-20260921-007，①）──
+    // 刚完成的步是 Wave 步且下一步也是 Wave 步 = Wave 边界：把「换瘦会话」从建议升为默认动作
+    // （同会话硬续不阻断——advisory 语义）。账本：同会话跨 ≥2 Wave 时提示语气升级（肥上下文税
+    // 累积实证见 updateWaveSessionLedger 注释）。best-effort：账本读写失败零输出不阻断。
+    if (stageName === 'execute' && changeName && defSteps && defSteps[currentIdx] && defSteps[nextPendingIdx] &&
+        /Wave \d+ 执行/.test(defSteps[currentIdx].name || '') && /Wave \d+ 执行/.test(defSteps[nextPendingIdx].name || '')) {
+      try {
+        const ledgerPath = join(specBase, '.runtime', `wave-session-ledger-${changeName}.json`)
+        let ledger = null
+        try { ledger = JSON.parse(readFileSync(ledgerPath, 'utf8')) } catch { /* 首 Wave */ }
+        const { ledger: nextLedger, crossWaveAdvisory } = updateWaveSessionLedger(ledger, process.env.SILLYSPEC_SESSION_ID, defSteps[currentIdx].name)
+        try { mkdirSync(join(specBase, '.runtime'), { recursive: true }); writeFileSync(ledgerPath, JSON.stringify(nextLedger, null, 1) + '\n', 'utf8') } catch { /* 账本 best-effort */ }
+        console.log(`\n🔄 Wave 边界——默认动作：下一 Wave 换瘦会话续跑（每请求背全量历史，130K 上下文 ×每步重发≈1/4 墙钟，实测 2026-09-21）：`)
+        console.log(`   1. sillyspec handoff --change ${changeName}   # 生成交接块（含任务面/未决阻断/决策 ID 回源）`)
+        console.log(`   2. 新会话（SILLYSPEC_SESSION_ID 不变）粘贴交接块 → sillyspec run execute --change ${changeName}`)
+        console.log(`   同会话硬续不阻断；上下文已压缩过（Read 旧工件可回源）则续跑无妨。`)
+        if (crossWaveAdvisory) {
+          console.log(`   ⚠️ 本会话已完成 ${nextLedger.waveCount} 个 Wave——肥上下文税在累积（缓存救账单不救墙钟），强烈建议 handoff。`)
+        }
+      } catch { /* 边界提示 best-effort */ }
+    }
     // quick 末步四字段前置预告（坑 quick-step3-four-fields-late）：末步 --done 的 --output 四字段
     // 是硬校验（缺任一项被拒 + 回滚），但模板藏在 step3 长 prompt 中段——task-08 同因（长 prompt
     // 易被 tail 截断），agent 常到 --done 被拦才第一次见到模板。推进到末步的此刻用底部短块预告
@@ -1126,6 +1267,139 @@ function prefetchDiffFileSet(ctx) {
   }
 }
 
+/**
+ * burst 完成侧循环包装（2026-09-22-stage-burst-fold D-003@v2/D-004@v2/D-005/D-009，FR-03）：
+ * burst 模式下一次 --done 收口全部剩余步——循环调既有 completeStep（**本体零改动**，全部守卫
+ * ——WAIT 硬校验/waiting 前置/requiresWait 门控/意图断言/门禁/并发防护——逐轮原样生效）。
+ *
+ * 循环语义（每轮）：
+ * 1. **轮首：尾随 stale 拉回**（D-003@v2，钉死先于退出判定——「仅剩尾随 stale、无 pending」的轮
+ *    必须先拉回再判退出，否则 --reopen 中途开 burst 时渲染集合与完成集合发散、stale 尾残留阶梯）：
+ *    首个非 completed/skipped 步为 stale → 拉回 pending + pm._write（与 runStage 单步路径同语义）。
+ * 2. 重算 pending（谓词 pending|in-progress|blocked，与 completeStep 内部一致）；无 → 退出循环。
+ * 3. 调 completeStep(pm, progress, stageName, cwd, **null**, inputText, {...roundOptions, printNext:false})
+ *    ——每轮 outputText=null 走 P0-2 事实合成（per-step 摘要 CLI 合成，agent 只给一次整体 --output）。
+ *    completeStep 遇守卫失败 process.exit 即 burst 天然断点（agent 修复后重跑 --done 从断点幂等续推）；
+ *    续推/停轮以每轮后重读 DB 态为准（正常完成也返回 truthy 进度对象——真值性不代表失败）：
+ *    无 pending → 收口透传；pending 未前进（失败步保持/重拦）→ 停断点 + exitCode=1。
+ * 4. 每轮后 pm.read 重读（null=并发归档删除 → 报错 exitCode=1，对齐 command.js auto 路径 BUG-05 语义）。
+ * 5. **--answer 单次消费**（D-004@v2）：轮前快照全部步 waitAnswer、轮后比对——任一步 waitAnswer
+ *    新变为 === doneAnswer → 已消费，后续轮剥离（防 brainstorm 双 requiresWait 步〔选方案/确认设计〕
+ *    把步4答案错填步5；快照比对防 waiting 解析重定向漏检）。
+ * 6. **--step 断言仅首轮**（D-005）：第二轮起当前步已推进、断言必然 mismatch，首轮后剥离。
+ *
+ * 循环上限 50 轮（单阶段步数不可能超），耗尽仍有 pending → 报错防死循环。
+ * agent 的整体 --output 只打一行横幅（D-009：不落步记录——语义错归属会污染步骤审计面）。
+ *
+ * @param {import('./shared.js').ProgressManagerLike} pm
+ * @param {object} progress
+ * @param {string} stageName
+ * @param {string} cwd
+ * @param {string|null} outputText agent 整体摘要（仅横幅展示，不落步记录）
+ * @param {string|null} [inputText]
+ * @param {object} [options] 透传 completeStep 全量字段（printNext 强制 false、每轮 outputText 强制 null）
+ * @returns {Promise<object|undefined>} 末轮 completeStep 返回值
+ */
+export async function completeStepBurst(pm, progress, stageName, cwd, outputText, inputText = null, options = {}) {
+  if (outputText) console.log(`📦 burst 收口摘要：${outputText}`)
+  let roundOptions = { ...options, printNext: false }
+  // burst 单调时钟基准（坑 stage-burst ①）：null=首轮（用真实时刻），此后每轮保严格递增
+  let burstClock = null
+  const MAX_ROUNDS = 50
+  let lastResult
+  for (let round = 0; round < MAX_ROUNDS; round++) {
+    // ① 轮首尾随 stale 拉回（先于退出判定）
+    const stepsNow = progress?.stages?.[stageName]?.steps
+    if (Array.isArray(stepsNow) && stepsNow.length > 0) {
+      const firstOpenIdx = stepsNow.findIndex(s => s && s.status !== 'completed' && s.status !== 'skipped')
+      if (firstOpenIdx !== -1 && stepsNow[firstOpenIdx].status === 'stale') {
+        console.log(`⚠️  Step "${stepsNow[firstOpenIdx].name}" 处于 stale，burst 轮首拉回待执行。`)
+        stepsNow[firstOpenIdx].status = 'pending'
+        // 拉回清残留（坑 stage-burst-timeline-quality-collapse ③，2026-09-24 实证）：拉回
+        // 仅改 status 不清 output/completedAt → 平台时间线出现「pending 步挂着已完成合成
+        // 文案」的矛盾态行。与 reopenStage fromStep 步口径一致（pending 必不带完成面）。
+        delete stepsNow[firstOpenIdx].output
+        delete stepsNow[firstOpenIdx].output_truncated
+        delete stepsNow[firstOpenIdx].output_original_length
+        delete stepsNow[firstOpenIdx].completedAt
+        pm._write(cwd, progress, options.changeName)
+      }
+    }
+    // ② 重算 pending（谓词与 completeStep 内部一致）
+    const stepsForPending = progress?.stages?.[stageName]?.steps
+    const pendingIdx = Array.isArray(stepsForPending)
+      ? stepsForPending.findIndex(s => s && (s.status === 'pending' || s.status === 'in-progress' || s.status === 'blocked'))
+      : -1
+    if (pendingIdx === -1) {
+      if (round === 0) {
+        // 退化场景对齐（execute 轮 Grill P2-2）：无任何待完成步的 --done 委托 completeStep 走
+        // 既有 no-pending 处理（「没有待完成的步骤」报错 / --confirm stale 回填 / 矛盾态自愈）
+        // ——burst 不静默吞掉该信号（静默 break 会让 auto 路径跳过 nextInFlow 推进）。
+        return await completeStep(pm, progress, stageName, cwd, outputText ?? null, inputText, roundOptions)
+      }
+      break
+    }
+    // ③ 轮前 waitAnswer 快照（D-004@v2 消费检测基准）
+    const answerSnapshot = roundOptions.doneAnswer != null && Array.isArray(stepsForPending)
+      ? stepsForPending.map(s => (s && s.waitAnswer) || null)
+      : null
+    // 单调时钟（坑 stage-burst-timeline-quality-collapse ①）：completedAt 是秒级字符串——
+    // 比较必须取秒粒度（毫秒级真实推进落在同一秒内仍会产出相同字符串），同秒或追不上
+    // 上一轮戳 → +1s 递增，保轮间 completedAt 字符串严格互异且递增（平台时间线可读）。
+    const _now = new Date()
+    const _stamped = (!burstClock || Math.floor(_now.getTime() / 1000) > Math.floor(burstClock.getTime() / 1000))
+      ? _now
+      : new Date(burstClock.getTime() + 1000)
+    burstClock = _stamped
+    const result = await completeStep(pm, progress, stageName, cwd, null, inputText, {
+      ...roundOptions,
+      completedAtOverride: _stamped,
+    })
+    lastResult = result
+    // ④ 每轮后重读（completeStep 内部已落库；重读后下一轮谓词基于真实 DB 态）。
+    // 注意 completeStep 正常完成单步也返回 truthy 进度对象（{stageCompleted:false, nextPendingIdx}）
+    // ——续推/停轮判定以重读 DB 态为准，不以返回值真值性为准（探针实证：步 7 正常完成返回
+    // {stageCompleted:false,currentIdx:6,nextPendingIdx:7}）。
+    const fresh = pm.read(cwd, options.changeName)
+    if (!fresh) {
+      console.error(`❌ burst 收口推进后进度数据消失（变更 ${options.changeName} 可能被并发归档/删除），请用 sillyspec progress show 核对当前状态`)
+      process.exitCode = 1
+      return lastResult
+    }
+    progress = fresh
+    // 停轮判定：重读后无 pending → 阶段收口（gate 返回态由 lastResult 透传）；pending 未前进
+    //（门禁失败步保持 pending / blocked 重拦 / 前置步被重置）→ 停在断点防同步锤击（重跑幂等续推）。
+    const stepsAfterRound = progress?.stages?.[stageName]?.steps
+    const nextPendingIdx = Array.isArray(stepsAfterRound)
+      ? stepsAfterRound.findIndex(s => s && (s.status === 'pending' || s.status === 'in-progress' || s.status === 'blocked'))
+      : -1
+    if (nextPendingIdx === -1) break
+    if (nextPendingIdx <= pendingIdx) {
+      if (!process.exitCode) process.exitCode = 1
+      break
+    }
+    // ⑤ --answer 单次消费：快照比对（任一步 waitAnswer 新变为 === doneAnswer 即已消费）
+    if (roundOptions.doneAnswer != null && answerSnapshot) {
+      const stepsAfter = progress?.stages?.[stageName]?.steps || []
+      const consumed = stepsAfter.some((s, i) => s && s.waitAnswer === roundOptions.doneAnswer
+        && (answerSnapshot[i] == null || answerSnapshot[i] !== roundOptions.doneAnswer))
+      if (consumed) roundOptions = { ...roundOptions, doneAnswer: undefined }
+    }
+    // ⑥ --step 断言仅首轮
+    if (round === 0 && roundOptions.stepAssert !== undefined) roundOptions = { ...roundOptions, stepAssert: undefined }
+  }
+  // 防死循环：耗尽仍有 pending
+  const stepsFinal = progress?.stages?.[stageName]?.steps
+  const stillOpenIdx = Array.isArray(stepsFinal)
+    ? stepsFinal.findIndex(s => s && (s.status === 'pending' || s.status === 'in-progress' || s.status === 'blocked'))
+    : -1
+  if (stillOpenIdx !== -1) {
+    console.error(`❌ burst 收口循环达到上限（${MAX_ROUNDS} 轮）仍有待完成步骤「${stepsFinal[stillOpenIdx].name}」——疑似状态推进异常，请 sillyspec progress show 核对后重跑。`)
+    process.exitCode = 1
+  }
+  return lastResult
+}
+
 /**
  * 判定 task 是否该被 autoCheckPlanFromReviews 自动勾选。
  * 端到端/deployment-critical task 要求 review spec+quality 双 pass（cannot_verify 不算，防批量完成
@@ -1292,6 +1566,22 @@ export async function autoCheckPlanFromReviews({ stageName, changeName, cwd, pla
  * verify-facts.json 在场（探针跑过）+ 锚定步（step 1-2）已完成。批量只标剩余 step
  * completed，收尾门禁由阶段完成分支照常执行（批量不绕门）。
  */
+/**
+ * 批量对齐面是否含未完成的 verify 亲测步（cli-protocol-trust，评审 P1 修复的判定半边）：
+ * DB 步骤行只有 {name,status}——_cliAction 在 stageRegistry 的步骤定义上，按索引对齐判定
+ * （进度库步骤按定义种子，同序同名）；步对象自带 _cliAction 时兜底直读。导出供 test 直测。
+ */
+export function hasPendingVerifyScanStep(stageName, steps) {
+  try {
+    const defSteps = stageRegistry[stageName]?.steps || []
+    return (steps || []).some((s, i) =>
+      (s.status === 'pending' || s.status === 'in-progress') &&
+      (s._cliAction === 'verifyRunQualityScan' || defSteps[i]?._cliAction === 'verifyRunQualityScan'))
+  } catch {
+    return false // fail-open：判定异常不阻断批量（亲测门兜底由收尾对账承担）
+  }
+}
+
 export function detectVerifyBatchFinish({ changeName, specBase, steps }) {
   if (!changeName) return { batched: false, aligned: 0 }
   try {
@@ -1570,7 +1860,7 @@ export async function waitStep(pm, progress, stageName, cwd, outputText, waitRea
 
   progress.lastActive = now
   pm._write(cwd, progress, changeName)
-  triggerSync(cwd, changeName, platformOpts)
+  triggerSync(cwd, changeName, platformOpts, { completion: true })
 
   // 盖章路径的收尾提示独立分叉：wait 已在记录态完成（非等待用户），提示 --done 直接收尾；
   // 无 --inherit-from 路径输出与现状逐字节一致（兼容红线）。
@@ -1700,7 +1990,7 @@ export async function continueStep(pm, progress, stageName, cwd, answer, options
 
   progress.lastActive = now
   pm._write(cwd, progress, changeName)
-  triggerSync(cwd, changeName, platformOpts)
+  triggerSync(cwd, changeName, platformOpts, { completion: true })
   // wait 解除持久化点（含 repeatable 多轮）同样刷新 change title——多轮确认期间 design.md 已存在
   refreshChangeTitleFromArtifacts(pm, cwd, specBase, changeName)
 
@@ -1809,14 +2099,6 @@ export async function continueStep(pm, progress, stageName, cwd, answer, options
       if (stageName === 'execute') {
         console.log(`   ⚠️ 若 worktree 改动还没 apply 到主工作区，先：sillyspec worktree apply ${changeName}`)
         console.log(`   （apply 不需要先 commit，支持 working tree 未提交改动）`)
-        // plan.md checkbox auto-check：execute 完成 + review.json pass → 自动勾选（治本，比警告可靠）
-        const _ac = await autoCheckPlanFromReviews({ stageName, changeName, cwd, platformOpts })
-        if (_ac.autoChecked) {
-          console.log(`   ✅ 自动勾选 ${_ac.checkedCount} 个 task checkbox（基于 review.json pass）`)
-        }
-        if (_ac.skippedCount > 0) {
-          console.warn(`   ⚠️ ${_ac.skippedCount} 个 task 未勾（review.json 缺失/fail）→ archive 会拦。补 review 后重跑 execute --done 触发自动勾`)
-        }
       }
     }
     return { stageCompleted: true, currentIdx, nextPendingIdx: -1 }
@@ -1876,7 +2158,7 @@ export async function skipStep(pm, progress, stageName, cwd, changeName, platfor
   steps[currentIdx].skippedAt = new Date().toLocaleString('zh-CN',{hour12:false})
   progress.lastActive = new Date().toLocaleString('zh-CN',{hour12:false})
   pm._write(cwd, progress, changeName)
-  triggerSync(cwd, changeName, platformOpts)
+  triggerSync(cwd, changeName, platformOpts, { completion: true })
 
   console.log(`⏭️ Step ${currentIdx + 1}/${steps.length} 已跳过：${steps[currentIdx].name}`)