sillyspec 3.32.8 → 3.32.10

package/src/flow.js

@@ -27,6 +27,7 @@
  */
 import { existsSync, readFileSync, writeFileSync, readdirSync, appendFileSync, renameSync, statSync } from 'node:fs'
 import { join, relative, dirname } from 'node:path'
+import { DatabaseSync } from 'node:sqlite'
 import yaml from 'js-yaml'
 import { git, gitQuiet } from './git-helper.js'
 import { writeAtomicSync } from './fs-atomic.js'
@@ -223,6 +224,23 @@ export async function extractRoutingInputPaths(cwd, specBase, input) {
   })
 }
 
+/**
+ * 轻量道知识注入查询串瘦身（2026-10-15-thin-query-slim）：--input 的「成功标准：」段是验收
+ * 判据语料（文件路径/测试名/断言词——对知识匹配是纯噪音，且路径词会过触路由关键词把命中面
+ * 撑爆：本仓实证整段 input 匹配出 76 条目、58 个 fr 域文件全命中）。查询只取动机段——
+ * 「成功标准：」标记前正文；标记缺席=无标准段，全文照旧（兼容旧形态）；标记前为空白则退全 input。
+ * @param {string} change 变更名（查询首行，既有口径）
+ * @param {string} input --input 全文
+ * @returns {string} 瘦身后的查询串
+ */
+export function thinKnowledgeQuery(change, input) {
+  const raw = String(input || '')
+  const markerIdx = raw.search(/成功标准[:：]/)
+  const motivation = markerIdx >= 0 ? raw.slice(0, markerIdx) : raw
+  const body = motivation.trim() || raw.trim()
+  return `${change || ''}\n${body}`
+}
+
 /**
  * 轻量道知识注入段（2026-09-25-thin-fr-inject-parity）：默认快道读取面对齐——
  * {FR_INDEX_DIGEST}/{DECISION_HITS}/execute 知识命中报告此前只在 run 族装配，轻量道 fresh
@@ -294,10 +312,11 @@ export async function flowKnowledgeDigest({ specBase, change, changeDir, input,
       }
     }
     const { matchKnowledgeHybrid } = await import('./knowledge-vector.js')
-    const { deathPathNote } = await import('./knowledge-match.js')
+    const { deathPathNote, decisionChangeQualifier } = await import('./knowledge-match.js')
     // scope 遍历召回（2026-10-08-knowledge-graph，FR-04）：touched=机器算的图查询键
     // （filesOverride ∪ design 交付表——上方既有变量），词面三层零命中时沿强边保底防复潮
-    const km = await matchKnowledgeHybrid(knowledgeRoot, `${change}\n${input || ''}`, { cwd: dirname(specBase), scopeFiles: touched })
+    const kmQuery = thinKnowledgeQuery(change, input)
+    const km = await matchKnowledgeHybrid(knowledgeRoot, kmQuery, { cwd: dirname(specBase), scopeFiles: touched })
     // 防复潮面 = 死路注记 ∪ 有主题重叠的 rejected（2026-09-28-knowledge-inject-ranking 起 rejected∪死路；
     // 2026-09-28-knowledge-gate-denoise 收紧：score 零的 rejected 与查询零主题重叠——空标题条目靠状态
     // 蹭进回显是行为实测三例的噪音源，不再注入）
@@ -305,20 +324,51 @@ export async function flowKnowledgeDigest({ specBase, change, changeDir, input,
     summary.rejectedDecisions = rejected.length
     summary.knowledgeEntries = km.matched ? (km.entries || []).length : 0
     if (rejected.length > 0) {
-      lines.push(`   ⚠️ 否决决策/死路注记（历史已否决或已记死路，防复潮——除非复潮条件满足勿重提，复潮须在本变更 decisions.md 记新版本）：`)
+      lines.push(`   ⚠️ 否决决策/死路注记（历史已否决或已记死路，防复潮——除非复潮条件满足勿重提，复潮须在本变更 decisions.md 记新版本；跨变更引用带变更名 变更名#D-xxx@vN）：`)
       for (const h of rejected.slice(0, 5)) {
         const note = h.status === 'rejected' ? (h.reason || '（未记录）') : `死路——${deathPathNote(h.reason)}`
-        lines.push(`   - ${h.id} ${h.title}（${h.file}）${h.status === 'rejected' ? '否决理由' : '⚰️'}：${note}`)
+        lines.push(`   - ${h.id} ${h.title}（${h.file}｜${decisionChangeQualifier(h.change)}）${h.status === 'rejected' ? '否决理由' : '⚰️'}：${note}`)
       }
     }
     if (km.matched && (km.entries || []).length > 0) {
       const src = km.entries.slice(0, 3).map((e) => (e.anchor ? `${e.file}#${e.anchor}` : e.file)).join('；')
       lines.push(`   📚 知识命中（INDEX 关键词，按需 Read）：${src}`)
     }
+    // 遥测导线（2026-10-15-thin-inject-telemetry）：轻量道注入此前不落 hits.jsonl——thin 常态化后
+    // inject 事件流断流（本仓 10-09 后归零实证），knowledge stats 从未命中判定被盲区污染。
+    // 分级字段（A2-lite）：injectedFiles=正文实际注入（thin 面恒空——只出按需 Read 行）、
+    // mentionedFiles=显式展示给 agent 的锚点（📚 行 top-3）。既有 matchedFiles 口径不变
+    // （knowledge-stats 消费面零回归）。仅命中面非空才落盘；fail-soft（R-04）不阻断注入。
+    const thinMatchedFiles = km.matched ? (km.entries || []).map((e) => (e.anchor ? `${e.file}#${e.anchor}` : e.file)) : []
+    if (thinMatchedFiles.length > 0 || rejected.length > 0) {
+      try {
+        const { appendKnowledgeHit } = await import('./knowledge-hits.js')
+        appendKnowledgeHit(join(specBase, '.runtime'), {
+          type: 'inject',
+          change,
+          query: kmQuery,
+          matchedFiles: thinMatchedFiles,
+          injectedFiles: [],
+          mentionedFiles: thinMatchedFiles.slice(0, 3),
+          rejectedCount: rejected.length,
+          source: 'thin-start',
+        })
+      } catch { /* 遥测 fail-soft（R-04）：hits 落盘失败不影响注入本体 */ }
+    }
     if (domains.length === 0 && rejected.length === 0 && !km.matched) {
       lines.length = 0
       lines.push(`🧠 知识注入（轻量道读取面）：语料未命中知识库（无触达域依据、无否决命中、INDEX 无对齐条目）——可自行查 knowledge/INDEX.md。`)
     }
+    // 向量开关发现性提示（2026-10-15-vector-switch-discoverability）：零命中=正需要语义召回
+    // 而未获得的时刻——平台已连接但开关未开（缺省关）时给一行可执行提示；有命中/未连接/
+    // 已开启零新增（vectorSwitchHint 单源，同款提示也挂 knowledge search hint 键）。
+    if (!km.matched && rejected.length === 0) {
+      try {
+        const { vectorSwitchHint } = await import('./knowledge-vector.js')
+        const hint = vectorSwitchHint(dirname(specBase))
+        if (hint) lines.push(`   ${hint}`)
+      } catch { /* 提示 fail-open */ }
+    }
     // 模块卡欠账提示前移（2026-10-12-thin-module-gate-and-feed 三档）：触碰命中模块 behind>0
     // 才出事实行——动手前看到「你要动的卡已落后」比收口时警告有效；computeDocsDebt（厚道
     // execute {DOCS_DEBT}）同源，空债/无图零输出，异常走外层 catch fail-open 不阻断 start。
@@ -442,7 +492,136 @@ function changeArtifactPaths(changeDir) {
  * flow start —— 第 1 次协议调用（建卡+下发）。已存在 change → 恢复简报（不新建不重置）。
  * @param {{change:string, input?:string, thick?:boolean, withTasks?:boolean, cwd:string, specBase:string, json?:boolean}} p
  */
-export async function cmdFlowStart({ change, input, title: titleFlag = null, thick = false, withTasks = false, reviewForce = null, autopilot = false, cwd, specBase, runtimeRootOpt = null, json = false }) {
+/**
+ * flow diff —— change 粒度文件统计只读查询（2026-10-13-flow-diff-cmd）。
+ * 双态同构：归档态读 change-patch.json scopeAudit（冻结时点真相，含 verdict）；活跃态实时算
+ * baseline→工作树 累计口径（与 patch 子步冻结面同规则：filterCommittedFace 剔 ownPrefix 治理件
+ * 保 .sillyspec/docs/；行数 git numstat，untracked 按文件行数、二进制 ∅）。只读零副作用：
+ * 不 pull（无 triggerPullActiveChange）、不写盘、不动状态机——scan diff 同纪律。
+ * rows[].state：committed（工作树==HEAD）/ dirty（有未提交改动）/ untracked / archived。
+ */
+async function cmdFlowDiff({ change, cwd, specBase, json = false }) {
+  const toPosix = (p) => String(p).replace(/\\/g, '/')
+  const activeDir = join(specBase, 'changes', change)
+  const archiveJson = join(specBase, 'changes', 'archive', change, 'change-patch.json')
+  const rows = []
+  let mode = null
+  let baseline = null
+  if (existsSync(archiveJson)) {
+    mode = 'archived'
+    try {
+      const meta = JSON.parse(readFileSync(archiveJson, 'utf8'))
+      const sa = meta.scopeAudit || {}
+      for (const r of (sa.rows || [])) {
+        if (!r || !r.path) continue
+        rows.push({ path: toPosix(r.path), additions: Number.isFinite(r.additions) ? r.additions : null, deletions: Number.isFinite(r.deletions) ? r.deletions : null, state: 'archived', verdict: r.verdict || null })
+      }
+      const t = (sa.totals && sa.totals.files != null) ? sa.totals : meta.totals
+      var archivedTotals = (t && typeof t === 'object') ? { files: t.files ?? rows.length, additions: t.additions ?? null, deletions: t.deletions ?? null } : null
+    } catch { /* 损坏件 → 按活跃态兜底（下方 activeDir 分支不命中则报不存在） */
+      mode = null
+    }
+  }
+  if (mode === null && existsSync(join(activeDir, 'flow-state.yaml'))) {
+    mode = 'active'
+    const st = readFlowState(activeDir)
+    baseline = st?.baseline_commit || null
+    if (baseline) {
+      const ownPrefix = `.sillyspec/changes/${change}/`
+      const committedRaw = String(gitQuiet(cwd, ['diff', '--name-only', `${baseline}..HEAD`]) || '').split('\n').map((s) => s.trim().replace(/\\/g, '/')).filter(Boolean)
+      const { filterCommittedFace } = await import('./flow-parity.js')
+      const committed = filterCommittedFace(committedRaw, ownPrefix)
+      // dirty 面（含 untracked）：porcelain 全列，交付规则同冻结面（.sillyspec/ 剔、.sillyspec/docs/ 保、ownPrefix 剔）
+      // ⚠ 行不可 trim——porcelain 前导状态码含空格（' M x'）；git() 默认整段 trim 会吃掉首行
+      // 前导空格（实测 ' M work.txt' → 'M work.txt' → slice(3) 错位吃路径首字符），须 trim:false
+      const por = String(gitQuiet(cwd, ['status', '--porcelain', '-uall'], { trim: false }) || '').split('\n').filter((s) => s.length >= 4)
+      const dirtyState = new Map() // path -> 'dirty' | 'untracked'
+      for (const line of por) {
+        const xy = line.slice(0, 2)
+        const raw = line.slice(3).trim()
+        const path = toPosix(raw.includes(' -> ') ? raw.split(' -> ').pop() : raw)
+        if (!path || path.startsWith(ownPrefix)) continue
+        if (path.startsWith('.sillyspec/') && !path.startsWith('.sillyspec/docs/')) continue
+        dirtyState.set(path, xy === '??' ? 'untracked' : 'dirty')
+      }
+      const face = [...new Set([...committed, ...dirtyState.keys()])]
+      // 累计口径 numstat：baseline → 工作树（无 HEAD 上限，含未提交；untracked 不入 git diff 单独算）
+      const tracked = face.filter((f) => dirtyState.get(f) !== 'untracked')
+      const nsOut = String(gitQuiet(cwd, ['diff', '--numstat', baseline, '--', ...tracked]) || '')
+      const ns = new Map()
+      for (const l of nsOut.split('\n').filter(Boolean)) {
+        const [a, d, ...rest] = l.split('\t')
+        if (rest.length === 0) continue
+        ns.set(toPosix(rest.join('\t')), { additions: /^\d+$/.test(a) ? Number(a) : null, deletions: /^\d+$/.test(d) ? Number(d) : null })
+      }
+      for (const f of face) {
+        const st3 = dirtyState.get(f)
+        if (st3 === 'untracked') {
+          try {
+            const buf = readFileSync(join(cwd, f))
+            const text = buf.toString('utf8')
+            const lines = text.split('\n')
+            if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop()
+            rows.push({ path: f, additions: buf.includes(0) ? null : lines.length, deletions: null, state: 'untracked' })
+          } catch { rows.push({ path: f, additions: null, deletions: null, state: 'untracked' }) }
+        } else {
+          const s = ns.get(f)
+          rows.push({ path: f, additions: s ? s.additions : null, deletions: s ? s.deletions : null, state: st3 === 'dirty' ? 'dirty' : 'committed' })
+        }
+      }
+    }
+  }
+  if (mode === null) {
+    console.error(`❌ 变更「${change}」不存在（活跃 flow-state 与归档 change-patch.json 均未找到）`)
+    console.error('   修复：sillyspec status 查变更列表核对拼写/日期前缀；归档变更名与归档目录名逐字一致')
+    process.exit(1)
+  }
+  const totals = mode === 'archived' && archivedTotals
+    ? archivedTotals
+    : { files: rows.length, additions: rows.reduce((s, r) => s + (r.additions || 0), 0), deletions: rows.reduce((s, r) => s + (r.deletions || 0), 0) }
+  if (json) {
+    console.log(JSON.stringify({ change, mode, baseline, rows, totals }))
+    return
+  }
+  if (mode === 'active' && !baseline) {
+    console.log(`📦 flow diff — ${change}（active）：无 git 基线（无历史仓）——无可对账面`)
+    return
+  }
+  console.log(`📐 flow diff — ${change}（${mode}${mode === 'active' ? `｜baseline ${String(baseline).slice(0, 8)}→工作树` : '｜flow done 冻结件'}）`)
+  for (const r of rows) {
+    const a = r.additions == null ? '   ∅' : `+${String(r.additions).padStart(4)}`
+    const d = r.deletions == null ? '   ∅' : `-${String(r.deletions).padStart(4)}`
+    const tag = r.state === 'dirty' ? '（未提交）' : r.state === 'untracked' ? '（未跟踪·新文件）' : r.state === 'archived' && r.verdict ? `｜${r.verdict}` : ''
+    console.log(`  ${a} ${d}  ${r.path}${tag}`)
+  }
+  console.log(`合计：${totals.files} 文件 +${totals.additions ?? '?'} -${totals.deletions ?? '?'}${mode === 'active' ? '（baseline→工作树累计口径，含未提交）' : ''}`)
+}
+
+/**
+ * 升厚行值重置（坑 thin-upgrade-stale-stage-window，2026-10-13）：升厚只写 flow-state
+ * 不碰 DB 行——行值残留 'thin'（平台 pull 往返透传形态）时，serializeForSync 的 thin 投影
+ * 在首次 run <stage> 前持续误标平台「轻量」出身（短窗展示面失真）。升厚三写点统一调本
+ * helper：行 current_stage 'thin' → 'brainstorm'（厚档起点，与 run 阶段机首写同值），
+ * 仅 thin 值才动（其余行值不越权重置）。best-effort 不阻断升厚链。
+ */
+function resetThinStageRowOnUpgrade(cwd, change, specBase = null) {
+  try {
+    // cmdFlowDone 作用域无共享 ProgressManager——helper 直走底层数据库文件（node:sqlite）
+    // 零依赖；specBase 优先（与 flow 侧锚定同口径，平台模式 specRoot 异位不迷路）
+    const db = new DatabaseSync(join(specBase || join(cwd, '.sillyspec'), '.runtime', 'sillyspec.db'))
+    try {
+      const row = db.prepare('SELECT current_stage FROM changes WHERE name = ?').get(change)
+      if (row && row.current_stage === 'thin') {
+        db.prepare('UPDATE changes SET current_stage = ? WHERE name = ?').run('brainstorm', change)
+        console.log('   ↺ 升厚重置 DB 行 current_stage: thin → brainstorm（防平台短窗误标轻量出身）')
+      }
+    } finally {
+      try { db.close() } catch { /* 关闭失败不放大 */ }
+    }
+  } catch { /* 行值重置 best-effort，不阻断升厚 */ }
+}
+
+export async function cmdFlowStart({ change, input, title: titleFlag = null, thick = false, withTasks = false, reviewForce = null, autopilot = false, prestageAck = false, turbo = false, cwd, specBase, runtimeRootOpt = null, json = false }) {
   // local.yaml 缺席 fail-fast（R22 实证：缺 local.yaml 时 flow done 测试门静默兜底裸
   // python -m pytest → aiobotocore 假红/全量 860s 撞 600s 帽 → 11 轮重试 135min）。
   // local.yaml 是 init 的职责面——flow start 在此拒绝，不让 agent 在错误的测试配置上走完全程
@@ -477,9 +656,18 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
       // 保留，机器只补缺件与绑定面。无产物 = 真 legacy 既有变更，维持原拒收。
       const hasBsArtifacts = existsSync(join(changeDir, 'proposal.md')) || existsSync(join(changeDir, 'design.md'))
       if (hasBsArtifacts) {
+        // 预段反馈闭环（2026-10-14-prestage-consent-gate）：走了头脑风暴预段=选道正确，
+        // 消费 route-hindsight 标记（同意门的一次性豁免在这里用掉，无声明 flag 也放行）
+        try {
+          const { clearHindsightMark } = await import('./route-hindsight.js')
+          if (clearHindsightMark({ specBase })) console.log('🕰️ 预段同意门：头脑风暴收编即选道正确，route-hindsight 标记已消费')
+        } catch { /* 消费 best-effort */ }
         const head = gitQuiet(cwd, ['rev-parse', 'HEAD'])
         const baseline = typeof head === 'string' && head.trim() ? head.trim() : null
-        writeFlowState(changeDir, { tier: 'thin', born_face: 'thin', adopted_from: 'brainstorm', review_force: reviewForce, baseline_commit: baseline, substeps: {} })
+        writeFlowState(changeDir, { tier: 'thin', born_face: 'thin', adopted_from: 'brainstorm', review_force: reviewForce, baseline_commit: baseline, substeps: {},
+          // 极速模式留痕（2026-10-14-thin-turbo-mode D-005）：--turbo 用户显式触发声明性落盘；
+          // flow done 读态以 turbo && tier!=='thick' 判定（D-007 升厚即失效）
+          ...(turbo ? { turbo: true, turbo_since: new Date().toISOString() } : {}) })
         try {
           const { redraftMissingArtifacts, ensureBindingSlots } = await import('./flow-draft.js')
           const r = redraftMissingArtifacts({ changeDir, change, input: null, runtimeRoot })
@@ -519,6 +707,8 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
         try { digestLines = (await flowKnowledgeDigest({ specBase, change, changeDir, input: null })).lines } catch { /* 注入 best-effort */ }
         console.log([
           `🧲 头脑风暴产物已收编进轻量跑道: ${change}（adopted_from=brainstorm，baseline=${baseline ? baseline.slice(0, 10) : '（无 git 历史）'}）`,
+          // 极速指引行（2026-10-14-thin-turbo-mode FR-01）：--turbo 在场才输出，缺省路径逐字不变
+          ...(turbo ? [`⚡ 极速模式（用户显式触发）：只产 spec+代码，收口自动跳过实测与重仪式门（必留面照常）；本次收口不含测试客观核验`] : []),
           `══════════════════════════════════════`,
           `📖 必读（头脑风暴产出——方案的承诺锚，先读完再动手）：`,
           ...artifacts.map((p) => `   - ${p}`),
@@ -540,6 +730,10 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
           ...materials.map((p) => `  - ${p}`),
           ``,
           ...digestLines,
+          ...(prototypePaths.length > 0 ? [
+            `变更原型（头脑风暴产出，UI 实现前必看——中部 🖼️ 行的绝对尾部重列，防长输出截断丢指针）：`,
+            ...prototypePaths.map((p) => `  - ${p}`),
+          ] : []),
         ].filter(Boolean).join('\n'))
         try { await triggerSync(cwd, change) } catch { /* 同步绝不阻断协议面 */ }
         return { adopted: true, change, baseline }
@@ -663,6 +857,37 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
     }
   }
 
+  // 预段选道同意门（2026-10-14-prestage-consent-gate）：route-hindsight 标记从「下次 start 点名
+  // 提示」升级为声明即过的同意门——上个轻量变更被标「疑似该走预段未走」时，本次全新 start 须
+  // 显式选道一次（--no-prestage 声明留痕 / 先走 brainstorm 预段）。边界：门不判本次需求清不清晰
+  // （判定归 agent/用户，D-005 弱信号），只把上次的过程形态信号摆上台面要求一次显式消费——同
+  // --autopilot/--upgrade-thick 的同意门模式（「可无视」升级为「可无视但需留痕声明」）。
+  // 豁免面：resume（上方分支早退）天然不受影响；平台 writer 预建空目录（proceedFreshEmptyDir）
+  // 豁免——平台自动派发无选道对话面，标记留给人工会话消化；adopt（头脑风暴收编）= 选道正确，
+  // 在 adopt 分支消费标记。读取 fail-open（读不到=无门），消费失败不阻断（下次再声明一次）。
+  if (!proceedFreshEmptyDir) {
+    let prestageMark = null
+    try {
+      const { readHindsightMark } = await import('./route-hindsight.js')
+      prestageMark = readHindsightMark({ specBase })
+    } catch { /* 标记读取 fail-open */ }
+    if (prestageMark) {
+      if (!prestageAck) {
+        const _why = Array.isArray(prestageMark.reasons) && prestageMark.reasons.length > 0
+          ? prestageMark.reasons.join('；') : '过程形态超阈'
+        console.error(`❓ 预段选道同意门：上个轻量变更「${prestageMark.change}」被 route-hindsight 标记「疑似该走头脑风暴预段未走」（${_why}）。本次全新 start 须显式选道（声明即过——标记是过程形态信号非定罪）：`)
+        console.error(`   ① 确认需求已含决策（成功标准来自用户原话或既有文档转写，而非你的推断）：sillyspec flow start --change ${change} --input "<原输入>" --no-prestage（声明留痕 flow-state.prestage_ack，标记消费）`)
+        console.error(`   ② 需求不清晰或需方案探索：sillyspec run brainstorm --change ${change}（完成后回来 flow start 收编，标记自动消费）`)
+        process.exit(2)
+      }
+      try {
+        const { clearHindsightMark } = await import('./route-hindsight.js')
+        clearHindsightMark({ specBase })
+        console.log(`🕰️ 预段同意门：已按 --no-prestage 声明放行（本次需求已含决策，留痕 flow-state.prestage_ack；上个标记「${prestageMark.change}」已消费）`)
+      } catch { /* 标记消费 best-effort：失败不阻断（下次 start 再声明一次） */ }
+    }
+  }
+
   // 升厚预判已删除（2026-09-25-thin-precheck-removal）：技术面关键词（数据库/迁移等）测错轴——
   // R16 实证碰迁移的变更轻量变更带评审最优收口，预判反诱发误升厚（臂 A 129M）与误报打断。选道只留
   // 形态信号：清晰度门管「需求说不清楚」（预段收编），升厚只留用户决策（--upgrade-thick 同意门）
@@ -708,10 +933,44 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
     // autopilot（2026-10-04-thin-docs-v2 FR-06）：用户显式声明跳过 spec 断点人审（--autopilot）；
     // 缺省 false——flow done 要求 flow approve 批准证据（spec 断点机器化，护栏#2：零 prompt 劝说）
     autopilot: Boolean(autopilot),
+    // 预段同意门声明留痕（2026-10-14-prestage-consent-gate）：hindsight 标记在场时全新 start
+    // 以 --no-prestage 显式声明「本次需求已含决策」放行——审计面可区分「确认过」与「没被问过」
+    prestage_ack: Boolean(prestageAck),
+    // 极速模式留痕（2026-10-14-thin-turbo-mode D-005）：--turbo 用户显式触发声明性落盘；
+    // flow done 读态以 turbo && tier!=='thick' 判定（D-007 升厚即失效）
+    ...(turbo ? { turbo: true, turbo_since: new Date().toISOString() } : {}),
     baseline_commit: baseline,
     substeps: {},
   })
 
+  // 跨仓基线锚（2026-10-13-cross-repo-baseline-anchor）：thin 手工交付的跨仓对账此前无锚
+  // （B 档 HEAD~1 单笔窗口，多提交交付漏文件+交错时序抓错面——fire-ledger 两笔交付实证）。
+  // start 时点记各注册仓 HEAD（cross_baselines），收口窗口=基线..工作树（与主仓 baseline_commit
+  // 同构）。首写者胜（对齐 baseline_sha256 模式：重入不刷新，防跨仓已有并行提交后重锚漂移窗口）。
+  // 纯读 fail-soft：注册不可达/非 git 仓/rev-parse 失败 → 跳过该仓，绝不阻断 start。
+  try {
+    if (!(readFlowState(changeDir) || {}).cross_baselines) {
+      const _yamlText = existsSync(join(specBase, 'local.yaml')) ? readFileSync(join(specBase, 'local.yaml'), 'utf8') : ''
+      if (_yamlText) {
+        const { parseRepoRegistry } = await import('./stages/plan-postcheck.js')
+        const { isAbsolute: _isAbs, resolve: _res } = await import('node:path')
+        const _repos = parseRepoRegistry(_yamlText)
+        const _bl = {}
+        for (const [k, rawPath] of _repos || []) {
+          const rp = _isAbs(rawPath) ? rawPath : _res(cwd, rawPath)
+          if (!rp || !existsSync(rp)) continue
+          const sha = gitQuiet(rp, ['rev-parse', 'HEAD'], { timeout: 10_000 })
+          const s = sha === null ? '' : String(sha).trim()
+          if (/^[0-9a-f]{7,40}$/i.test(s)) _bl[k] = s
+        }
+        if (Object.keys(_bl).length > 0) {
+          writeFlowState(changeDir, { cross_baselines: _bl })
+          console.log(`🌐 跨仓基线锚：${Object.keys(_bl).length} 个注册仓 HEAD 已记入 flow-state（cross_baselines 首写者胜）——收口跨仓对账窗口=基线..工作树`)
+        }
+      }
+    }
+  } catch { /* 跨仓基线锚 best-effort：失败不阻断 start（收口回退既有档位） */ }
+
   // 全件机器起草（R7 切片三 / FR-07：工件回填轮=0——治理工件 CLI 写，agent 只裁例外）。
   // 任务卡分岔（用户裁定#3）：默认 thin+直写零任务卡；--thick/--with-tasks 才生成任务卡。
   let drafted = []
@@ -818,6 +1077,11 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
   const lines = [
     `🏃 flow start（${thick ? 'thick 厚档（--thick 显式声明，人声明不做启发式）' : 'thin 轻量跑道'}）: ${change}`,
     `══════════════════════════════════════`,
+    // 极速指引行（2026-10-14-thin-turbo-mode FR-01；2026-10-14-turbo-guide-tier-copy 评审 P3
+    // 清偿）：承诺文案随档位收窄——thick 起步时 done 读态 turbo 不生效（D-007），文案如实告知
+    // 全量仪式，防「提示说 A 实现是 B」漂移（cli-copy-selfsufficient②）。缺省路径逐字不变。
+    ...(turbo && !thick ? [`⚡ 极速模式（用户显式触发）：只产 spec+代码，收口自动跳过实测与重仪式门（必留面照常）；本次收口不含测试客观核验`]
+      : turbo && thick ? [`⚡ 极速留痕已记（--turbo），但 --thick 厚档起步——收口走全量仪式，实测与仪式门照跑不跳过（升厚即失效）`] : []),
     ...(hindsightHint ? [hindsightHint, ''] : []),
     `🔎 选道自检——对本需求，你还有没有必须问用户才能动手的问题？`,
     `   有 → sillyspec run brainstorm --change ${change}（它就是结构化问询协议，产物随后 flow start 自动收编续跑）；`,
@@ -926,6 +1190,15 @@ function printRecoveryBriefing({ cwd, specBase, change, changeDir, runtimeRoot,
     `- 剩什么：${left.length === 0 && dirty === 0 ? '活已干完' : dirty > 0 ? '活未干完（继续改代码）' : '收尾待裁决'}`,
     `- 下一步：${left.length === 0 ? `sillyspec flow done --change ${change}` : `继续干活；干完跑 flow done（断点续）`}`,
     ...(digestLines.length > 0 ? ['', ...digestLines] : []),
+    // 尾部原型锚（2026-10-14-guide-anchor-adopt-proto）：收编/含原型变更重入时原型指针不隐身
+    //（首进 adopt 输出的 🖼️ 行在会话切换后已丢，简报尾部补可发现面；置于 digestLines 后＝绝对
+    // 尾部，长知识注入段也顶不掉——评审 P3-2 清偿）。无原型零输出。
+    ...(() => {
+      const protos = changeArtifactPaths(changeDir).filter((p) => /\.html$/i.test(p))
+      return protos.length > 0
+        ? [`- 变更原型在场（UI 实现前必看，界面/交互/流程按原型对齐）：`, ...protos.map((p) => `  - ${p}`)]
+        : []
+    })(),
   ].join('\n'))
 }
 
@@ -958,6 +1231,9 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
     console.error('❌ 本 change 已混跑回退 legacy（跑过 run <stage>）——剩余流程按厚档走 run <stage>，flow done 不再裁决')
     process.exit(2)
   }
+  // 极速模式读态（2026-10-14-thin-turbo-mode FR-02/D-007）：turbo && tier!=='thick' 双条件——
+  // 升厚（distill 异态/verify 失败/--thick 起步）后 turbo 残留不短路厚档仪式，重入即恢复全量校验
+  const turbo = st.turbo === true && st.tier !== 'thick'
   const runtimeRoot = resolveRuntimeRoot(runtimeRootOpt ? { runtimeRoot: runtimeRootOpt } : {}, specBase)
   // 归属收窄清单（2026-09-25-thin-dogfood-fixes 修复②）：baseline..HEAD 不分作者——并行会话在
   // start..done 之间的提交会混入本变更实测面与 FR 域路由。复用 verify 对账同款切分器：他侧显式
@@ -1198,11 +1474,22 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
     // 采样去重（2026-10-07-thin-tasks-v3）：task tick 直写的精确事件（source:'task-tick'）为
     // 权威口径，watcher 3s 采样合并跳被去重——CLI 快速连续 tick 不再误伤；观测旁路缺席
     // （无流/读失败）→ 跳过（fail-open，watcher 非真相源）；--allow-batch-tick 显式旁路留痕。
+    // 侧车突发回退（2026-10-14-tick-burst-sidecar-gate）：CLI 收口端快连点对事件流不可见（单格
+    // 精确跳），空结果时回退 task-ticks.jsonl 毫秒时戳判突发——CLI 与直接 Edit 两条路径同判。
     try {
       const { readWatcherEvents } = await import('./watcher.js')
-      const { detectBatchCheckCadence, resolveBatchTickAction } = await import('./sentinel-assertions.js')
+      const { detectBatchCheckCadence, detectTickBurst, resolveBatchTickAction } = await import('./sentinel-assertions.js')
       const stream = readWatcherEvents({ runtimeRoot, change })
-      const batch = stream.exists ? detectBatchCheckCadence(stream.events) : null
+      let batch = stream.exists ? detectBatchCheckCadence(stream.events) : null
+      if (!batch) {
+        // 侧车突发回退（2026-10-14-tick-burst-sidecar-gate）：事件流空结果时读 change 目录
+        // task-ticks.jsonl（CLI tick 毫秒时戳事实源，随归档进 git、不受观测盲窗影响）判快连点；
+        // 事件流结果优先不双重报告；侧车缺失/坏文件按无证据静默（fail-open）。
+        try {
+          const { parseTickLog } = await import('./timeline.js')
+          batch = detectTickBurst(parseTickLog(readFileSync(join(changeDir, 'task-ticks.jsonl'), 'utf8')))
+        } catch { /* 侧车缺失/不可读 → 无侧车证据（fail-open） */ }
+      }
       if (batch) {
         // 代勾计数取「本拍实时代勾 ∨ 持久化代勾」较大者（二轮 P2-B：重入漂移防护）；决策纯函数
         // 单源（resolveBatchTickAction）四态与豁免优先序见其 JSDoc——代勾须解释整跳才降级
@@ -1227,7 +1514,8 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
             console.warn(`⚠️ 勾选节奏：单拍多格勾选（${batch.detail}，${at}）——${why}，降级提醒不拒`)
           }
         } else if (v.action === 'reject') {
-          console.error(`🚫 单拍勾选拒收：事件流观测到一拍勾选 ${batch.detail}（${at}）——勾选纪律要求逐格（做一件→勾一格→下一个），勾选任务 ${_sentinelNonMirrorTasks} 格`)
+          const _via = batch.source === 'tick-burst' ? '侧车时戳观测到' : '事件流观测到'
+          console.error(`🚫 单拍勾选拒收：${_via}一拍勾选 ${batch.detail}（${at}）——勾选纪律要求逐格（做一件→勾一格→下一个），勾选任务 ${_sentinelNonMirrorTasks} 格`)
           console.error('   出口：①节奏违例已既成——认知后重跑带 --allow-batch-tick 显式留痕过门（平台时间线可见旁路）；②疑观测误判→sillyspec doctor 核对事件流')
           appendTelemetry({ sentinel: 'batch-tick', jump: batch.detail })
           reportMidFail('ledger')
@@ -1235,7 +1523,14 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
         }
       }
     } catch { /* 节奏门 best-effort：读流失败静默（fail-open——观测缺席不阻断） */ }
-    const gate = await runQuickTestLintGate({ cwd, specBase, changedFiles, changeName: change, skipSentinel: true /* flow 侧哨兵带 baseline 区间，quick 侧区间不可靠——单判不双判 */ })
+    // 极速模式实测门跳过（2026-10-14-thin-turbo-mode FR-02/D-002）：turbo 在场不调
+    // runQuickTestLintGate，合成 gate 同形状 skipped 对象（带 status:'skipped' 完整形态——
+    // 下方 fmt 对 null 显示 '—'，带形态才输出「skipped — 跳过原因」，审计可见；
+    // 对齐 quick-audit env 逃生门 skip 形态先例 src/run/quick-audit.js:482）。
+    // 失败升厚分支（下方 action==='fail'）turbo 下天然不触达——升厚语义不变。
+    const gate = turbo
+      ? { action: 'skip', failed: [], reason: `⚡ 极速模式（用户显式触发 ${st.turbo_since || '时点未记'}）——test+lint 实测跳过（审计留痕；本次收口不含测试客观核验）`, test: { status: 'skipped', command: null, exitCode: null, durationMs: null, outputTail: null, reason: `⚡ 极速模式（用户显式触发 ${st.turbo_since || '时点未记'}）——本次收口不含测试客观核验（审计留痕）`, resultPath: null }, lint: { status: 'skipped', command: null, exitCode: null, durationMs: null, outputTail: null, reason: '⚡ 极速模式——lint 实测跳过（审计留痕）', resultPath: null } }
+      : await runQuickTestLintGate({ cwd, specBase, changedFiles, changeName: change, skipSentinel: true /* flow 侧哨兵带 baseline 区间，quick 侧区间不可靠——单判不双判 */ })
     if (gate && gate.action === 'fail') {
       console.error(`❌ 测试门 FAIL（整单 FAIL——实测失败/超时=失败，不继续 distill/归档）：`)
       console.error(`   ${gate.reason || gate.message || JSON.stringify(gate)}`)
@@ -1279,6 +1574,7 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
       } catch { /* lint 件套 best-effort */ }
       // 失败触发升级（R7 切片四 / FR-10 / 护栏#4：不依赖 agent 主动）——剩余流程按厚档走
       writeFlowState(changeDir, { tier: 'thick', upgrade_reason: `verify 实测失败（${gate.reason || 'test fail'}）——失败自动升厚` })
+      resetThinStageRowOnUpgrade(cwd, change, specBase)
       console.error('   ⬆️ 已自动升厚档（tier=thick）：重入修复后剩余流程按厚档语义（归档不跳过 plan.md 校验）')
       reportMidFail('ledger')
       process.exit(1)
@@ -1290,7 +1586,7 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
     const fmt = (r) => r
       ? `${r.status}${r.command ? ` ← ${r.command}` : ''}${typeof r.durationMs === 'number' ? `（${(r.durationMs / 1000).toFixed(1)}s）` : ''}${r.resultPath ? ` 结果：${r.resultPath}` : ''}${r.status === 'skipped' && r.reason ? ` — 跳过原因：${String(r.reason).split('。')[0]}。` : ''}`
       : '—'
-    gateSummaryText = `test: ${fmt(gate && gate.test)}｜lint: ${fmt(gate && gate.lint)}｜门文件 ${Array.isArray(changedFiles) ? changedFiles.length : '?'} 个`
+    gateSummaryText = `${turbo ? '⚡极速模式｜' : ''}test: ${fmt(gate && gate.test)}｜lint: ${fmt(gate && gate.lint)}｜门文件 ${Array.isArray(changedFiles) ? changedFiles.length : '?'} 个`
     console.log(`🧾 实测面对账 — ${gateSummaryText}`)
     try { writeFlowState(changeDir, { gate_summary: gateSummaryText }) } catch { /* 存档 best-effort */ }
     // FR 腐烂 suspect（2026-09-25-thin-fr-inject-parity）：quick-done 钩子迁轻量道（quick 退役后
@@ -1374,62 +1670,87 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
     // 提交时，幂等跳过会把 change.patch/review.json 停在处置前时点（归档审计件缺处置面，
     // 2026-10-05-flowdone-lintfail-output 收编活体复现）。漂移 → 自动重冻结（等价 --refreeze）
     // + review 已有结论则隔离旧 review.json（结论对着旧冻结面不作数）并重置标记强制重评。
-    try {
-      const patchMeta = JSON.parse(readFileSync(join(changeDir, 'change-patch.json'), 'utf8'))
-      const { detectPatchDrift } = await import('./flow-parity.js')
-      const drift = detectPatchDrift({ cwd, change, freezeHead: patchMeta.head })
-      if (drift.drifted) {
-        console.warn(`⚠️ 审计时点漂移：patch 冻结（${String(patchMeta.head || '').slice(0, 8)}）后另有 ${drift.ownCommits.length} 个本变更交付提交（${drift.ownCommits.slice(0, 3).join('；')}${drift.ownCommits.length > 3 ? ' 等' : ''}）——幂等跳过会把审计件停在处置前时点`)
-        // 隔离先行（评审处置 P3：时间戳槽位防跨代覆盖——单槽 .superseded 在 Windows renameSync
-        // 同名碰撞会抛错；隔离失败则整体退回现状幂等跳过（fail-safe：漂移处理要么完整交付要么
-        // 不动，不留半套状态），指引人工处置后重跑）
-        const reviewPath = join(changeDir, 'review.json')
-        let quarantineOk = true
-        if (existsSync(reviewPath)) {
-          // 锚定保留判定（2026-10-06-review-anchor-and-negation 实测竞态：复审对着当前 HEAD
-          // 做的 PASS 结论落盘 26 秒后被「重冻结时刻在场=过期」口径误隔离）：reviewedAgainst
-          // 命中当前 HEAD = 评审对象即最新交付面，结论有效——保留不隔离、review 标记不重置。
-          // 缺省/读失败/格式非法按未锚定处理，隔离行为不变（fail-safe 宁可多评）。
-          let anchoredToHead = false
+    //
+    // 冻结件存在性复查（2026-10-14-patch-refreeze-missing-artifact）：子步标记 done 而冻结件
+    // 缺席（手工误删/上次写盘中断）时，旧逻辑 readFileSync 抛错被下方 catch 吞掉 → 幂等跳过
+    // → 归档无审计冻结件（multi-agent-platform 2026-10-14 实证：verify-result 记「无冻结件」，
+    // 只能按 git 手工重建）。存在性复查优先于子步状态：缺件按漂移同款自动重冻结（重冻面=
+    // 当前 HEAD）；review 处置沿用漂移面同一隔离规则——缺基面无法判 governance-only，
+    // 未锚定一律隔离（fail-safe 宁可多评）。
+    const patchJsonPath = join(changeDir, 'change-patch.json')
+    const patchTextPath = join(changeDir, 'change.patch')
+    const missingFreeze = [
+      !existsSync(patchJsonPath) ? 'change-patch.json' : null,
+      !existsSync(patchTextPath) ? 'change.patch' : null,
+    ].filter(Boolean)
+    let drifted = false
+    let drift = null
+    if (missingFreeze.length > 0) {
+      drifted = true
+      console.warn(`⚠️ 冻结件缺失：patch 子步标记 done 但 ${missingFreeze.join('、')} 不在——存在性复查优先于子步状态，按漂移同款自动重冻结（2026-10-14-patch-refreeze-missing-artifact）`)
+    } else {
+      try {
+        const patchMeta = JSON.parse(readFileSync(patchJsonPath, 'utf8'))
+        const { detectPatchDrift } = await import('./flow-parity.js')
+        drift = detectPatchDrift({ cwd, change, freezeHead: patchMeta.head })
+        if (drift.drifted) {
+          drifted = true
+          console.warn(`⚠️ 审计时点漂移：patch 冻结（${String(patchMeta.head || '').slice(0, 8)}）后另有 ${drift.ownCommits.length} 个本变更交付提交（${drift.ownCommits.slice(0, 3).join('；')}${drift.ownCommits.length > 3 ? ' 等' : ''}）——幂等跳过会把审计件停在处置前时点`)
+        }
+      } catch { /* 漂移检测失败按现状幂等跳过（fail-safe 不新造阻断面） */ }
+    }
+    if (drifted) {
+      // 隔离先行（评审处置 P3：时间戳槽位防跨代覆盖——单槽 .superseded 在 Windows renameSync
+      // 同名碰撞会抛错；隔离失败则整体退回现状幂等跳过（fail-safe：漂移处理要么完整交付要么
+      // 不动，不留半套状态），指引人工处置后重跑）
+      const reviewPath = join(changeDir, 'review.json')
+      let quarantineOk = true
+      if (existsSync(reviewPath)) {
+        // 重冻结目标 HEAD：漂移面取 detectPatchDrift.head；缺件重冻面取当前 HEAD（重冻结将锚定该面）。
+        // 锚定保留判定（2026-10-06-review-anchor-and-negation 实测竞态：复审对着当前 HEAD
+        // 做的 PASS 结论落盘 26 秒后被「重冻结时刻在场=过期」口径误隔离）：reviewedAgainst
+        // 命中重冻结目标 HEAD = 评审对象即最新交付面，结论有效——保留不隔离、review 标记不重置。
+        // 缺省/读失败/格式非法按未锚定处理，隔离行为不变（fail-safe 宁可多评）。
+        const refreezeHead = drift ? drift.head : String(gitQuiet(cwd, ['rev-parse', 'HEAD']) || '').trim()
+        let anchoredToHead = false
+        try {
+          const { reviewAnchoredToHead } = await import('./flow-review.js')
+          anchoredToHead = reviewAnchoredToHead(reviewPath, refreezeHead)
+        } catch { /* 锚定判定失败按未锚定处理 */ }
+        if (anchoredToHead) {
+          console.log(`   review.json 已锚定当前 HEAD（reviewedAgainst 命中 ${String(refreezeHead || '').slice(0, 8)}）——评审对象即最新交付面，结论保留不隔离`)
+        } else if (drift && drift.governanceOnly && !drift.touchedPromiseFace) {
+          // 治理面等价保留（2026-10-10-drift-review-governance-keep，坑 drift-review-governance-loop
+          // 用户实证）：评审结论的对象是交付面——窗口内本变更提交只碰 .sillyspec/** 治理文件且
+          // 未触本变更 requirements/design（承诺面也是评审对象）时，结论对最新交付面逐字节等价，
+          // 保留不隔离不重置标记；change.patch 仍走下方 driftRefreeze 自动重冻结（FR-01 后治理
+          // 工件不入冻结面——治理修复的留档真相=归档目录本体文件，重冻结保交付面时点对齐）
+          // （审计件覆盖最新提交面不变量不破）。此前任何后缀提交一律隔离重评——评审后修一个
+          // P2 文档措辞也付整轮子代理评审费（循环，被迫手工重排执行顺序自赎）。
+          console.log(`   review.json 保留不隔离——窗口内本变更提交仅触及治理文件（${drift.ownFiles.length} 个，未触 requirements/design），评审对象（交付面）未变，结论对最新面等价；change.patch 自动重冻结（治理工件不入冻结面，治理修复随归档目录本体留档）`)
+        } else {
+          const ts = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, '')
           try {
-            const { reviewAnchoredToHead } = await import('./flow-review.js')
-            anchoredToHead = reviewAnchoredToHead(reviewPath, drift.head)
-          } catch { /* 锚定判定失败按未锚定处理 */ }
-          if (anchoredToHead) {
-            console.log(`   review.json 已锚定当前 HEAD（reviewedAgainst 命中 ${String(drift.head || '').slice(0, 8)}）——评审对象即最新交付面，结论保留不隔离`)
-          } else if (drift.governanceOnly && !drift.touchedPromiseFace) {
-            // 治理面等价保留（2026-10-10-drift-review-governance-keep，坑 drift-review-governance-loop
-            // 用户实证）：评审结论的对象是交付面——窗口内本变更提交只碰 .sillyspec/** 治理文件且
-            // 未触本变更 requirements/design（承诺面也是评审对象）时，结论对最新交付面逐字节等价，
-            // 保留不隔离不重置标记；change.patch 仍走下方 driftRefreeze 自动重冻结（FR-01 后治理
-            // 工件不入冻结面——治理修复的留档真相=归档目录本体文件，重冻结保交付面时点对齐）
-            // （审计件覆盖最新提交面不变量不破）。此前任何后缀提交一律隔离重评——评审后修一个
-            // P2 文档措辞也付整轮子代理评审费（循环，被迫手工重排执行顺序自赎）。
-            console.log(`   review.json 保留不隔离——窗口内本变更提交仅触及治理文件（${drift.ownFiles.length} 个，未触 requirements/design），评审对象（交付面）未变，结论对最新面等价；change.patch 自动重冻结（治理工件不入冻结面，治理修复随归档目录本体留档）`)
-          } else {
-            const ts = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, '')
-            try {
-              renameSync(reviewPath, `${reviewPath}.superseded-${ts}`)
-              console.warn(`   旧 review.json 已隔离为 review.json.superseded-${ts}（评审结论对着旧冻结面）——重新执行评审任务书后再收口`)
-            } catch (e) {
-              quarantineOk = false
-              console.error(`   ⚠️ 旧 review.json 隔离失败（${e.message}）——本次保持现状幂等跳过，手动删除/改名 ${reviewPath} 后重跑（将自动重冻结+重评）`)
-            }
+            renameSync(reviewPath, `${reviewPath}.superseded-${ts}`)
+            console.warn(`   旧 review.json 已隔离为 review.json.superseded-${ts}（评审结论对着旧冻结面）——重新执行评审任务书后再收口`)
+          } catch (e) {
+            quarantineOk = false
+            console.error(`   ⚠️ 旧 review.json 隔离失败（${e.message}）——本次保持现状幂等跳过，手动删除/改名 ${reviewPath} 后重跑（将自动重冻结+重评）`)
           }
         }
-        if (quarantineOk) {
-          driftRefreeze = true
-          if (st.substeps?.review === 'done' && !existsSync(reviewPath)) {
-            // 双故障边界（评审 P3 处置披露）：writeFlowState 盘写失败时内存重置保本运行正确；
-            // 极端双故障（隔离成功+盘写失败）下轮残留 done 且 review.json 缺席 → review 子步
-            // backfill 按 exempt 误读——该窄路径未测（需 I/O 故障注入，design 边界披露）
-            try { writeFlowState(changeDir, { substeps: { review: null } }) } catch { /* 见上边界注释 */ }
-            if (st.substeps) st.substeps.review = null
-            if (!existsSync(reviewPath)) console.warn('   review 豁免口径对着旧冻结面——review 子步标记已重置，本次重新定档')
-          }
+      }
+      if (quarantineOk) {
+        driftRefreeze = true
+        if (st.substeps?.review === 'done' && !existsSync(reviewPath)) {
+          // 双故障边界（评审 P3 处置披露）：writeFlowState 盘写失败时内存重置保本运行正确；
+          // 极端双故障（隔离成功+盘写失败）下轮残留 done 且 review.json 缺席 → review 子步
+          // backfill 按 exempt 误读——该窄路径未测（需 I/O 故障注入，design 边界披露）
+          try { writeFlowState(changeDir, { substeps: { review: null } }) } catch { /* 见上边界注释 */ }
+          if (st.substeps) st.substeps.review = null
+          if (!existsSync(reviewPath)) console.warn('   review 豁免口径对着旧冻结面——review 子步标记已重置，本次重新定档')
         }
       }
-    } catch { /* 漂移检测失败按现状幂等跳过（fail-safe 不新造阻断面） */ }
+    }
     if (!driftRefreeze) skip('patch')
   }
   if (st.substeps?.patch !== 'done' || driftRefreeze) {
@@ -1532,7 +1853,12 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
           // ——旧行为警告后继续归档，autopilot 单跑到底把三选一变成不可达选项（归档即拒收重入）。
           // 缺口在场且未显式处置 → 停在 patch 子步标记之前（半态可重入，与 review 中断同款
           // exit 语义）：处置后重跑，patch 全量重建自动并入已提交 src。
-          if (!freezeDirty && !acceptDirtyGap) {
+          // 极速模式（2026-10-14-thin-turbo-mode FR-02/D-002）：缺口三选一阻断降 advisory——
+          // 警告+缺口数留痕后放行，不 exit；非 turbo 路径逐字不变。
+          if (turbo && !freezeDirty && !acceptDirtyGap) {
+            console.warn(`⚡ 极速模式：未提交交付缺口未显式处置——降 advisory 放行（缺口数 ${freeze.dirtyWarned.length} 随收口输出留痕，审计自负）`)
+          }
+          if (!freezeDirty && !acceptDirtyGap && !turbo) {
             console.error('⛔ 未提交交付缺口未显式处置——收口阻断（不归档；处置后重跑同一条命令从断点续）：')
             console.error(`   ① git commit 这些文件（信息尾缀带 (${change}) 或 （${change}），重跑本命令——冻结面自动并入`)
             console.error(`   ② 全部归属本变更：flow done --change ${change} --freeze-dirty`)
@@ -1731,6 +2057,9 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
                 changeName: change,
                 planEntries,
                 collectPatch: true,
+                // 跨仓基线锚透传（2026-10-13-cross-repo-baseline-anchor）：flow start 记录的
+                // cross_baselines → collectRepoActual 3c 档（基线..工作树窗口，token 归因主面）
+                crossBaselines: (st && st.cross_baselines && typeof st.cross_baselines === 'object') ? st.cross_baselines : null,
               })
               crossRepoRows = recon.rows
               crossRepos = recon.repos
@@ -1822,6 +2151,13 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
         reviewOutcome = { required: false, sampled: false, verdict: 'exempt', backfilled: true }
       }
     } catch { reviewOutcome = { required: null, verdict: 'done', backfilled: true } }
+  } else if (turbo) {
+    // 极速模式评审豁免（2026-10-14-thin-turbo-mode FR-02/D-001/D-002）：用户显式极速声明=
+    // 风险自担留痕，跳过 classifyReviewNeed 强制豁免（telemetry src/flow.js 整对象 JSON
+    // 序列化，turboExempt 字段无破坏——Grill X-003 探针已核）。
+    console.log('⚡ 极速模式：评审子步豁免（用户显式极速声明=风险自担留痕）')
+    reviewOutcome = { required: false, sampled: false, verdict: 'exempt', turboExempt: true }
+    mark('review')
   } else {
     const { classifyReviewNeed, renderReviewerTaskbook, validateReviewJson } = await import('./flow-review.js')
     let patchText = null
@@ -1912,6 +2248,10 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
     // 视觉降级无用户裁决留痕恒拦；ui_visual_gate=error 时缺 visual-evidence.md 亦拦；
     // 默认 warn 档只警告不拦。与 run/gates.js verify 收尾同一检测单点，不二算）。
     try {
+      if (turbo) {
+        // 极速模式（2026-10-14-thin-turbo-mode FR-02/D-002）：ui 视觉探针跳过留痕
+        console.log('⚡ 极速模式：UI 视觉证据探针跳过（审计留痕）')
+      } else {
       const uiProbe = runUiVisualProbe({ changeDir, gate: readUiVisualGate(specBase) })
       if (uiProbe.level === 'error') {
         console.error('\n❌ UI 视觉证据门（探针 12 error 档）阻断收口：')
@@ -1922,6 +2262,7 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
       } else if (uiProbe.level === 'warn') {
         console.warn(`⚠️ UI 视觉证据（探针 12 warn 档）：${uiProbe.notes.join('；')}`)
       }
+      }
     } catch (e) {
       console.warn(`⚠️ UI 视觉证据探针异常（fail-soft 降级放行）：${(e && e.message) || e}`)
     }
@@ -1930,7 +2271,9 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
     // 竞争、在途残留；hunk_gate warn 默认（警告）/error（阻断）/off。与「提交面夹带嫌疑
     // advisory」互补：advisory 在冻结面采集处看文件名，本门在 probes 执法看 hunk 与竞争面。
     try {
-      const gate = readHunkGate(specBase)
+      // 极速模式（2026-10-14-thin-turbo-mode FR-02/D-002）：hunk 门强制降 warn 档——
+      // 判定链路照跑（三类信号照常渲染），仅 error 阻断档解除（降 advisory 留痕不阻断）。
+      const gate = turbo ? 'warn' : readHunkGate(specBase)
       let committedForGate = []
       try {
         committedForGate = String(gitQuiet(cwd, ['diff', '--name-only', `${st.baseline_commit}..HEAD`]) || '')
@@ -1990,8 +2333,10 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
     // 回读块保证在场（patch 本轮算出或 change-patch.json 回读）。
     try {
       if (moduleScope && Array.isArray(moduleScope.modules) && moduleScope.modules.length > 0) {
-        const { appendChangeIndexEntries } = await import('./flow-parity.js')
-        const motive = String(st.input || '').split('\n').map((s) => s.trim()).find(Boolean) || ''
+        const { appendChangeIndexEntries, motiveFromInput } = await import('./flow-parity.js')
+        // 摘要与变更标题同源（2026-10-15-title-label-skip）：段头行（动机与背景：等）跳过取次行，
+        // 空提取回退变更名——此前裸取首行致「动机与背景：」整行入摘要（stages.changelog 实证）。
+        const motive = motiveFromInput(st.input, change)
         const wr = appendChangeIndexEntries({ specBase, modules: moduleScope.modules, change, summary: motive, date: new Date().toISOString().slice(0, 10) })
         changelogAppended = wr.appended
         if (wr.appended.length > 0) console.log(`📖 模块变更索引回写：${wr.appended.length} 个目标（${wr.appended.join('、')}）——sidecar 优先/卡内节次之，随归档窄化入暂存`)
@@ -2007,6 +2352,7 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
       const abnormal = res && (res.rejected > 0 || res.needsWait > 0)
       if (abnormal) {
         writeFlowState(changeDir, { tier: 'thick', upgrade_reason: `distill 异态（rejected=${res.rejected} needsWait=${res.needsWait}）——升厚留人工裁决` })
+        resetThinStageRowOnUpgrade(cwd, change, specBase)
         console.warn(`⚠️ distill 异态 → 已升厚档（tier=thick）。剩余流程按厚档走 run <stage> 完整仪式；归档子步仍将执行（厚档语义不跳过 plan.md 校验）。`)
       }
     } catch (e) {
@@ -2317,7 +2663,7 @@ export async function cmdFlow(args, cwd, specDir = null, opts = {}) {
         console.error(`❌ ${e.message}`)
         // 可照抄实例（2026-10-05-input-teach-copyable）：引号内换行合法，行级 trim 容忍缩进
         console.error('   重试（--input 引号内换行合法，可照抄）：')
-        console.error('   sillyspec flow start --change <YYYY-MM-DD-简短描述> --input "<动机与背景>')
+        console.error('   sillyspec flow start --change <YYYY-MM-DD-简短描述> --input "<一句中文概括（首行即变更标题）；随后动机与背景')
         console.error('')
         console.error('   成功标准：')
         console.error('   - <可验证标准>"')
@@ -2333,6 +2679,8 @@ export async function cmdFlow(args, cwd, specDir = null, opts = {}) {
       withTasks: hasFlag('--with-tasks'),
       reviewForce: hasFlag('--review') ? true : hasFlag('--no-review') ? false : null,
       autopilot: hasFlag('--autopilot'),
+      prestageAck: hasFlag('--no-prestage'),
+      turbo: hasFlag('--turbo'),
       cwd, specBase,
       json: hasFlag('--json') || jsonGlobal,
     })
@@ -2358,6 +2706,15 @@ export async function cmdFlow(args, cwd, specDir = null, opts = {}) {
     await reportAgentLog(change, sub)
     return cmdFlowReject({ change, cwd, specBase, reason: getFlag('--reason') })
   }
+  if (sub === 'diff') {
+    // 只读查询面（2026-10-13-flow-diff-cmd）：change 粒度文件统计双态口——与 status 同级自愿面
+    const change = getFlag('--change')
+    if (!change) { console.error('❌ flow diff 需 --change <名>'); process.exit(2) }
+    validateChangeName(change)
+    await reportAgentLog(change, sub)
+    await cmdFlowDiff({ change, cwd, specBase, json: jsonGlobal || hasFlag('--json') })
+    return
+  }
   if (sub === 'status') {
     // 三断点配套（2026-09-25-flow-checkpoints）：随时可查当前变更阶段/槽位/子步进度
     const change = getFlag('--change')
@@ -2535,12 +2892,13 @@ export async function cmdFlow(args, cwd, specDir = null, opts = {}) {
     console.log(`✅ flow amend-draft 留痕重锚：${r.reanchored.join('、')}——ledger amendment 审计在案；editRatio=${maxRatio}（段级最大；基准=首版原文，AGENT 槽不计入）`)
     return r
   }
-  console.error('用法: sillyspec flow start --change <名> --input "<动机与背景＋独立一行『成功标准：』＋每行一条『- 可验证标准』>" [--thick|--with-tasks] | sillyspec flow done --change <名> | sillyspec flow status --change <名> [--json]')
+  console.error('用法: sillyspec flow start --change <名> --input "<一句中文概括（首行即变更标题）＋动机与背景详述＋独立一行『成功标准：』＋每行一条『- 可验证标准』>" [--thick|--with-tasks] [--no-prestage（hindsight 标记在场时声明需求已含决策，留痕放行）] | sillyspec flow done --change <名> | sillyspec flow status --change <名> [--json] | sillyspec flow diff --change <名> [--json]（只读文件统计）')
   console.error('      --input 可照抄形态（引号内换行合法）：')
-  console.error('      sillyspec flow start --change <名> --input "<动机与背景>')
+  console.error('      sillyspec flow start --change <名> --input "<一句中文概括（首行即变更标题）；随后动机与背景')
   console.error('')
   console.error('      成功标准：')
   console.error('      - <可验证标准>"')
+  console.error('      预段同意门被拦时（上个轻量变更被 route-hindsight 标记「疑似该走预段未走」）：确认需求已含决策加 --no-prestage；不清晰则先 run brainstorm --change <名>，完成后回来 flow start 收编（标记自动消费）')
   process.exit(2)
 }