sillyspec 3.29.4 → 3.30.0

package/src/review-material-pack.js

@@ -23,7 +23,7 @@
  * 是 prompt.js tier 注入链的组包入口——机械抽素材半边（designDigest/fileList/硬约束/diff/热区/
  * checklist），主代理点名半边（五交叉点/plan 差量）留位不预填（decisions.md D-002）。
  */
-import { readFileSync } from 'fs'
+import { mkdirSync, readFileSync, writeFileSync } from 'fs'
 import { join } from 'path'
 import { REVIEW_CHECKLISTS } from './stage-review-checklist.js'
 
@@ -132,9 +132,15 @@ export function buildReviewMaterialPack(stage, inputs = {}) {
     const delta = (inputs.planDelta || []).map(d => `- [${d.id}] ${d.status}${d.note ? '——' + d.note : ''}`).join('\n')
     body = ['### design 硬约束', hc || '（无）', '### plan 差量（逐约束判定：一致/偏离/未覆盖）', delta || '（无——主代理未提供差量，评审者按 cannot_verify 列缺件）'].join('\n\n')
   } else if (stage === 'execute-qa') {
+    // 测试清单（R16 减负批次 2026-09-24）：diff 命中的测试文件点名——QA 对「组装行为」条目
+    // 作答时不必全仓找测试（R14 对撞失控勘察子代理 2.33M 的反面教材后，包内点名收窄查证面）。
+    const testFiles = (inputs.diffSummary && inputs.diffSummary.files || [])
+      .filter(f => /(^|[\\/])(tests?|__tests__)([\\/])|\.(test|spec)\.[cm]?[jt]sx?$|_test\.(go|py)$|(^|[\\/])test_[^\\/]+\.py$/i.test(f))
+      .slice(0, 30)
     body = [
       '### diff 摘要', (inputs.diffSummary && inputs.diffSummary.files || []).map(f => '- ' + f).join('\n') || '（无）',
       inputs.diffSummary && inputs.diffSummary.stat ? '```diff\n' + inputs.diffSummary.stat + '\n```' : '',
+      '### 测试清单（diff 命中的测试文件）', testFiles.map(f => '- ' + f).join('\n') || '（diff 无测试文件——「组装行为」条目按包不足处理：cannot_verify 列缺件或定向查证并列明）',
       '### design 热区（CLI 抽取）', extractDesignHotZone(inputs.designContent || '') || '（无命中节）',
       '### 验收清单', (inputs.checklist || []).map(c => '- [ ] ' + c).join('\n') || '（无）',
     ].filter(Boolean).join('\n\n')
@@ -263,3 +269,200 @@ export async function assembleStageReviewMaterials({ stage, cwd, changeName, spe
   } catch { /* 装配 best-effort：失败零注入（与占位符缺失同态） */ }
   return ''
 }
+
+// ══ execute 任务材料包（2026-09-21-r5-efficiency-batch1 task-02，B-④ / D-003）════
+// 两段式装配：稳定段（design.md「接口定义」「文件变更清单」固定节名机械选取原文 + 签名锚点）
+// 在前、专属段（task 卡 title/goal/implementation/acceptance + allowed_paths）在后——稳定前缀
+// 跨任务共享，兑现统一前缀缓存收益（压 task-08 型子代理轮均 148K vs 同侪 45-92K 差额）。
+// 只摘不译（D-003 错键正典红线）：一切内容为源文件原文逐字摘录/字段机械抽取，禁转写缩写。
+
+/** 材料包字节上限（专属段尾部优先截；稳定段超限按节优先级截断——见 assembleExecuteTaskMaterials） */
+const EXEC_MATERIALS_MAX_BYTES = 24576
+/** 被截节保底形态里「首个代码块/表格」的块级上限（单块病态体量防穿顶） */
+const EXEC_STUB_BLOCK_MAX_BYTES = 3600
+
+function bytesOf(s) { return Buffer.byteLength(String(s || ''), 'utf8') }
+
+/** 字节安全截断（按 UTF-8 字节预算切，不切断多字节字符） */
+function byteSafeSlice(text, maxBytes) {
+  const s = String(text || '')
+  if (bytesOf(s) <= maxBytes) return s
+  let out = ''
+  let used = 0
+  for (const ch of s) {
+    const b = Buffer.byteLength(ch, 'utf8')
+    if (used + b > maxBytes) break
+    out += ch
+    used += b
+  }
+  return out
+}
+
+/** 节内首个完整代码块（``` 围栏）或表格（连续 | 行）——被截节的保底保留形态 */
+function firstBlockOrTable(body) {
+  const fence = body.match(/```[^\n]*\n[\s\S]*?```/)
+  if (fence) return fence[0]
+  const lines = body.split('\n')
+  const start = lines.findIndex(l => l.trim().startsWith('|'))
+  if (start >= 0) {
+    let end = start
+    while (end < lines.length && lines[end].trim().startsWith('|')) end++
+    return lines.slice(start, end).join('\n')
+  }
+  return null
+}
+
+/** task 卡 frontmatter 块级解析（机械逐字）：顶格 key 行归属，其后缩进行归当前 key */
+function splitTaskCardFields(cardText) {
+  const m = String(cardText || '').match(/^---\r?\n([\s\S]*?)\r?\n---/)
+  if (!m) return {}
+  const fields = {}
+  let cur = null
+  for (const line of m[1].split(/\r?\n/)) {
+    if (/^[A-Za-z_][\w-]*:/.test(line)) {
+      const at = line.indexOf(':')
+      cur = { key: line.slice(0, at), raw: line.slice(at + 1).trim(), lines: [] }
+      fields[cur.key] = cur
+    } else if (cur) {
+      cur.lines.push(line)
+    }
+  }
+  return fields
+}
+
+function unquoteScalar(v) {
+  const s = String(v || '')
+  return s.replace(/^'(.*)'$/s, '$1').replace(/^"(.*)"$/s, '$1')
+}
+
+/**
+ * task 卡字段取值（只摘不译——原文保持，无 YAML 折叠语义改写）：
+ * 块标量（>/|）→ 原始行去公共缩进后逐行拼接；列表 → `- ` 后原文数组；标量 → 去包裹引号。
+ * @returns {string|string[]}
+ */
+function taskCardFieldValue(field) {
+  if (!field) return ''
+  if (/^[>|][+-]?$/.test(field.raw)) {
+    const indents = field.lines.filter(l => l.trim()).map(l => l.match(/^[ \t]*/)[0].length)
+    const cut = indents.length ? Math.min(...indents) : 0
+    return field.lines.map(l => (l.trim() ? l.slice(cut) : '')).join('\n').trim()
+  }
+  if (field.raw) return unquoteScalar(field.raw)
+  const items = []
+  for (const l of field.lines) {
+    const im = l.match(/^\s*-\s?(.*)$/)
+    if (im && im[1].trim()) items.push(im[1].trim())
+  }
+  return items
+}
+
+/**
+ * 组装 execute 任务材料包（两段式，只摘不译——契约见 change design.md「接口定义」）。
+ * @param {object} opts
+ * @param {string} opts.changeDir         - 变更目录（读 design.md / tasks/task-NN.md）
+ * @param {string} opts.taskId            - 'task-NN'
+ * @param {string} [opts.materialsDir]    - 落盘目录；缺省 → 不落盘不抛错返回 null（additive）
+ * @param {Array<{symbol: string, file: string, line: number}>} [opts.signatureAnchors]
+ *                                        - 接口签名锚点（可选，调用方供给；缺省空）
+ * @returns {Promise<{path: string, bytes: number, truncated: boolean}|null>}
+ *   截尾序：①专属段尾部优先截（稳定段全量保留）；②稳定段自身超限按节优先级（接口定义 >
+ *   文件变更清单——高优先节后截）逐节降为「节头 + 首个代码块/表格 + 回源指引行」；锚点永不丢。
+ */
+export async function assembleExecuteTaskMaterials({ changeDir, taskId, materialsDir, signatureAnchors }) {
+  if (!changeDir || !taskId || !materialsDir) return null
+  const designPath = join(changeDir, 'design.md')
+  const taskCardPath = join(changeDir, 'tasks', `${taskId}.md`)
+  let designContent = ''
+  let cardContent = ''
+  try { designContent = readFileSync(designPath, 'utf8') } catch { /* 缺 design → 稳定段只剩锚点 */ }
+  try { cardContent = readFileSync(taskCardPath, 'utf8') } catch { /* 缺卡 → 专属段仅回源指引 */ }
+
+  // ── 稳定段素材：固定节名机械选取（缺节跳过）+ 签名锚点行 ──
+  const anchors = (Array.isArray(signatureAnchors) ? signatureAnchors : [])
+    .filter(a => a && a.symbol)
+    .map(a => `- \`${String(a.symbol)}\` → ${a.file || '?'}:${a.line || '?'}`)
+  const anchorsBlock = anchors.length ? `### 接口签名锚点\n\n${anchors.join('\n')}` : ''
+
+  const SECTION_SPECS = [{ name: '接口定义' }, { name: '文件变更清单' }] // 序 = 保留优先级序
+  const secBlocks = SECTION_SPECS
+    .map(s => ({ ...s, body: sectionBody(designContent, s.name) }))
+    .filter(s => s.body)
+    .map(s => ({ ...s, full: `### ${s.name}（design.md 原文摘录）\n\n${s.body}` }))
+
+  /** 被截节残体：节头 + 首个代码块/表格（块级 clamp）+ 一行回源指引 */
+  const stubOf = s => {
+    const first = firstBlockOrTable(s.body)
+    const kept = first
+      ? (bytesOf(first) > EXEC_STUB_BLOCK_MAX_BYTES ? byteSafeSlice(first, EXEC_STUB_BLOCK_MAX_BYTES) + '\n…（首块超限截断）' : first)
+      : byteSafeSlice(s.body, 600)
+    return `### ${s.name}（design.md 原文摘录）\n\n${kept}\n\n完整内容回源：${designPath}#${s.name}`
+  }
+
+  // ── 专属段素材：task 卡要点（机械摘录）+ allowed_paths + 回源指引 ──
+  const fields = splitTaskCardFields(cardContent)
+  const val = k => taskCardFieldValue(fields[k])
+  const bulletList = v => (Array.isArray(v) ? v.map(i => `  - ${i}`).join('\n') : `  - ${v}`)
+  const title = val('title')
+  const goal = val('goal')
+  const impl = val('implementation')
+  const acc = val('acceptance')
+  const paths = val('allowed_paths')
+  const cardLines = [
+    title ? `- title：${title}` : '',
+    goal ? `- goal：${goal}` : '',
+    impl ? `- implementation：\n${bulletList(impl)}` : '',
+    acc ? `- acceptance：\n${bulletList(acc)}` : '',
+  ].filter(Boolean).join('\n')
+  const dedicatedFull = [
+    cardLines ? `### 任务卡要点（tasks/${taskId}.md 摘录）\n\n${cardLines}` : '',
+    Array.isArray(paths) && paths.length ? `### allowed_paths\n\n${paths.map(p => `- ${p}`).join('\n')}` : '',
+    `### 回源指引\n\n- design.md：${designPath}\n- 任务卡：${taskCardPath}`,
+  ].filter(Boolean).join('\n\n')
+
+  // ── 装配（稳定段在前、专属段在后）+ 字节预算 ──
+  const packTitle = `# execute 任务材料包：${taskId}`
+  const packNote = '> 两段式：稳定段（design 契约节原文摘录）在前、专属段（task 卡摘录）在后。\n> 只摘不译——正文均为源文件原文逐字摘录；与源文件冲突时以源文件为准，按锚点回源核对。'
+  const stableTitle = '## 稳定段（design 契约节原文摘录——跨任务稳定）'
+  const dedicatedTitle = `## 专属段（${taskId} 专属）`
+  const tailMarker = `…（专属段超限截尾——完整内容回源：${taskCardPath}）`
+  const joinParts = parts => parts.filter(Boolean).join('\n\n')
+  const assemble = (secs, dedicatedText) =>
+    joinParts([packTitle, packNote, stableTitle, ...secs, anchorsBlock, dedicatedTitle, dedicatedText])
+
+  let truncated = false
+  const sections = secBlocks.map(s => s.full)
+  let content = assemble(sections, dedicatedFull)
+
+  if (bytesOf(content) > EXEC_MATERIALS_MAX_BYTES) {
+    truncated = true
+    // ① 专属段尾部优先截：稳定段全量保留，专属段按剩余预算截尾
+    const clampDedicated = () => {
+      const head = assemble(sections, '')
+      const room = EXEC_MATERIALS_MAX_BYTES - bytesOf(head) - bytesOf('\n\n') - bytesOf(tailMarker) - 1
+      if (room < 0) return false
+      const sliced = byteSafeSlice(dedicatedFull, room)
+      content = head + '\n\n' + (sliced ? sliced + '\n' + tailMarker : tailMarker)
+      return true
+    }
+    if (!clampDedicated()) {
+      // ② 稳定段自身超限：按节优先级（接口定义 > 文件变更清单）低优先节先降为残节，逐节重试
+      for (let i = secBlocks.length - 1; i >= 0; i--) {
+        sections[i] = stubOf(secBlocks[i])
+        if (clampDedicated()) break
+      }
+    }
+    // ③ 终极兜底（双节皆残仍超限——仅病态锚点面可达）：字节安全截 + 锚点块强制保留
+    if (bytesOf(content) > EXEC_MATERIALS_MAX_BYTES && anchorsBlock) {
+      const cut = content.indexOf(anchorsBlock)
+      const before = (cut > 0 ? content.slice(0, cut) : content).replace(/\n+$/, '')
+      content = byteSafeSlice(before, EXEC_MATERIALS_MAX_BYTES - bytesOf('\n\n' + anchorsBlock)) + '\n\n' + anchorsBlock
+    } else if (bytesOf(content) > EXEC_MATERIALS_MAX_BYTES) {
+      content = byteSafeSlice(content, EXEC_MATERIALS_MAX_BYTES)
+    }
+  }
+
+  mkdirSync(materialsDir, { recursive: true })
+  const outPath = join(materialsDir, `${taskId}.md`)
+  writeFileSync(outPath, content, 'utf8')
+  return { path: outPath, bytes: bytesOf(content), truncated }
+}

package/src/run/archive-distill.js

@@ -48,8 +48,10 @@ export async function executeArchiveDistill({ cwd, specBase, changeName }) {
 
   // ── FR 索引提炼（2026-09-18-fr-index-l1 L1：稳定 id 发号+承接翻链；同 best-effort 降级语义）──
   try {
-    const { indexRequirements } = await import('../fr-index.js')
-    const fr = indexRequirements({ changeDir, knowledgeRoot, headHash })
+    const { indexRequirements, archiveDeliverableFiles } = await import('../fr-index.js')
+    // greenfield-bootstrap：供 deliverableFiles（design 表 ∪ apply-manifest）——此前缺供致域路由
+    // 退化为 design 清单单源，全泛化段时落 unmapped（R17 臂3 实证），与轻量道口径对齐。
+    const fr = indexRequirements({ changeDir, knowledgeRoot, headHash, deliverableFiles: archiveDeliverableFiles(changeDir) })
     const frWritten = Array.isArray(fr && fr.written) ? fr.written : []
     if (fr && fr.skipped) {
       console.log(`\nℹ️  FR 索引零输出：${fr.skipped}`)

package/src/run/bg-sync.js

@@ -52,6 +52,11 @@ const LOCK_STALE_MS = 15 * 60 * 1000;
 const LOG_TRUNCATE_THRESHOLD = 1_000_000;
 const LOG_TRUNCATE_KEEP = 512 * 1024;
 
+// 终态补推扫描窗口与上限（2026-09-23 quick ql-20260923-007）：候选取 last_active 倒序
+// 前 50 行（老终态缺位也收敛，但不全表扫描）；一轮最多补 3 条（防多缺位风暴挤爆预算）。
+const TERMINAL_SWEEP_CANDIDATES = 50;
+export const TERMINAL_SWEEP_MAX = 3;
+
 /** pid 活性探测（跨平台）：signal 0 探测；EPERM = 进程存在但属他户，保守按活。 */
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -178,6 +183,48 @@ export async function spawnBackgroundSync(cwd, changeName, platformOpts = {}, op
   return { status: 'spawned', logPath };
 }
 
+/**
+ * 归档终态补推扫描：DB 里 status=archived/deleted 且本地终态脏于平台镜像
+ * （last_local_modified_ts > last_synced_platform_ts，或从未同步）的变更名，last_active
+ * 倒序取前 TERMINAL_SWEEP_MAX 条。
+ *
+ * 背景（2026-09-22 session-fork-continuation 实证）：终态推送依赖归档后还有一轮
+ * triggerSync——bg 子进程 best-effort，spawn 失败/单飞锁竞态/会话在归档后戛然而止都会
+ * 吞掉最后一轮，本地已归档而平台镜像停在旧阶段（verify），此后再无命令碰该变更即永久
+ * 滞后。归档/删除收尾均 _touchLocalModified（change-registry 语义：本地状态推进），
+ * 谓词即「终态戳晚于最后一次成功推送」。补推幂等（sync() 对 archived/deleted 推终态+
+ * 墓碑，POST 幂等），任意后续命令触发的 bg 轮顺带收敛。
+ * 时钟口径：last_synced_platform_ts 是服务端时间，本地钟超前服务端时至多多补一轮幂等
+ * 推送（无副作用），且 synced 随每次成功推进，自愈。
+ * 库路径与 sync() 内 ProgressManager 同源（resolvePlatformSpecDir(cwd)：平台指针→向上
+ * 发现→cwd/.sillyspec 默认；platformOpts.specRoot 不进库路径——与 triggerSync 对齐），
+ * 保证扫的库就是主轮推的库；解析抛错（指针失效等）→ 空集跳过本轮（best-effort）。
+ */
+export async function collectTerminalSyncPending(cwd) {
+  const { resolvePlatformSpecDir, ProgressManager } = await import('../progress.js');
+  let specDir = null;
+  try { specDir = resolvePlatformSpecDir(cwd); } catch { return []; }
+  if (!specDir) return [];
+  if (!existsSync(join(specDir, '.runtime', 'sillyspec.db'))) return [];
+  const pm = new ProgressManager({ specDir });
+  const rows = pm._ensureDB(cwd).getDb().prepare(
+    `SELECT name, last_active, last_synced_platform_ts, last_local_modified_ts
+     FROM changes WHERE status IN ('archived','deleted')
+     ORDER BY last_active DESC LIMIT ${TERMINAL_SWEEP_CANDIDATES}`
+  ).all();
+  const pending = [];
+  for (const r of rows) {
+    if (!r.name) continue;
+    const synced = r.last_synced_platform_ts || '';
+    const local = r.last_local_modified_ts || '';
+    // 脏度戳必须在场（fail-closed）：D-013 之前的陈年行两戳皆空，无从判滞后——补推只会
+    // 给平台凭空造新行；synced 空而 local 在场 = 从未成功推送过但终态有据 → 补。
+    if (local && (!synced || local > synced)) pending.push(r.name);
+    if (pending.length >= TERMINAL_SWEEP_MAX) break;
+  }
+  return pending;
+}
+
 /**
  * 子侧入口（bootstrap 经 env 传参调起；env 注入默认值供测试覆盖）。
  *
@@ -224,6 +271,26 @@ export async function runBgSyncFromEnv(env = process.env) {
       break;
     }
   }
+  // 终态补推（2026-09-23 quick ql-20260923-007）：主轮收尾后扫 DB，补推「本地已达终态但
+  // 平台镜像滞后」的变更（session-fork 实证缺口）。幂等；主变更刚推过跳过；预算耗尽留下一轮。
+  try {
+    const pending = await collectTerminalSyncPending(cwd);
+    for (const name of pending) {
+      if (name === changeName) continue;
+      if (Date.now() + roundTimeoutMs > deadline) {
+        console.warn('[spec-sync-bg] 总预算用尽，终态补推剩余条目由下一轮 bg 接管');
+        break;
+      }
+      console.log(`[spec-sync-bg] 终态补推（本地终态未被平台镜像）: ${name}`);
+      try {
+        await triggerSync(cwd, name, platformOpts, { inline: true, timeoutMs: roundTimeoutMs });
+      } catch (e) {
+        console.warn(`[spec-sync-bg] 终态补推异常（best-effort，下轮重试）: ${(e && e.message) || e}`);
+      }
+    }
+  } catch (e) {
+    console.warn(`[spec-sync-bg] 终态补推扫描异常（best-effort）: ${(e && e.message) || e}`);
+  }
   console.log(`[spec-sync-bg] 后台同步完成 ${new Date().toISOString()}: ${changeName}`);
   removeBgSyncLock(runtimeRoot);
 }

package/src/run/command.js

@@ -20,14 +20,14 @@
  *     './run/stage.js' → './shared.js' 等同级
  */
 import { basename, join, resolve, dirname } from 'node:path'
-import { existsSync, readdirSync, mkdirSync, writeFileSync, readFileSync, rmSync, unlinkSync } from 'node:fs'
+import { existsSync, readdirSync, mkdirSync, writeFileSync, readFileSync, rmSync, unlinkSync, statSync } from 'node:fs'
 import { randomBytes, randomUUID } from 'node:crypto'
 import { fileURLToPath } from 'node:url'
 import { writeAtomicSync } from '../fs-atomic.js'
-import { resolveSpecDir, countAncestorSpecDirs, ancestorSpecDirs, resolveAncestorCeiling, resolveChangeDir, triggerSync, getStageSteps, formatWaitOptions, checkApproval, warnApprovalUnknown, didYouMean, assertSafeChangeName, assertDatedChangeName, detectQuickSessionDrift, detectWorktreeSpecDrift, resolveRuntimeRoot, resolveQuickSessionsDir, writePlatformPointer, checkPlatformManaged, isSelfReferentialSpecRoot, isTempResidueSpecRoot, PLATFORM_MANAGED_FILENAME, warnSelfRefPointerOnce } from './shared.js'
+import { resolveSpecDir, countAncestorSpecDirs, ancestorSpecDirs, resolveAncestorCeiling, resolveChangeDir, triggerSync, getStageSteps, formatWaitOptions, checkApproval, warnApprovalUnknown, didYouMean, assertSafeChangeName, assertDatedChangeName, detectQuickSessionDrift, detectWorktreeSpecDrift, resolveRuntimeRoot, resolveQuickSessionsDir, writePlatformPointer, checkPlatformManaged, isSelfReferentialSpecRoot, isTempResidueSpecRoot, PLATFORM_MANAGED_FILENAME, warnSelfRefPointerOnce, readStageBurst, STAGE_BURST_STAGES } from './shared.js'
 import { resolveQuickLinkedChanges } from './quick-audit.js'
 import { outputStep, collectStageWaitHistory } from './prompt.js'
-import { completeStep, skipStep, waitStep, continueStep, synthesizeStepOutput } from './complete.js'
+import { completeStep, completeStepBurst, skipStep, waitStep, continueStep, synthesizeStepOutput } from './complete.js'
 import { runStage } from './stage.js'
 import { sanitizeDesc } from '../quicklog.js'
 import { ProgressManager, resolveSessionIdentity } from '../progress.js'
@@ -52,6 +52,7 @@ const VALUE_FLAGS = new Set([
   '--base', // scan diff 基线 commit（吃值；只在 run scan --diff 转发路径消费）
   '--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 执行会话实证）
 ])
 
 /**
@@ -511,6 +512,10 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
         console.error(`❌ 检测到祖先链有 ${ancestorSpecs.length} 个 .sillyspec 实例(monorepo 多实例)，当前使用: ${specBase}`)
         console.error(`   当前 cwd 不在 git 顶层仓库根下，静默绑定到子项目实例会导致进度/QUICKLOG 分裂。`)
         console.error(`   修复：cd 回项目根目录，或用 --spec-dir <根>/.sillyspec 显式指定。`)
+        // 一键指定整行（R4-S-Q 实证：嵌套 worktree 场景下 agent 多次试错才拼对放行组合）——
+        // 意图实例即当前最近命中（specBase），直接给出可贴完整命令行。
+        console.error(`   一键指定（当前最近实例，整行照贴）：`)
+        console.error(`   sillyspec ${process.argv.slice(2).join(' ')} --spec-dir "${specBase}"`)
         process.exit(2)
       }
       // 在 git 根下但有多实例(子项目也有 .sillyspec)→ 仅警告(正确实例已命中)
@@ -716,6 +721,10 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
     '--takeover', // 所有权护栏显式强制接管（task-02 / FR-01：本层只注册透传，实际消费在 index.js apply/cleanup 子命令层——run 侧带上不报未知参数，语义出口在 worktree 命令）
     '--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 执行会话实证）
+    '--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 守护整类
     '-h',
   ])
   for (let i = 0; i < flags.length; i++) {
@@ -791,6 +800,43 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
         } catch {}
       }
       if (!quickSessionId) {
+        // 坑 quick-done-长静默与快照行尾假阳性 坑3（2026-09-21 实证）：`quick --status` 不带
+        // --change 时缺省语义是「新建」而非「查看」——查进度忘带 --change 直接误开空壳会话
+        //（需 --cancel 清理）。只读意图（--status）拦截：读 current marker 与最近 guard 目录
+        // 展示最近会话状态 + 提示带 --change，零副作用退出（绝不新建）。
+        if (isStatus) {
+          const recentRoot = resolveRuntimeRoot(platformOpts, specRoot)
+          let recent = null
+          try {
+            const idFile = join(recentRoot, 'current-quick-run-id')
+            if (existsSync(idFile)) {
+              const v = readFileSync(idFile, 'utf8').trim()
+              if (QUICK_SID_RE.test(v)) recent = v
+            }
+          } catch { /* 读失败按无 marker 处理 */ }
+          if (!recent) {
+            try {
+              const sessRoot = join(recentRoot, 'quick-sessions')
+              if (existsSync(sessRoot)) {
+                const cands = readdirSync(sessRoot, { withFileTypes: true })
+                  .filter(d => d.isDirectory() && QUICK_SID_RE.test(d.name))
+                  .map(d => ({ name: d.name, m: statSync(join(sessRoot, d.name, 'guard.json')).mtimeMs }))
+                  .filter(x => x.m > 0)
+                  .sort((a, b) => b.m - a.m)
+                if (cands.length > 0) recent = cands[0].name
+              }
+            } catch { /* 枚举失败按无近期会话处理 */ }
+          }
+          console.log('ℹ️ `run quick --status` 不带 --change 查的是最近会话，不会新建（查进度请带 --change <sessionId>）')
+          if (recent) {
+            console.log(`   最近会话: ${recent}（本命令将展示其状态）`)
+            quickSessionId = recent
+            quickFallbackUsed = true
+          } else {
+            console.log('   本仓无近期 quick 会话记录（current marker 与 quick-sessions 均空）——新工作请走轻量变更：sillyspec flow start --change <名> --input "<动机与背景；随后独立一行『成功标准：』；再每行一条『- <可验证标准>』>"')
+            process.exit(0)
+          }
+        } else {
         // 坑 quick-no-input-placeholder-title（2026-08-24 二期①；2026-09-19 上移）：全新 quick 会话
         // （即将生成新 sessionId）缺 --input 且无可取标题的 --linked-changes → 拒绝启动（exit 2，
         // 零沉没成本）。原位置在 flag 校验之后，但 sessionId 生成/「已建立」公告与 agent-log 平台
@@ -824,6 +870,7 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
         // 若把命令拖过 exec 超时，调用方仍能从输出头部拿到 sessionId 续用（--status / guard.json
         // 核对），不会误开空壳新会话。
         console.log(`📌 quick 会话已建立: ${quickSessionId}（后续若超时/中断，用 --change ${quickSessionId} 续用）`)
+        }
       }
       changeName = quickSessionId
     } else {
@@ -1301,6 +1348,45 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
   // 注册变更到全局活跃列表（如果尚未注册）
   if (effectiveChange) {
     pm.registerChange(cwd, effectiveChange)
+    // ── watcher 拉起（R7 切片一 / D-001：观测与协议解耦）──
+    // effectiveChange 解析后无条件 spawn（不做「检测新建」——registerChange 是 INSERT OR
+    // IGNORE 不返回新建信号），活锁在跑由单飞锁合并 coalesced。best-effort：失败只 warn
+    // 绝不阻断主流程；未连接平台也 spawn（本地 jsonl 是事件唯一真相源）；
+    // SILLYSPEC_WATCHER=0 逃生阀。default 容器行不监听（非真实变更）。
+    if (effectiveChange !== 'default') {
+      // ── 混跑回退写侧（R7 切片二 / FR-06 / D-002：thin change 上跑 run <stage> = 该 change
+      // 回 legacy 记账——flow done 读侧拒裁并指路厚档；两套记账不叠加。一次性置位留痕。）──
+      // 升厚同意门（2026-09-25-thin-upgrade-consent，R16 实测驱动）：轻量→完整是成本数倍的资源
+      // 决策，归属用户——agent 不得凭 CLI 的 advisory 自行转道。混跑回退须显式 --upgrade-thick
+      // （=「用户已同意」的落痕 flag，同 --force 留痕先例）；无 flag 拒跑指路。
+      try {
+        const flowStatePath = join(specRoot, 'changes', effectiveChange, 'flow-state.yaml')
+        if (existsSync(flowStatePath)) {
+          const { readFlowState, writeFlowState } = await import('../flow.js')
+          const changeDir = join(specRoot, 'changes', effectiveChange)
+          const st = readFlowState(changeDir)
+          if (st && !st.legacy_fallback) {
+            if (!flags.includes('--upgrade-thick')) {
+              console.error(`⛔ 本变更在轻量跑道上（flow-state 在场）——升厚走完整流程需用户同意，agent 不得自行转道：`)
+              console.error(`   · 征得用户同意后带 --upgrade-thick 重跑本命令（落痕留档，首次转厚即转）`)
+              console.error(`   · 用户未确认或选择轻量跑 → 继续轻量变更：直接干活，收口 sillyspec flow done --change ${effectiveChange}`)
+              process.exit(2)
+            }
+            writeFlowState(changeDir, { legacy_fallback: true, upgraded_by_consent: new Date().toISOString() })
+            console.warn(`⚠️ [flow] thin change「${effectiveChange}」经用户同意（--upgrade-thick 落痕）升厚——已混跑回退 legacy（flow done 将按厚档拒裁并指路；两套记账不叠加）`)
+          }
+        }
+      } catch { /* 探测失败不阻断既有 run 流程（process.exit 直出不经 catch） */ }
+      try {
+        const { spawnWatcher } = await import('../watcher.js')
+        const r = await spawnWatcher(cwd, effectiveChange, { ...platformOpts, specBase })
+        if (r.status === 'spawned') {
+          console.log(`🔄 [watcher] 观测旁路已拉起（产物签名轮询，事件恒带 provisional:true）: ${effectiveChange}`)
+        }
+      } catch (e) {
+        console.warn(`⚠️ [watcher] 拉起失败（观测旁路 best-effort，不影响主流程）: ${(e && e.message) || e}`)
+      }
+    }
     // ── 所有权首建 claim（2026-09-14-change-ownership-guards task-02 / FR-01 / D-001@v1）──
     // run <stage> 启动即认领 owner（claimChangeOwner 守卫语义：已有值不覆盖——他人持有不抢
     // 也不拒；拒绝语义只锁接管类操作，见 index.js apply/cleanup/assess 接线）。会话标识三级：
@@ -1652,11 +1738,16 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
     const doneAnswer = getFlagValue('--answer')
     // isSkipApply/sessionFlag（task-03）：--skip-apply 归档收口跳过 + --session 所有权会话标识，
     // 随 completeStep options 透传（isNoDocs 同款链路）——消费点 archive/quick 收尾 handler。
+    // burst 分发门（2026-09-22-stage-burst-fold D-003@v2/FR-06）：白名单主阶段 + readStageBurst
+    // 开启 → completeStepBurst 循环收口（completeStep 本体零改动，守卫逐轮生效）；options 原样透传。
+    if (STAGE_BURST_STAGES.includes(stageName) && await readStageBurst(cwd)) {
+      return await completeStepBurst(pm, progress, stageName, cwd, outputText, inputText, { confirm: isConfirm, changeName: effectiveChange, nonInteractive: isNonInteractive && !isInteractive, platformOpts, doneAnswer, isForceBaseline, isAllowNew, isAllowDelete, isNoDocs, isSkipApply, sessionFlag: getFlagValue('--session'), quickFiles, stepAssert: stepAssertValue })
+    }
     return await completeStep(pm, progress, stageName, cwd, outputText, inputText, { confirm: isConfirm, changeName: effectiveChange, nonInteractive: isNonInteractive && !isInteractive, platformOpts, doneAnswer, isForceBaseline, isAllowNew, isAllowDelete, isNoDocs, isSkipApply, sessionFlag: getFlagValue('--session'), quickFiles, stepAssert: stepAssertValue })
   }
 
   // 默认：输出当前步骤
-  return await runStage(pm, progress, stageName, cwd, effectiveChange, isSkipApproval, platformOpts, { quickFiles, isAllowNew, isAllowDelete, isForceBaseline, isForceRescan, linkedChanges, linkedChangesAuto: linkedAuto, taskDescription: inputText, adoptBranch: stageName === 'execute' && flags.includes('--adopt-branch') })
+  return await runStage(pm, progress, stageName, cwd, effectiveChange, isSkipApproval, platformOpts, { quickFiles, isAllowNew, isAllowDelete, isForceBaseline, isForceRescan, linkedChanges, linkedChangesAuto: linkedAuto, taskDescription: inputText, adoptBranch: stageName === 'execute' && flags.includes('--adopt-branch'), sameSession: flags.includes('--same-session') })
 }
 
 /**
@@ -1844,6 +1935,23 @@ async function runAutoMode(pm, progress, cwd, flags, changeName, platformOpts =
   // 零活跃建变更已上移入口守卫层，多活跃 exit 2 由入口守卫处理）。
   if (changeName) console.log(`🎯 auto 目标变更（单活跃自动选中或显式指定）：${changeName}`)
 
+  // ── watcher 拉起（2026-09-23-sentinel-rules task-05 / FR-09）──
+  // run auto 在 runCommand 主干的 spawnWatcher 挂点（effectiveChange 解析后那处）之前
+  // 早退进本函数——auto 路径是 run 族唯一观测缺口。语义同 flow start 接线：best-effort
+  // 失败只 warn 不阻断，SILLYSPEC_WATCHER=0 逃生阀在 spawnWatcher 内短路，活锁合并
+  // coalesced，未连接平台也 spawn（本地 jsonl 是事件唯一真相源）。
+  if (changeName && changeName !== 'default') {
+    try {
+      const { spawnWatcher } = await import('../watcher.js')
+      const r = await spawnWatcher(cwd, changeName, { ...platformOpts, specBase })
+      if (r.status === 'spawned') {
+        console.log(`🔄 [watcher] 观测旁路已拉起（auto 路径补挂，事件恒带 provisional:true）: ${changeName}`)
+      }
+    } catch (e) {
+      console.warn(`⚠️ [watcher] 拉起失败（观测旁路 best-effort，不影响主流程）: ${(e && e.message) || e}`)
+    }
+  }
+
   // Helper: 在 auto 模式下获取步骤定义
   const getAutoSteps = async (stage) => {
     if (stage === 'brainstorm') {
@@ -1901,8 +2009,9 @@ async function runAutoMode(pm, progress, cwd, flags, changeName, platformOpts =
     const localConfig = readAutoModeFromLocalYaml(cwd)
     const classification = classifyChange({ description: inputText || '', explicitMode, localConfig })
     if (classification.mode === 'quick') {
-      console.log(`📊 auto 模式分类：${classification.mode}（${classification.reason}）`)
-      console.log(`   此变更建议使用 quick 模式，运行：sillyspec run quick "${inputText || '需求'}"`)
+      console.log(`📊 auto 模式分类：${classification.reason} 判为小变更`)
+      console.log(`   小变更请走轻量变更（quick 通道已退役，v3.30.0 起拒绝新会话）：`)
+      console.log(`   sillyspec flow start --change <名> --input "<动机与背景；随后独立一行『成功标准：』；再每行一条『- <可验证标准>』>"`)
       return
     }
     console.log(`📊 auto 模式分类：${classification.mode}（${classification.reason}）`)
@@ -1989,16 +2098,24 @@ async function runAutoMode(pm, progress, cwd, flags, changeName, platformOpts =
     return
   }
 
-  if (!outputText) {
+  // burst 分发门（2026-09-22-stage-burst-fold D-003@v2/X-4，FR-06）：auto 路径 burst 分支跳过
+  // --output 预合成（预合成文本在 burst 下沦为横幅重复打印——burst 直接透传原始 outputText，
+  // 横幅去重归 completeStepBurst 单点），循环收口后本路径既有推进逻辑（nextPendingIdx 渲染 /
+  // nextInFlow 阶段推进）基于重读 progress 自然衔接。
+  const _autoBurstOn = STAGE_BURST_STAGES.includes(currentStage) && await readStageBurst(cwd)
+
+  if (!outputText && !_autoBurstOn) {
     // P0-2（noai-ir-roadmap §3）：auto --done 的 --output 同样可省略——与 completeStep 同源
     // 的事实性摘要合成（此前硬拒 exit 2 是用法守卫；SS-META 的 doneCommand 仍带 --output，
     // 照抄路径零变化，省略路径不再罚一轮）。
     const _autoStep = progress?.stages?.[currentStage]?.steps?.find((s) => s && ['pending', 'in-progress', 'blocked'].includes(s.status))
-    outputText = synthesizeStepOutput({ stageName: currentStage, stepName: _autoStep?.name || currentStage, cwd })
+    outputText = synthesizeStepOutput({ stageName: currentStage, stepName: _autoStep?.name || currentStage, cwd, platformOpts })
     console.log(`🤖 auto --done 未带 --output——CLI 已按事实合成步骤摘要（语义说明下次带 --output 手写）。`)
   }
 
-  const result = await completeStep(pm, progress, currentStage, cwd, outputText, inputText, { printNext: false, changeName, platformOpts })
+  const result = _autoBurstOn
+    ? await completeStepBurst(pm, progress, currentStage, cwd, outputText, inputText, { printNext: false, changeName, platformOpts })
+    : await completeStep(pm, progress, currentStage, cwd, outputText, inputText, { printNext: false, changeName, platformOpts })
   if (!result) return
   progress = pm.read(cwd, changeName)
   // change 行被并发归档/删除时 read 返回 null（体检 BUG-05）：引导排查而非 TypeError 崩溃
@@ -2157,7 +2274,7 @@ export async function maybeWaitInteractive(stepDef, changeName, stageName, { rlF
       const { execFileSync } = await import('node:child_process')
       const binSelf = resolveBinSelfPath()
       try {
-        execFileSync(process.execPath, [binSelf, 'run', 'auto', '--continue', '--answer', answer.trim(), '--change', changeName], { stdio: 'inherit', cwd: process.cwd() })
+        execFileSync(process.execPath, [binSelf, 'run', 'auto', '--continue', '--answer', answer.trim(), '--change', changeName], { stdio: 'inherit', cwd: process.cwd(), windowsHide: true })
       } catch { /* continue 失败（非 waiting 态等）静默——回三段式由 agent 走 */ }
     }
   } catch (e) {