sillyspec 3.33.4 → 3.33.5

package/.claude/skills/sillyspec-config/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: sillyspec:config
+description: 用于 SillySpec local.yaml 配置引导。适合用户说"配置下 sillyspec、连接平台、配 MCP、lint 不跑、测试太慢、加豁免"或 agent 需要写 .sillyspec/local.yaml 时。核心原则：默认零配置可用，只写真需要的键，写完必须 config validate 通过。
+---
+
+## 何时使用
+
+- 用户要求配置 SillySpec（平台凭据/MCP/测试/lint/调优键）
+- agent 判断需要写 `.sillyspec/local.yaml`（任何场景——本技能是唯一引导面）
+
+## 第一原则：默认零配置可用（先读这段再动手）
+
+**local.yaml 一个键都不写，SillySpec 就是完整可用的。** 全部 ~70 个注册键中只有平台/MCP 凭据族（4 键）真必填，且仅当用户要用平台功能。测试面按变更动态推断、lint 未配置自动跳过归 pre-push、FR 回归层缺省不跑归 CI——都是零配置最优缺省（2026-10-23 起）。
+
+**不要「预防性配置」**：不确定要不要写的键就是不写。写了多余键的唯一效果是偏离缺省、增加审计面。
+
+## 必填场景决策表（只有这些场景才动配置）
+
+| 场景 | 症状/触发 | 要写的键 | 怎么获得值 |
+|---|---|---|---|
+| 平台同步/看板 | 用户要用 SillyHub 平台 | `platform.url` + `platform.token` | **不手填**：跑 `sillyspec platform connect <url> --token <t>` 自动写 |
+| MCP 派发 | 评审平台单调用/独立审查派发 | `mcp.url` + `mcp.token` | 同上（connect 成对签发） |
+| 评审单调用 | 用户要评审收口一次完成（省 missing→PASS 往返） | `review_inline_wait: 180` | 依赖 mcp 凭据；平台不可用自动回退任务书面零损失 |
+| dirty 门残渣 | 收口反复被已知残渣文件拦（--accept-dirty-gap 成常态） | `dirty_gate_ignore: <前缀1>, <前缀2>` | 看收口输出点名的文件，取其稳定目录前缀 |
+| lint 收口实测 | 用户要 lint 在收口时跑（缺省跳过归 pre-push） | `commands.lint: <命令>` | 从 package.json scripts / Makefile 抄 |
+| 慢套件超时 | 实测被 600s 默认帽判超时失败 | `commands.test_timeout_sec: 2400` | 收口输出会提示 |
+| 全量测试道 | 用户明确要本地跑全量（罕见） | `test_strategy: full` | 仅显式全量时；缺省动态子集已是最优 |
+| 项目特有评审必查面 | 团队有自己的评审红线 | `review_probes:` 段 | 见 `sillyspec config schema` review_probes 节 |
+
+调优键全清单与语义：`sillyspec config schema`（单一真相；example 列可照抄值）。
+
+## 操作流程
+
+1. **看现状**：`sillyspec config cat`（权威路径链解析——worktree 内也能拿到主仓真实文件；不存在=零配置形态，正常）。
+2. **对决策表**：确认触发场景真实存在；不在表内的场景**不写任何键**，向用户说明缺省行为已覆盖。
+3. **获得值**：凭据族走 `sillyspec platform connect`（禁止手填 token 到 yaml）；其余键从仓库结构（package.json/pyproject/Makefile）或收口输出提示取值。
+4. **写文件**：编辑 `.sillyspec/local.yaml`（config cat 显示的路径；整文件 YAML，注意缩进用空格、保存为 UTF-8 无 BOM——PS 下用 Set-Content -Encoding utf8NoBOM 或让 CLI 命令代写）。**只写决策表需要的键，逐键照抄 schema 的 example 形态。**
+5. **硬门验证（必做，不许跳过）**：跑 `sillyspec config validate`
+   - **exit 0 才算配置完成**；exit 1 时按输出的错误行逐条修复后重跑。
+   - 有「未知顶层键」警告=键名/层级写错，回 schema 核对。
+   - 凭据段报缺键=两键要成对（或整段删除回退）。
+   - **禁止**在 validate 未通过时向用户宣称配置完成。
+
+## 边界
+
+- 禁止写 `.sillyspec/` 之外的 local.yaml（hook 拦截）；项目根没有这个文件。
+- 禁止把 token 写进 local.yaml.example 或任何可提交文件（真实 local.yaml 是 gitignored）。
+- known_failures 豁免键不用手改 yaml：`sillyspec config known-failures add|remove`（行级手术保注释）。

package/package.json

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

package/src/config-schema.js

@@ -122,6 +122,15 @@ export const LOCAL_YAML_SCHEMA = {
       keys: [
         { path: 'modules.<name>.path', type: 'string', optional: true, status: 'live', readers: ['extractModules (src/verify-postcheck.js)', 'parseLocalYamlModules (src/plan-postcheck.js)', 'extractModulePaths (src/worktree-deps.js)'], desc: '子模块目录路径（相对仓库根）。', example: 'frontend/' },
         { path: 'modules.<name>.test', type: 'string', optional: true, status: 'deprecated', readers: ['extractModules (src/verify-postcheck.js，退役提示用）'], desc: '【2026-09-26-dynamic-test-inference 退役，不再消费】测试面按变更动态推断、runner 自项目结构（pyproject/uv.lock/package.json 就近祖先）推断。模块级 flaky 处置迁 known_failures。块在场时 CLI 打印退役指引。', example: 'cd frontend && pnpm test' },
+        { path: 'fr_unmapped_baseline', type: 'integer', optional: true, status: 'live', readers: ['unmapped 大池消音（src/fr-index.js）'], desc: 'unmapped 域 FR 条数消音基线（跨仓历史堆积已清算时设当前值；增量 >10 才警告，缺省 0=无基线恒警告行为）。', example: '720' },
+      ],
+    },
+    {
+      id: 'repos',
+      title: '跨仓注册表',
+      note: '仓键 → 本地工作目录。注册后参与跨仓冻结面/对账/未标注交付探测与跨仓 worktree 落位；条目两种形态：字符串路径或 {path, worktree} 对象（worktree=跨仓 worktree 落位根，优先级见 worktree.crossPlacement）。local.yaml 本就 gitignored，真实本地路径不入库。',
+      keys: [
+        { path: 'repos.<repo键>', type: 'string', optional: true, status: 'live', readers: ['跨仓冻结/对账（src/cross-repo-reconcile.js）、注册探测（src/local-register.js）、跨仓 worktree（src/worktree-cross.js）'], desc: '仓键 → 该仓本地工作目录绝对路径（或 {path, worktree} 对象形态）。', example: 'shared-lib: C:/path/to/shared-lib' },
       ],
     },
     {
@@ -131,6 +140,7 @@ export const LOCAL_YAML_SCHEMA = {
       keys: [
         { path: 'verify.test_rerun', type: 'enum', values: ['incremental', 'full'], optional: true, status: 'live', readers: ['readTestRerunConfig (src/verify-postcheck.js — dynamic-subset 分支增量档)'], desc: '实测门失败后重跑档：incremental（缺省）= 前轮失败后，下轮只跑「失败批测试文件 ∪ 自失败基线以来变更文件」的三源推断面（未触碰绿面复用，返工轮分钟级）；full = 恒全子集重跑（2026-10-07 前现状，保守项目用）。env SILLYSPEC_TEST_RERUN 优先。仅作用 dynamic-subset 档（显式 test_strategy: full 不受影响）。', example: 'verify: { test_rerun: full }' },
         { path: 'test_strategy', type: 'enum', values: ['full', 'module', 'skip', 'evidence-auto'], optional: true, status: 'live', readers: ['extractTestStrategy (src/verify-postcheck.js)', 'resolveTestStrategy (src/verify-postcheck.js)'], desc: '【2026-09-26-dynamic-test-inference 起】full=全量（commands.test 在场生效，否则结构推断）；module=已退役折算动态子集（超集覆盖：变更文件面收窄 + FR 关联回归 + import 依赖）；skip=真跳过（R-07 不变）；evidence-auto=按 module-impact.md 推荐（行为→动态子集、文档/门禁→skip）。缺省=动态子集：三源并集非空实测、空则不硬跑全量（防超时/预存失败面）。', example: 'full' },
+        { path: 'fr_regress_cap', type: 'string', optional: true, status: 'live', readers: ['readFrRegressCap (src/verify-postcheck.js)'], desc: '【2026-10-23-fr-regress-default-off 缺省翻转】FR 关联回归层本地实测开关：缺省（不写）=不跑（归 pre-push/CI 门，收口披露行留痕）；N（1-2000）=前 N 个绑定文件进实测面；all=全跑旧行为显式恢复；off=同缺省。', example: '40' },
       ],
     },
     {
@@ -188,6 +198,12 @@ export const LOCAL_YAML_SCHEMA = {
         { path: 'flow.mode', type: 'enum', values: ['thin', 'legacy'], optional: true, status: 'live', readers: ['readFlowConfig (src/flow.js)'], desc: '2-调用轻量协议开关：thin（缺省——2026-09-25-thin-default-flip 翻转，入口归一：常规变更默认轻量跑道，需求不清晰 CLI 拦下指路头脑风暴预段，实测失败自动升厚）= flow start/done 轻量跑道；legacy = 显式回旧道（run <stage> 全族行为逐字不动，flow start 拒跑并指路）。切回一行 yaml。', example: 'thin' },
         { path: 'flow.edit_ratio_threshold', type: 'number', optional: true, status: 'live', readers: ['readFlowConfig (src/flow.js)'], desc: '机器稿改写比例路由阈值（amend 通道计算的行级 editRatio 超阈 → 厚档提示 route_hint）。缺省 0.5。', example: '0.5' },
         { path: 'flow.edit_ratio_enforcement', type: 'enum', values: ['advisory', 'block'], optional: true, status: 'live', readers: ['readFlowConfig (src/flow.js)'], desc: 'editRatio 超阈的执行档：advisory（缺省——测绿可轻量档过，只提示+遥测）| block（超阈阻断 flow done）。用户裁定 advisory 定案，dogfood 后可按遥测翻 block。', example: 'advisory' },
+        // 以下四键为根级标量（无点 path——2026-10-23-config-validate-skill 补登：此前散落
+        // 各 reader 内联正则、schema 发现面缺失；校验器按注册面跟随）
+        { path: 'turbo', type: 'enum', values: ['docs-auto'], optional: true, status: 'live', readers: ['readFlowConfig (src/flow.js)'], desc: '【2026-10-23-turbo-docs-auto】纯文档面常设极速授权档：docs-auto=CLI 按提交∪脏面自动判纯文档（代码分类器同源）降档 turbo（实测/评审/UI 探针跳过，授权源留痕）；不写=关（--turbo 旗标档不受影响，agent 仍不可自启）。', example: 'docs-auto' },
+        { path: 'review_inline_wait', type: 'integer', optional: true, status: 'live', readers: ['readFlowConfig (src/flow.js)'], desc: '【2026-10-23-review-inline-dispatch】薄道评审平台单调用通道等待预算秒数（1-600，钳 300s 帽）：>0 时 flow done 评审缺席分支经 SillyHub 派发 readOnly worker 有界轮询回收、同调用登记（missing→PASS 往返消灭）；任何失败回退任务书面零损失；不写/坏值=关。', example: '180' },
+        { path: 'dirty_gate_ignore', type: 'string', optional: true, status: 'live', readers: ['readDirtyGateIgnore (src/flow-parity.js)'], desc: '【2026-10-23-dirty-gate-ignore】dirty 冻结缺口门的已知残渣前缀忽略清单（单行逗号分隔、posix 前缀匹配，module_gate_ignore 同款）：命中面从缺口剔除并每轮 ℹ️ 留痕；三态 fail-soft 未配置=现状。', example: 'quicklog, test/.sillyspec' },
+        { path: 'module_gate_ignore', type: 'string', optional: true, status: 'live', readers: ['readFlowConfig (src/flow.js)'], desc: '【2026-10-12-thin-module-gate-and-feed】模块图未登记目录软门的固定忽略清单（单行逗号、目录前缀、posix）——合法未登记面（根级脚本/配置等）免登记签收。', example: 'scripts, .github' },
       ],
     },
     {
@@ -426,6 +442,18 @@ dispatch:
 #   mode: thin               # thin=flow start/done 轻量跑道（协议必需交互=2）| legacy=既有 run <stage> 全族（回滚一行）
 #   edit_ratio_threshold: 0.5   # 机器稿改写比例路由阈值（超阈提示厚档；缺省 0.5）
 #   edit_ratio_enforcement: advisory   # advisory=测绿可轻量过只提示（缺省）| block=超阈阻断
+#
+# ── 收口调优（根级键，缺省零配置即用——注释态=缺省已最优，确要调优再解注释）──
+# turbo: docs-auto   # 纯文档面自动极速档（实测/评审/UI 探针跳过，授权源留痕）；不写=关
+# review_inline_wait: 180   # 评审平台单调用等待秒（1-600，需 SillyHub）；不写=评审任务书面模式
+# dirty_gate_ignore: quicklog, test/.sillyspec   # dirty 门已知残渣前缀（单行逗号、posix 前缀）
+# module_gate_ignore: scripts   # 模块图软门固定忽略目录（单行逗号、前缀匹配）
+# fr_regress_cap: 40   # FR 回归层本地开关：缺省不跑归 pre-push/CI 门；N=前 N 个；all=全跑旧行为
+# fr_unmapped_baseline: 720   # unmapped 域 FR 消音基线（跨仓历史堆积已清算时设）
+#
+# ── 跨仓注册表（注册后参与跨仓冻结/对账；local.yaml gitignored 故真实路径不入库）──
+# repos:
+#   shared-lib: C:/path/to/shared-lib   # 或对象形态 {path: …, worktree: <跨仓落位根>}
 
 # ── 阶段说明书下发与会话墙（R16 减负批次）──
 # stage:

package/src/config-validate.js

@@ -0,0 +1,180 @@
+/**
+ * config-validate.js — local.yaml 逐键校验器（2026-10-23-config-validate-skill）
+ *
+ * 用户配置哲学（2026-10-23 裁决原话）：「能不要配置的就别让用户配置，默认都集成好；实在
+ * 不好配置的要生成一个技能去引导 agent 怎么填写，并且 agent 写完要 CLI 验证通过才行」。
+ * 本模块是那句「CLI 验证」：sillyspec config validate 经 config-cat 权威路径链解析真实
+ * local.yaml（worktree 感知），按 LOCAL_YAML_SCHEMA 单一源逐键校验——校验只消费不生产
+ * （schema 注册面新增键照常跟随，无需改本模块）。
+ *
+ * 判级：错误（exit 1）=YAML 解析失败/顶层非映射/段非映射/枚举越界/结构性类型错（标量位
+ * 收到映射或数组）/不可强转标量（number/integer 键收 "abc" 类纯文本、boolean 键收非
+ * true|false 串）/段内必填键缺失（凭据族两键齐全才生效）。警告（exit 0）=未知键（可能
+ * 无效果）。info（exit 0）=deprecated 键在场/空文件。标量强转语义（评审 P1 修正）：数字
+ * 串与数字同义（"2400"≡2400——YAML 弱型等价），但不可强转的错拼类必拦——防「宽容」变成
+ * 放过 FR 承诺要拦的坏值。缺文件=零配置可用 info exit 0（69 键仅 4 凭据键真必填且仅平台
+ * 用户——零配置契约锚）。
+ */
+import yaml from 'js-yaml'
+import { readFileSync } from 'fs'
+import { LOCAL_YAML_SCHEMA } from './config-schema.js'
+import { resolveLocalYaml } from './config-cat.js'
+
+/** schema 注册面索引：path→def、已知顶层键（段 id ∪ 无点 path）、含占位段的段（免未知键误报）。 */
+function buildRegistry() {
+  const byPath = new Map()
+  const sectionIds = new Set()
+  const rootScalars = new Set()
+  const placeholderSections = new Set()
+  for (const sec of LOCAL_YAML_SCHEMA.sections || []) {
+    sectionIds.add(sec.id)
+    for (const k of sec.keys || []) {
+      byPath.set(k.path, k)
+      if (!k.path.includes('.')) rootScalars.add(k.path)
+      if (/<[^>]+>/.test(k.path)) placeholderSections.add(sec.id)
+    }
+  }
+  return { byPath, sectionIds, knownTop: new Set([...sectionIds, ...rootScalars]), placeholderSections }
+}
+
+const kindOf = (v) => (v === null || v === undefined ? 'null' : Array.isArray(v) ? 'array' : typeof v)
+
+/** 类型检查（评审 P1 修正口径：可强转宽容、不可强转判错）——YAML 标量弱型下 24 与 "24"
+ * 同义（number/integer 收数字串合法），但 "abc" 这类不可强转错拼必须拦（FR-01 场景）；
+ * boolean 收非 true/false 串判错；string 收任意标量；结构错配（标量位收映射/数组）恒错。 */
+function checkType(def, v, path, errors) {
+  const kind = kindOf(v)
+  if (kind === 'null') return
+  const scalarSpot = ['string', 'number', 'integer', 'enum', 'boolean', 'json'].includes(def.type)
+  if (scalarSpot && (kind === 'object' || kind === 'array')) {
+    errors.push(`「${path}」期望${def.type === 'enum' ? `枚举（${(def.values || []).join('|')}）` : def.type}标量，实得 ${kind}——嵌套层级写错（该键是叶子值不是段）`)
+    return
+  }
+  if (def.type === 'object' && kind !== 'object') {
+    errors.push(`「${path}」期望键值映射，实得 ${kind}`)
+    return
+  }
+  if (def.type === 'array' && kind !== 'array') {
+    errors.push(`「${path}」期望列表，实得 ${kind}`)
+    return
+  }
+  if (def.type === 'enum' && !(def.values || []).map(String).includes(String(v))) {
+    errors.push(`「${path}」取值越界：${JSON.stringify(v)}（合法：${(def.values || []).join('|')}）`)
+    return
+  }
+  if ((def.type === 'number' || def.type === 'integer') && kind === 'string' && !/^-?\d+(\.\d+)?$/.test(v.trim())) {
+    errors.push(`「${path}」期望${def.type === 'integer' ? '整数' : '数字'}，实得字符串 ${JSON.stringify(v)}（不可强转——数字串可，纯文本不可）`)
+    return
+  }
+  if (def.type === 'integer' && kind === 'string' && !/^-?\d+$/.test(v.trim())) {
+    errors.push(`「${path}」期望整数，实得 ${JSON.stringify(v)}`)
+    return
+  }
+  if (def.type === 'boolean' && kind === 'string' && !/^(true|false)$/i.test(v.trim())) {
+    errors.push(`「${path}」期望布尔（true/false），实得 ${JSON.stringify(v)}`)
+  }
+}
+
+/**
+ * 校验 local.yaml 文本（纯函数）。@returns {{errors:string[], warnings:string[], infos:string[], keysChecked:number}}
+ */
+export function validateLocalYamlContent(text) {
+  const { byPath, knownTop, placeholderSections } = buildRegistry()
+  const errors = [], warnings = [], infos = []
+  let doc
+  try { doc = yaml.load(text) } catch (e) {
+    return { errors: [`YAML 解析失败：${(e && e.message) || e}——agent 手改易犯缩进/Tab/编码错（doctor 的 local_yaml_integrity 维度查编码）`], warnings, infos, keysChecked: 0 }
+  }
+  if (doc == null) doc = {}
+  const topKind = kindOf(doc)
+  if (topKind !== 'object') {
+    return { errors: [`local.yaml 顶层必须是键值映射（实得 ${topKind}）`], warnings, infos, keysChecked: 0 }
+  }
+  const sectionIds = new Set((LOCAL_YAML_SCHEMA.sections || []).map((s) => s.id))
+  let checked = 0
+  const checkDef = (def, v, path) => {
+    checked++
+    checkType(def, v, path, errors)
+    if (def.status === 'deprecated') infos.push(`「${path}」已退役（${String(def.desc || '').slice(0, 80)}…）——新配置勿再写`)
+  }
+  for (const [k, v] of Object.entries(doc)) {
+    if (!knownTop.has(k)) {
+      warnings.push(`未知顶层键「${k}」——sillyspec config schema 可查全部已知键（未知键大概率无效果；确认拼写与层级）`)
+      continue
+    }
+    if (sectionIds.has(k) && byPath.has(k) === false) {
+      // 纯段（如 project/commands）：校验段内键。两种真实形态：键值映射（commands.lint）
+      // 与列表-of-对象（review_probes 列表项字段建模为 sec.field 点路径——本仓 dogfood 实证）。
+      if (v == null) continue
+      const vKind = kindOf(v)
+      if (vKind !== 'object' && vKind !== 'array') { errors.push(`段「${k}」必须是键值映射或列表（实得 ${vKind}）`); continue }
+      const entries = vKind === 'array'
+        ? (v.every((it) => kindOf(it) === 'object') ? v.flatMap((it) => Object.entries(it)) : Object.entries(v[0] || {}))
+        : Object.entries(v)
+      for (const [ik, iv] of entries) {
+        const path = `${k}.${ik}`
+        const def = byPath.get(path)
+        if (!def) {
+          // 占位段（modules.<name>.path 族）：子键名是用户自定义 id，注册面无法穷举——
+          // 未知子键不警告（占位形态本身合法），具体叶子键校验交给占位 path 前缀匹配不到即跳过
+          if (!placeholderSections.has(k)) warnings.push(`「${path}」不在注册键表（可能拼错/层级错，或新版键未同步 schema——sillyspec config schema 核对）`)
+          continue
+        }
+        checkDef(def, iv, path)
+      }
+    } else {
+      // 根级标量键（test_strategy/module_gate_ignore/…）
+      const def = byPath.get(k)
+      if (!def) { warnings.push(`键「${k}」不在注册键表`); continue }
+      checkDef(def, v, k)
+    }
+  }
+  // 段内必填闭合（required:true 键所在段在场则须齐全——mcp/platform 凭据族两键成对才生效）
+  for (const sec of LOCAL_YAML_SCHEMA.sections || []) {
+    if (!(sec.id in doc) || doc[sec.id] == null || kindOf(doc[sec.id]) !== 'object') continue
+    for (const kd of sec.keys || []) {
+      if (kd.required !== true || !kd.path.startsWith(`${sec.id}.`)) continue
+      const leaf = kd.path.slice(sec.id.length + 1)
+      if (!(leaf in doc[sec.id])) {
+        errors.push(`段「${sec.id}」缺必填键「${leaf}」——${sec.id === 'mcp' || sec.id === 'platform' ? '凭据两键齐全才生效（缺半整段回退缺省/env）；补齐或整段删除' : '必填键'}`)
+      }
+    }
+  }
+  if (checked === 0 && errors.length === 0) infos.push('local.yaml 在场但无任何已注册键（空段/仅注释）——等于零配置形态')
+  return { errors, warnings, infos, keysChecked: checked }
+}
+
+/**
+ * config validate 子命令体：路径链解析（config-cat 同源，worktree 感知）→ 校验 → 人类/--json
+ * 双态渲染。退出码：0=通过（可含警告/info），1=有错误；缺文件=零配置 info exit 0。
+ */
+export function cmdConfigValidate({ dir, specBase = null, json = false } = {}) {
+  const r = resolveLocalYaml(dir, { specBase })
+  if (!r.exists) {
+    const payload = { file: null, exists: false, passed: true, errors: [], warnings: [], infos: ['local.yaml 不存在——零配置可用（全部键走缺省；仅平台/MCP 凭据族真必填）'], keysChecked: 0 }
+    if (json) console.log(JSON.stringify(payload, null, 2))
+    else console.log('✅ local.yaml 不存在——零配置可用（全部键走缺省；仅平台/MCP 凭据族真必填，需要时 sillyspec platform connect 一键写入）。\n   需要调优时：sillyspec config schema 查键 ＋ sillyspec-config 技能引导；写完跑 sillyspec config validate 验证。')
+    return 0
+  }
+  let v
+  try { v = validateLocalYamlContent(readFileSync(r.path, 'utf8')) } catch (e) {
+    // 读盘竞态兜底（评审 P3 清偿）：resolve 与 read 之间文件消失/被锁——优雅报错不裸崩
+    if (json) console.log(JSON.stringify({ file: r.path, exists: true, passed: false, errors: [`local.yaml 读取失败：${(e && e.message) || e}（可能刚被移动/删除——重跑）`], warnings: [], infos: [], keysChecked: 0 }, null, 2))
+    else console.error(`❌ local.yaml 读取失败：${(e && e.message) || e}（可能刚被移动/删除——重跑 sillyspec config validate）`)
+    return 1
+  }
+  const passed = v.errors.length === 0
+  if (json) {
+    console.log(JSON.stringify({ file: r.path, exists: true, passed, ...v }, null, 2))
+  } else {
+    console.log(`${passed ? '✅' : '❌'} local.yaml 校验${passed ? '通过' : '未通过'}（${r.path}${r.source ? `，来源 ${r.source}` : ''}；已查 ${v.keysChecked} 个注册键）`)
+    for (const e of v.errors) console.error(`   错误：${e}`)
+    for (const w of v.warnings) console.warn(`   警告：${w}`)
+    for (const i of v.infos) console.log(`   ℹ️ ${i}`)
+    if (passed && v.warnings.length === 0 && v.errors.length === 0) console.log('   无警告无未知键。')
+    if (!passed) console.error('   修复后重跑：sillyspec config validate（exit 0 才算配置完成——sillyspec-config 技能硬门）')
+  }
+  return passed ? 0 : 1
+}
+
+export default { validateLocalYamlContent, cmdConfigValidate }

package/src/flow-parity.js

@@ -522,6 +522,20 @@ export function detectPatchDrift({ cwd, change, freezeHead }) {
  * gate-snapshot 同款判定注入）时未提交 dirty 交付面一并入冻结——独占树内 dirty 全归属本变更；
  * 共享主仓无法归属 → 不入面只警告（他侧声明的 dirty 连警告都免）。
  */
+/**
+ * dirty_gate_ignore 读取（2026-10-23-dirty-gate-ignore，module_gate_ignore/readFlowConfig
+ * 同款逐键正则防线）：local.yaml 单行逗号串（目录/文件前缀，posix），列表块形态不支持。
+ * 三态 fail-soft——未配置/键值非法/local.yaml 不可读 → 空清单（dirty 门行为与现状逐字一致）。
+ */
+export function readDirtyGateIgnore(specBase) {
+  try {
+    const raw = readFileSync(join(specBase, 'local.yaml'), 'utf8')
+    const m = raw.match(/^\s*dirty_gate_ignore\s*:\s*(.+)$/m)
+    if (!m) return []
+    return m[1].split(',').map((s) => s.trim().replace(/\\/g, '/')).filter(Boolean)
+  } catch { return [] }
+}
+
 export function collectFreezeFiles({ cwd, specBase, change, committed, exclusive }) {
   const deliverable = (f) => !String(f).replace(/\\/g, '/').startsWith('.sillyspec/')
     && !isToolGovernancePath(f)
@@ -540,6 +554,12 @@ export function collectFreezeFiles({ cwd, specBase, change, committed, exclusive
       if (deliverable(path) && !dirty.includes(path)) dirty.push(path)
     }
   } catch { /* git 失败零 dirty 面 */ }
+  // 已知残渣前缀剔除（2026-10-23-dirty-gate-ignore，单一源）：仓主显式声明的残渣面
+  // （quicklog/、测试夹具运行库等）不进 dirty 冻结缺口——剔除进 dirtyIgnored 随返回值
+  // 留证（权威门打 ℹ️ 留痕行）；预检（flow-preflight.js）经本函数自动同源继承。
+  const ignorePrefixes = readDirtyGateIgnore(specBase)
+  const dirtyIgnored = ignorePrefixes.length > 0 ? dirty.filter((f) => ignorePrefixes.some((pfx) => f.startsWith(pfx))) : []
+  if (dirtyIgnored.length > 0) dirty = dirty.filter((f) => !dirtyIgnored.includes(f))
   // 归属切分单点：exclusive（worktree/--freeze-dirty）与共享主仓共用——他侧已声明 dirty 永不入冻
   // （评审 P2 修复：--freeze-dirty 承诺「非他侧声明」，全量冻入会造成跨变更审计双计；worktree
   // 下 own 恒为全量，切分无伤）
@@ -547,8 +567,8 @@ export function collectFreezeFiles({ cwd, specBase, change, committed, exclusive
   try {
     ownDirty = splitOwnVsForeignDiffFiles(cwd, change, dirty, { specBase }).own
   } catch { /* 归属切分失败：exclusive 保留全量（声明即边界），共享主仓退全量警告 */ }
-  if (exclusive) return { files: [...new Set([...committed, ...ownDirty])], dirtyAdded: ownDirty, dirtyWarned: [] }
-  return { files: [...committed], dirtyAdded: [], dirtyWarned: ownDirty }
+  if (exclusive) return { files: [...new Set([...committed, ...ownDirty])], dirtyAdded: ownDirty, dirtyWarned: [], dirtyIgnored }
+  return { files: [...committed], dirtyAdded: [], dirtyWarned: ownDirty, dirtyIgnored }
 }
 
 /**

package/src/flow-preflight.js

@@ -0,0 +1,67 @@
+/**
+ * flow-preflight.js — 收口预检（fail-together 一次报全，2026-10-23-flow-done-preflight）
+ *
+ * 背景（收口画像实证）：621 次 flow done 调用/255 变更=2.44 次/变更，净浪费 152 次 RTT（24.5%）
+ * 源于逐门 fail-fast 串行拒绝；dirty-gap 门在实测门之后——56% 触发率的门每次拦截都先付一轮
+ * 完整实测（58s 起、大仓分钟级）。
+ *
+ * 本模块是纯前移报告层：实测门前只读收集「独立可算的便宜阻断条件」，由 flow.js 侧渲染一次
+ * 报全后拦在付费实测之前。判定与权威门同源同判定（复用同一批函数而非重写），旗标与守卫
+ * 逐条镜像 patch 子步：
+ *   - dirty-gap 预判镜像 collectFreezeFiles dirtyWarned 非空 && !freezeDirty && !acceptDirtyGap
+ *     && !turbo（turbo 下权威门降 advisory，镜像不拦）
+ *   - orphan-face 预判镜像仅会话独占 worktree（shouldSkipGateSnapshotForWorktree）且
+ *     !acceptOrphanFace
+ *   - 守卫：baseline 缺席跳过（patch 子步整体跳过面）；patch 子步已 done 跳过——预检绝不
+ *     重复拦已过权威门的面（断点续不误拦）
+ *
+ * 放弃项（评审已裁决，见 design 风险与死路）：review.json schema 预验不做——schema 违规的
+ * 成本是「修正文件+重跑」一轮 RTT，与检测时点无关（同轮提前检测不省轮次）；且豁免轮
+ * （--no-review）权威门不读文件，预检先验会多拦权威门不拦的面（判定漂移），三路皆负。
+ *
+ * fail-safe 单向：预检异常静默放行（返回空 findings）——漏报由权威门兜底（仍在原子步原序），
+ * 预检不构成新失败面；全程零写盘（不落冻结件、不 mark 子步、不写 flow-state）。
+ */
+import { gitQuiet } from './git-helper.js'
+
+/**
+ * 收集收口预检阻断条件（纯计算零打印）。
+ * @returns {{ findings: Array<{id:'dirty-gap',count:number,files:string[]} | {id:'orphan-face',commits:string[],count:number,files:string[]}> }}
+ */
+export async function collectCloseoutPreflight({ cwd, specBase, change, st, freezeDirty = false, acceptDirtyGap = false, acceptOrphanFace = false, turbo = false }) {
+  const findings = []
+  const patchDone = st?.substeps?.patch === 'done'
+  // ── dirty-gap / orphan-face 预判（镜像 patch 子步判定链）──
+  if (!patchDone && st?.baseline_commit) {
+    try {
+      let exclusiveFrom = freezeDirty === true ? 'flag' : null
+      if (exclusiveFrom == null) {
+        try {
+          const { shouldSkipGateSnapshotForWorktree } = await import('./run/gate-snapshot.js')
+          if (shouldSkipGateSnapshotForWorktree(cwd)) exclusiveFrom = 'worktree'
+        } catch { /* 判定异常按共享主仓（权威门同款） */ }
+      }
+      const exclusive = exclusiveFrom != null
+      const committedRaw = String(gitQuiet(cwd, ['diff', '--name-only', `${st.baseline_commit}..HEAD`]) || '')
+        .split('\n').map((s) => s.trim().replace(/\\/g, '/')).filter(Boolean)
+      const { filterCommittedFace, collectFreezeFiles, scanOrphanFace } = await import('./flow-parity.js')
+      const ownPrefix = `.sillyspec/changes/${change}/`
+      const committed = filterCommittedFace(committedRaw, ownPrefix)
+      const freeze = collectFreezeFiles({ cwd, specBase, change, committed, exclusive })
+      if (freeze.dirtyWarned.length > 0 && !freezeDirty && !acceptDirtyGap && !turbo) {
+        findings.push({ id: 'dirty-gap', count: freeze.dirtyWarned.length, files: freeze.dirtyWarned })
+      }
+      if (exclusiveFrom === 'worktree' && !acceptOrphanFace) {
+        try {
+          const orphan = scanOrphanFace(cwd, { baseline: st.baseline_commit })
+          if (orphan.files.length > 0) {
+            findings.push({ id: 'orphan-face', commits: orphan.commits, count: orphan.files.length, files: orphan.files })
+          }
+        } catch { /* orphan 预判 fail-safe（权威门同款不阻断） */ }
+      }
+    } catch { /* 预检 fail-safe：异常静默放行（权威门仍在 patch 子步原序原判定） */ }
+  }
+  return { findings }
+}
+
+export default { collectCloseoutPreflight }

package/src/flow.js

@@ -83,14 +83,22 @@ export function readFlowConfig(specBase) {
     // module_gate_ignore（2026-10-12-thin-module-gate-and-feed）：未登记目录软门的固定忽略清单，
     // 单行逗号串（目录前缀，posix）——列表块形态不支持，readFlowConfig 同款逐键正则防线
     const ig = raw.match(/^\s*module_gate_ignore\s*:\s*(.+)$/m)
+    // turbo docs-auto 常设授权档（2026-10-23-turbo-docs-auto）：仓主一行声明纯文档面自动降档；
+    // 逐键正则同款防线，未配置/坏值（turbo: off 等）fail-soft 恒 false
+    const turboDocsAuto = /^\s*turbo\s*:\s*docs-auto\s*$/m.test(raw)
+    // review_inline_wait（2026-10-23-review-inline-dispatch）：薄道评审平台单调用通道的等待
+    // 预算秒数（1-600 正整数有效；缺省/坏值 0=off——回退现状任务书面零回归）
+    const riw = raw.match(/^\s*review_inline_wait\s*:\s*([0-9]+)\s*$/m)
     return {
       mode,
       editRatioThreshold: th ? Number(th[1]) : 0.5,
       editRatioEnforcement: en ? en[1] : 'advisory',
       moduleGateIgnore: ig ? ig[1].split(',').map((s) => s.trim()).filter(Boolean) : [],
+      turboDocsAuto,
+      reviewInlineWaitSeconds: riw ? Math.min(600, Math.max(0, Number(riw[1]))) : 0,
     }
   } catch {
-    return { mode: 'thin', editRatioThreshold: 0.5, editRatioEnforcement: 'advisory', moduleGateIgnore: [] }
+    return { mode: 'thin', editRatioThreshold: 0.5, editRatioEnforcement: 'advisory', moduleGateIgnore: [], turboDocsAuto: false, reviewInlineWaitSeconds: 0 }
   }
 }
 
@@ -630,7 +638,7 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
   const _localYaml = join(specBase, 'local.yaml')
   if (!existsSync(_localYaml) && !existsSync(join(specBase, 'changes', change))) {
     console.error('❌ local.yaml 不存在——先跑 sillyspec init（mode/lint/known_failures 等 init 级配置的落点）。')
-    console.error('   测试面无需在此配置（2026-09-26 起：测试门按变更动态推断——本变更测试 ∪ FR 关联回归 ∪ import 依赖，')
+    console.error('   测试面无需在此配置（测试门按变更动态推断——本变更测试 ∪ import 依赖；FR 关联回归层缺省不跑归 pre-push/CI 门（2026-10-23-fr-regress-default-off），fr_regress_cap: N|all 可开启，')
     console.error('   runner 自项目结构 pyproject/package.json 推断；modules.*.test/commands.test 已退役，后者仅显式 test_strategy: full 生效）。')
     process.exit(2)
   }
@@ -1158,6 +1166,7 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
     ``,
     `🛑 三断点纪律（顺序纪律：①未过不动码；②③为汇报点——用户没说「全跑完」就必须在每个断点向用户汇报并等确认）：`,
     `   ① spec 断点【机器门】：填完 FR 区和 design 四节后，把摘要给用户看（FR 条目+盲维作答+方案概述），`,
+    `      起草完先自查：sillyspec flow verify-drafts --change ${change}（与批准门同判定——自查通过再请批准，用户一次过）；`,
     `      用户确认后请其运行 sillyspec flow approve --change ${change}（批准留痕）再动手写代码——`,
     `      agent 代跑时如实声明通道：--user-confirmed（转述用户已确认）/ --self-approved（agent 自批），`,
     `      无 flag 按 unattested 留痕（审计面无法区分用户确认与自批）——2026-10-12-approve-channel-attest。`,
@@ -1268,7 +1277,35 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
   }
   // 极速模式读态（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'
+  // turbo 双源（2026-10-23-turbo-docs-auto）：旗标档（--turbo 用户显式）原样；未开且仓主常设
+  // 授权 turbo: docs-auto 时按面自动降档——面=changedFilesSinceBaseline（提交∪脏面）经
+  // dirty_gate_ignore 前缀剔除（与 dirty 门同一残渣口径）后非空且无文件命中代码分类器
+  // （quick-audit 单一源）。fail-closed：面空/含代码/读取或判定异常一律走全量（不静默降档）；
+  // 升厚即失效对双源同效（tier=thick 关）。授权权在仓主（local.yaml 一行），agent 仍无法自选。
+  const turboFlag = st.turbo === true && st.tier !== 'thick'
+  let turbo = turboFlag
+  let turboSource = turboFlag ? 'flag' : null
+  if (!turbo && st.tier !== 'thick') {
+    try {
+      if (readFlowConfig(specBase).turboDocsAuto === true) {
+        const { readDirtyGateIgnore } = await import('./flow-parity.js')
+        const { CODE_PATH_SEGMENT_RE, CODE_EXTENSION_RE } = await import('./run/quick-audit.js')
+        const ignorePfx = readDirtyGateIgnore(specBase)
+        const face = (changedFilesSinceBaseline(cwd, st.baseline_commit) || [])
+          .filter((f) => !ignorePfx.some((p) => f.startsWith(p)))
+        const docsOnly = face.length > 0 && !face.some((f) => CODE_PATH_SEGMENT_RE.test(f) || CODE_EXTENSION_RE.test(f))
+        if (docsOnly) {
+          turbo = true
+          turboSource = 'docs-auto'
+          console.log(`⚡ turbo(docs-auto)：提交/冻结面纯文档（${face.length} 文件）——实测/评审/UI 探针按极速档跳过（授权源 local.yaml turbo: docs-auto；升厚即失效）`)
+        }
+      }
+    } catch { /* 面判定异常 fail-closed 走全量 */ }
+  }
+  // 实测门 reason 的授权源标签（防文案漂移：docs-auto 档不得显示「用户显式触发」）
+  const turboLabel = turboSource === 'docs-auto'
+    ? 'local.yaml turbo: docs-auto 常设授权（提交/冻结面纯文档）'
+    : `用户显式触发 ${st.turbo_since || '时点未记'}`
   const runtimeRoot = resolveRuntimeRoot(runtimeRootOpt ? { runtimeRoot: runtimeRootOpt } : {}, specBase)
   // 归属收窄清单（2026-09-25-thin-dogfood-fixes 修复②）：baseline..HEAD 不分作者——并行会话在
   // start..done 之间的提交会混入本变更实测面与 FR 域路由。复用 verify 对账同款切分器：他侧显式
@@ -1377,7 +1414,7 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
         if (dr.applicable && dr.emptySlots.length > 0) {
           console.error(`❌ 设计记录未作答：design.md 有 ${dr.emptySlots.length} 个空 AGENT 槽（${dr.emptySlots.join('、')}）`)
           console.error(`   每节至少写一行（小改动可写「不适用：<理由>」）——设计承诺是评审与 FR 对账的锚点，空槽=承诺未落盘`)
-          console.error(`   恢复指引：槽标记（<!--AGENT:槽N）被删时，从 .runtime/step-guides/ 的指纹缓存可找骨架原文；或删 design.md 后重入 flow start 补生成（criteria 从 proposal 回提）`)
+          console.error(`   恢复指引：槽标记（<!--AGENT:槽N）被删时，骨架原文永存于 .runtime/state/draft-ledger-${change}.json 的 files["design.md"].text（draft-ledger 机器稿首版永存——2026-10-23 实证修正：step-guides/ 只有阶段指引，从未缓存 flow design 骨架，旧指引指向不存在的缓存）；从 ledger 取槽标记与问题行原样补回（作答放问题行之后——槽在问题行前会被当成答案）；或删 design.md 后重入 flow start 补生成（criteria 从 proposal 回提，注意会重置为骨架态）`)
           reportMidFail('artifacts')
           process.exit(1)
         }
@@ -1578,13 +1615,49 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
         }
       }
     } catch { /* 节奏门 best-effort：读流失败静默（fail-open——观测缺席不阻断） */ }
+    // ── 收口预检（fail-together 一次报全，2026-10-23-flow-done-preflight）：实测门前只读收集
+    //    便宜阻断条件（dirty-gap/orphan 预判）——56% 触发率的 dirty 门不再每轮先付完整实测；
+    //    命中即拦在付费实测之前，全部条件+处置出路一次报全（b1ab65b2「两条修复一次给全」
+    //    模式升格）。全过静默零行为变化；判定与权威门同源同旗标镜像（collectCloseoutPreflight
+    //    fail-safe：异常静默放行，权威门仍在原子步原序）。
+    {
+      const { collectCloseoutPreflight } = await import('./flow-preflight.js')
+      const pre = await collectCloseoutPreflight({ cwd, specBase, change, st, freezeDirty, acceptDirtyGap, acceptOrphanFace, turbo })
+      if (pre.findings.length > 0) {
+        console.error(`⛔ 收口预检未过——${pre.findings.length} 项阻断条件（fail-together 一次报全；实测未启动，处置后重跑同一条命令从断点续）：`)
+        for (const f of pre.findings) {
+          if (f.id === 'dirty-gap') {
+            // 逐字复用 patch 子步权威门文案（防两路口径漂移——文案即契约面）
+            console.error(`   ▸ ${f.count} 个未提交交付文件未入冻结面（共享主仓无法归属）——三选一：`)
+            console.error(`⛔ 未提交交付缺口未显式处置——收口阻断（不归档；处置后重跑同一条命令从断点续）：`)
+            console.error(`   ① git commit 这些文件（信息尾缀带 (${change}) 或 （${change}）），重跑本命令——冻结面自动并入`)
+            console.error(`   ② 全部归属本变更：flow done --change ${change} --freeze-dirty`)
+            console.error(`   ③ 接受审计缺口：flow done --change ${change} --accept-dirty-gap`)
+            console.error(`   💡 快速通道：脏文件全属并行会话在途/运行残渣且不在本变更交付面时，直接重跑带 --accept-dirty-gap（显式 pathspec 提交面已隔离归属；属本变更的文件必须走①提交）`)
+            console.error(`   ④ 已知残渣固定忽略：.sillyspec/local.yaml 加 dirty_gate_ignore: <目录前缀>（单行逗号分隔，同 module_gate_ignore）`)
+            console.error(`   ${f.files.slice(0, 3).join('、')}${f.files.length > 3 ? ' 等' : ''}`)
+          } else if (f.id === 'orphan-face') {
+            // 逐字复用 patch 子步权威门文案（防两路口径漂移——文案即契约面）
+            console.error(`   ▸ 会话专属 worktree 冻结面外交付改动——三选一：`)
+            console.error(`⛔ 会话专属 worktree 存在冻结面外交付改动：${f.commits.length} 个提交不在 HEAD 祖先链（patch-id 不等价）触及 ${f.count} 个交付文件——收口阻断（不归档；处置后重跑同一条命令从断点续）：`)
+            console.error(`   提交：${f.commits.slice(0, 5).map((c) => c.slice(0, 10)).join('、')}${f.commits.length > 5 ? ' 等' : ''}`)
+            console.error(`   文件：${f.files.slice(0, 5).join('、')}${f.files.length > 5 ? ' 等' : ''}`)
+            console.error(`   ① git rebase/cherry-pick 这些提交到 HEAD（补齐冻结面）后重跑`)
+            console.error(`   ② 确认放弃这些提交：清理对应分支/reflog 源后重跑`)
+            console.error(`   ③ 接受缺口留痕：flow done --change ${change} --accept-orphan-face`)
+          }
+        }
+        reportMidFail('patch')
+        process.exit(1)
+      }
+    }
     // 极速模式实测门跳过（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 } }
+      ? { action: 'skip', failed: [], reason: `⚡ 极速模式（${turboLabel}）——test+lint 实测跳过（审计留痕；本次收口不含测试客观核验）`, test: { status: 'skipped', command: null, exitCode: null, durationMs: null, outputTail: null, reason: `⚡ 极速模式（${turboLabel}）——本次收口不含测试客观核验（审计留痕）`, 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/归档）：`)
@@ -1902,6 +1975,11 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
         if (freeze.dirtyAdded.length > 0) {
           console.log(`🔒 ${exclusiveFrom === 'flag' ? '--freeze-dirty 显式声明' : '会话专属 worktree'}：${freeze.dirtyAdded.length} 个未提交交付文件一并入冻结面`)
         }
+        // 已知残渣剔除留痕（2026-10-23-dirty-gate-ignore）：collectFreezeFiles 单一源剔除
+        // dirty_gate_ignore 命中面——每轮一行可审计（配了什么、剔了几个），预检同源继承。
+        if (Array.isArray(freeze.dirtyIgnored) && freeze.dirtyIgnored.length > 0) {
+          console.log(`ℹ️ ${freeze.dirtyIgnored.length} 个 dirty 文件按 local.yaml dirty_gate_ignore 剔除（已知残渣面，不入冻结缺口）：${freeze.dirtyIgnored.slice(0, 3).join('、')}${freeze.dirtyIgnored.length > 3 ? ' 等' : ''}`)
+        }
         if (freeze.dirtyWarned.length > 0) {
           console.warn(`⚠️ ${freeze.dirtyWarned.length} 个未提交交付文件未入冻结面（共享主仓无法归属）——三选一：`)
           console.warn(`   ① 先提交这些文件（信息尾缀带变更名）后重跑 ② 确认全部归属本变更：重跑 flow done --freeze-dirty 并入冻结 ③ 确认接受审计缺口：重跑 flow done --accept-dirty-gap（缺口数随 change-patch.json 留痕）。Git 中间提交可归档后压扁（见收口指引）`)
@@ -1922,6 +2000,7 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
             console.error(`   ② 全部归属本变更：flow done --change ${change} --freeze-dirty`)
             console.error(`   ③ 接受审计缺口：flow done --change ${change} --accept-dirty-gap`)
             console.error(`   💡 快速通道：脏文件全属并行会话在途/运行残渣且不在本变更交付面时，直接重跑带 --accept-dirty-gap（显式 pathspec 提交面已隔离归属；属本变更的文件必须走①提交）`)
+            console.error(`   ④ 已知残渣固定忽略：.sillyspec/local.yaml 加 dirty_gate_ignore: <目录前缀>（单行逗号分隔，同 module_gate_ignore）`)
             reportMidFail('patch')
             process.exit(1)
           }
@@ -2351,6 +2430,41 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
       } catch { /* 无/坏 JSON → 保持 null（既有判定） */ }
     }
     const tier = classifyReviewNeed({ changeDir, input: null, patchText, editRatio: st.edit_ratio ?? null, reviewForce: st.review_force ?? null, change })
+    // 登记块单一源（2026-10-23-review-inline-dispatch）：子代理重跑路径与平台 inline 回收
+    // 路径同源消费——validateReviewJson+FAIL/P1 拦截+P2/P3 留债+PASS mark，无第二套判定。
+    const registerReviewOutcome = async () => {
+      const v = validateReviewJson(join(changeDir, 'review.json'))
+      if (!v.ok) {
+        console.error(`❌ review.json 校验失败（${v.errors.join('；')}）——按任务书 schema 修正后重跑`)
+        reviewOutcome = { required: true, sampled: tier.sampled, verdict: 'invalid' }
+        appendTelemetry(reviewOutcome) // 修评审 P2①
+        reportMidFail('review')
+        process.exit(1)
+      }
+      const p1s = (v.review.findings || []).filter((f) => /^P1$/i.test(String(f.severity || '')))
+      const others = (v.review.findings || []).filter((f) => !/^P1$/i.test(String(f.severity || '')))
+      if (v.review.verdict === 'FAIL' || p1s.length > 0) {
+        console.error(`❌ 独立评审未过（verdict=${v.review.verdict}，P1 发现 ${p1s.length} 项）——承诺与实现不一致，不许归档：`)
+        for (const f of [...p1s, ...others]) console.error(`   [${f.severity}] ${f.title} — ${f.evidence || ''}${f.location ? `（${f.location}）` : ''}`)
+        console.error(`   修复后删除 review.json 并重新执行评审任务书（起子代理重评），再重跑 flow done（断点续）`)
+        reviewOutcome = { required: true, sampled: tier.sampled, verdict: 'FAIL', findingsP1: p1s.length }
+        appendTelemetry(reviewOutcome) // 修评审 P2①：sampled+FAIL 恰是误豁免率校准的最关键信号
+        reportMidFail('review')
+        process.exit(1)
+      }
+      if (others.length > 0) {
+        console.warn(`⚠️ 评审非阻断发现 ${others.length} 项（P2/P3，随归档留档）：`)
+        for (const f of others) console.warn(`   [${f.severity}] ${f.title} — ${f.evidence || ''}`)
+        // 处置提示（2026-10-10-drift-review-governance-keep，坑 drift-review-governance-loop）：
+        // P2/P3 非阻断可留债归档；要修则修复面决定是否重评——只碰治理文件不动本变更
+        // requirements/design 的后缀提交触发治理面等价保留（评审保留+自动重冻结，零重评）；
+        // 触及交付面或承诺面才隔离重评（任务书带前轮 findings，复审只验修复+新增）。
+        console.warn(`   💡 处置参考：P2/P3 非阻断，可留债归档；要修——只碰治理文件（.sillyspec/**，不动本变更 requirements/design）的提交不触发重评；触及交付面或 requirements/design 需重评（复审只验修复+新增，非全量首评）`)
+      }
+      console.log(`✅ 独立评审通过（reviewer=${v.review.reviewer}${tier.sampled ? '，豁免抽查采样命中' : ''}）`)
+      reviewOutcome = { required: true, sampled: tier.sampled, verdict: 'PASS', findingsP1: 0 }
+      mark('review')
+    }
     if (!tier.required) {
       console.log(`⚖️ 评审豁免（低风险证据齐全）：${tier.exemptEvidence.join('；')}`)
       reviewOutcome = { required: false, sampled: false, verdict: 'exempt' }
@@ -2361,9 +2475,17 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
       // 不再被漂移重冻结误隔离（实测竞态修复）。rev-parse 失败传 null（任务书退引导形态）。
       let taskbookHead = null
       try { const h = gitQuiet(cwd, ['rev-parse', 'HEAD']); if (h && /^[0-9a-f]{7,40}$/i.test(String(h).trim())) taskbookHead = String(h).trim() } catch { /* best-effort */ }
-      // 派发纪律（2026-10-19-thin-review-dispatch-verbatim）：横幅是主会话派发时最先读到的通道，
-      // 明确「原样复制」——实测手写缩编会丢材料包（厚道 stage-review.js:803 同款指令的薄道对齐）。
-      console.log(`⚖️ 本变更需要独立评审（${tier.reasons.join('；')}）——评审任务书如下，任务书原样复制给子代理（勿自行改写增删）执行后重跑本命令：\n`)
+      // 平台单调用通道（2026-10-23-review-inline-dispatch）：review_inline_wait 键门控——键有效
+      // 先试 inline（派发→有界等待→回收→同调用登记，missing→PASS 往返消灭）；任何失败回退
+      // 现状任务书面（零治理损失）。键 off 时本分支与改动前逐字一致。
+      const inlineWaitSec = readFlowConfig(specBase).reviewInlineWaitSeconds
+      if (inlineWaitSec > 0) {
+        console.log(`⚖️ 本变更需要独立评审（${tier.reasons.join('；')}）——平台单调用通道已启用（review_inline_wait=${inlineWaitSec}s），先试 inline 派发：`)
+      } else {
+        // 派发纪律（2026-10-19-thin-review-dispatch-verbatim）：横幅是主会话派发时最先读到的通道，
+        // 明确「原样复制」——实测手写缩编会丢材料包（厚道 stage-review.js:803 同款指令的薄道对齐）。
+        console.log(`⚖️ 本变更需要独立评审（${tier.reasons.join('；')}）——评审任务书如下，任务书原样复制给子代理（勿自行改写增删）执行后重跑本命令：\n`)
+      }
       // 项目评审探针装配（2026-10-12-review-probe-injection）：local.yaml 数据驱动的项目特有
       // 必查面注入任务书（未配置零注入；装载告警/帽留痕 best-effort 提示，不阻断渲染）。
       let _probeLines = null
@@ -2403,43 +2525,39 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
         const _pack = assembleReviewPack({ changeDir, patchText, attribution: _attribution, testReceipt: _receipt })
         if (_pack && Array.isArray(_pack.lines) && _pack.lines.length > 0) _packLines = _pack.lines
       } catch { /* 材料包面 fail-soft：装配失败零注入 */ }
-      console.log(renderReviewerTaskbook({ change, changeDir, head: taskbookHead, probeLines: _probeLines, packLines: _packLines }))
-      reviewOutcome = { required: true, sampled: tier.sampled, verdict: 'missing' }
-      appendTelemetry(reviewOutcome) // 修评审 P2①：失败面先落账再 exit（校准信号不丢）
-      reportMidFail('review')
-      process.exit(1)
-    } else {
-      const v = validateReviewJson(join(changeDir, 'review.json'))
-      if (!v.ok) {
-        console.error(`❌ review.json 校验失败（${v.errors.join('；')}）——按任务书 schema 修正后重跑`)
-        reviewOutcome = { required: true, sampled: tier.sampled, verdict: 'invalid' }
-        appendTelemetry(reviewOutcome) // 修评审 P2①
-        reportMidFail('review')
-        process.exit(1)
+      const taskbookText = renderReviewerTaskbook({ change, changeDir, head: taskbookHead, probeLines: _probeLines, packLines: _packLines })
+      let inlineWritten = false
+      if (inlineWaitSec > 0) {
+        try {
+          const { runThinReviewInline } = await import('./review-dispatch.js')
+          const inline = await runThinReviewInline({
+            cwd, specBase, change, changeDir, taskbookText,
+            waitMs: Math.min(300_000, inlineWaitSec * 1000),
+            log: (m) => console.log(m),
+          })
+          if (inline.ok) {
+            console.log(`✅ 平台评审单调用回收（mission ${String(inline.missionId).slice(0, 8)}/worker ${String(inline.workerId).slice(0, 8)}，reviewer=platform-inline）——同调用登记结论（missing→PASS 往返消灭）`)
+            inlineWritten = true
+          } else {
+            console.log(`ℹ️ 平台评审单调用未回收：${inline.reason}——回退评审任务书面`)
+          }
+        } catch (e) {
+          console.log(`ℹ️ 平台评审单调用异常（${(e && e.message) || e}）——回退评审任务书面`)
+        }
       }
-      const p1s = (v.review.findings || []).filter((f) => /^P1$/i.test(String(f.severity || '')))
-      const others = (v.review.findings || []).filter((f) => !/^P1$/i.test(String(f.severity || '')))
-      if (v.review.verdict === 'FAIL' || p1s.length > 0) {
-        console.error(`❌ 独立评审未过（verdict=${v.review.verdict}，P1 发现 ${p1s.length} 项）——承诺与实现不一致，不许归档：`)
-        for (const f of [...p1s, ...others]) console.error(`   [${f.severity}] ${f.title} — ${f.evidence || ''}${f.location ? `（${f.location}）` : ''}`)
-        console.error(`   修复后删除 review.json 并重新执行评审任务书（起子代理重评），再重跑 flow done（断点续）`)
-        reviewOutcome = { required: true, sampled: tier.sampled, verdict: 'FAIL', findingsP1: p1s.length }
-        appendTelemetry(reviewOutcome) // 修评审 P2①：sampled+FAIL 恰是误豁免率校准的最关键信号
+      if (!inlineWritten) {
+        if (inlineWaitSec > 0) {
+          console.log(`⚖️ 回退评审任务书面——任务书原样复制给子代理（勿自行改写增删）执行后重跑本命令：\n`)
+        }
+        console.log(taskbookText)
+        reviewOutcome = { required: true, sampled: tier.sampled, verdict: 'missing' }
+        appendTelemetry(reviewOutcome) // 修评审 P2①：失败面先落账再 exit（校准信号不丢）
         reportMidFail('review')
         process.exit(1)
       }
-      if (others.length > 0) {
-        console.warn(`⚠️ 评审非阻断发现 ${others.length} 项（P2/P3，随归档留档）：`)
-        for (const f of others) console.warn(`   [${f.severity}] ${f.title} — ${f.evidence || ''}`)
-        // 处置提示（2026-10-10-drift-review-governance-keep，坑 drift-review-governance-loop）：
-        // P2/P3 非阻断可留债归档；要修则修复面决定是否重评——只碰治理文件不动本变更
-        // requirements/design 的后缀提交触发治理面等价保留（评审保留+自动重冻结，零重评）；
-        // 触及交付面或承诺面才隔离重评（任务书带前轮 findings，复审只验修复+新增）。
-        console.warn(`   💡 处置参考：P2/P3 非阻断，可留债归档；要修——只碰治理文件（.sillyspec/**，不动本变更 requirements/design）的提交不触发重评；触及交付面或 requirements/design 需重评（复审只验修复+新增，非全量首评）`)
-      }
-      console.log(`✅ 独立评审通过（reviewer=${v.review.reviewer}${tier.sampled ? '，豁免抽查采样命中' : ''}）`)
-      reviewOutcome = { required: true, sampled: tier.sampled, verdict: 'PASS', findingsP1: 0 }
-      mark('review')
+      await registerReviewOutcome()
+    } else {
+      await registerReviewOutcome()
     }
   }
 
@@ -2712,6 +2830,82 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
 }
 
 /** flow 命令族入口（index.js case 'flow' 接线）：flow start|done|amend-draft。 */
+/**
+ * spec 面完整性只读校验单一源（2026-10-23-flow-verify-drafts）：approve 批准门与
+ * verify-drafts 自查命令同判定同源——verifyFlowDrafts repair:false 只读轨（不做 design 问题行
+ * 自动回填，写盘修复属 done 面）+ ledger 机本位缺失降级（仅 v1 AGENT 槽形态跑空槽兜底）。
+ * 纯计算零打印：调用方各自渲染（approve 文案钉死既有形态，verify-drafts 按新面渲染）。
+ * 返回 { applicable, schema, violations, advisories, skipDesign, degraded, v1EmptySlots }。
+ */
+async function computeSpecFaceChecks({ changeDir, change, specBase, runtimeRootOpt = null }) {
+  const runtimeRoot = resolveRuntimeRoot(runtimeRootOpt ? { runtimeRoot: runtimeRootOpt } : {}, specBase)
+  const { verifyFlowDrafts, verifyDesignRecordFilled } = await import('./flow-draft.js')
+  const st = readFlowState(changeDir) || {}
+  const adoptedDesign = st.adopted_from === 'brainstorm' && existsSync(join(changeDir, 'design.md'))
+  const r = verifyFlowDrafts({ changeDir, change, runtimeRoot, skipDesign: adoptedDesign, repair: false })
+  const out = {
+    applicable: r.applicable === true, schema: r.schema || null,
+    violations: r.violations || [], advisories: r.advisories || [],
+    skipDesign: adoptedDesign, degraded: false, v1EmptySlots: [],
+  }
+  if (!r.applicable) {
+    // draft-ledger 机本位缺失（跨机/存量变更）：fail-open 降级——仅 v1（AGENT 槽形态）跑空槽
+    // 兜底；v2 纯 markdown 无 ledger 无法对锚校验，如实降级（不假装能查）。
+    out.degraded = true
+    let v1Text = null
+    try { v1Text = readFileSync(join(changeDir, 'design.md'), 'utf8') } catch { /* 无 design */ }
+    if (v1Text && /<!--AGENT:槽\d+/.test(v1Text)) {
+      const dr = verifyDesignRecordFilled({ changeDir })
+      if (dr.applicable) out.v1EmptySlots = dr.emptySlots
+    }
+  }
+  return out
+}
+
+/**
+ * flow verify-drafts（2026-10-23-flow-verify-drafts）：spec 面起草自查只读命令——起草完
+ * 先自查（与批准门同判定同源 computeSpecFaceChecks）、通过再请用户批准，把「用户跑 approve
+ * 被 exit 1 硬拒」的往返消灭在 agent 侧。零写盘、零状态副作用（通过≠批准——批准仍走 approve
+ * 留痕）。--json 与人类渲染同判定同退出码（对齐 flow status --json 双态同源先例）。
+ */
+async function cmdFlowVerifyDrafts({ change, cwd, specBase, runtimeRootOpt = null, json = false }) {
+  const changeDir = join(specBase, 'changes', change)
+  if (!existsSync(changeDir)) {
+    const msg = `❌ 变更不存在：${change}（flow verify-drafts 在 flow start 之后、approve 之前运行——起草面自查）`
+    if (json) console.log(JSON.stringify({ change, status: 'missing' }))
+    else console.error(msg)
+    process.exit(2)
+  }
+  const r = await computeSpecFaceChecks({ changeDir, change, specBase, runtimeRootOpt })
+  const hasViolations = r.applicable && r.violations.length > 0
+  const hasEmptySlots = r.degraded && r.v1EmptySlots.length > 0
+  const passed = !hasViolations && !hasEmptySlots
+  if (json) {
+    console.log(JSON.stringify({
+      change, passed, applicable: r.applicable, schema: r.schema,
+      violations: r.violations, advisories: r.advisories,
+      skipDesign: r.skipDesign, degraded: r.degraded, v1EmptySlots: r.v1EmptySlots,
+    }))
+    if (!passed) process.exit(1) // 与人类渲染同退出码（json 不分叉）
+  } else if (passed) {
+    for (const a of r.advisories) console.warn(`⚠️ [门柱漂移 advisory] ${a}（不阻断批准）`)
+    if (r.degraded) console.log(`ℹ️ 自查降级：draft-ledger 不在此机（.runtime 机本位/存量变更）——空槽兜底校验通过（v2 纯 markdown 无法对锚校验，如实降级）`)
+    console.log(`✅ spec 面自查通过（0 violations）——通过≠批准：请把摘要给用户看，用户确认后 sillyspec flow approve --change ${change}（批准留痕后动码）`)
+  } else {
+    for (const a of r.advisories) console.warn(`⚠️ [门柱漂移 advisory] ${a}（不阻断批准）`)
+    if (hasViolations) {
+      console.error(`❌ spec 面自查未通过——${r.violations.length} 处违规（与 flow approve 批准门同判定；一次全列，修复后重跑本命令）：`)
+      for (const v of r.violations) console.error(`   - ${v}`)
+    }
+    if (hasEmptySlots) {
+      console.error(`❌ spec 面自查未通过——design.md 有 ${r.v1EmptySlots.length} 个空 AGENT 槽（${r.v1EmptySlots.join('、')}）：每节至少一行（「不适用：<理由>」也算答）`)
+    }
+    console.error(`   修复后重跑：sillyspec flow verify-drafts --change ${change}——通过再请用户批准（flow approve），用户一次过`)
+    process.exit(1)
+  }
+  return { change, passed }
+}
+
 /**
  * flow approve（2026-10-04-thin-docs-v2 FR-06）：spec 断点用户批准留痕——用户确认 FR+design
  * 方案后运行；写 flow-state {spec_approved,spec_approved_at,spec_approved_by}。flow done 的
@@ -2747,11 +2941,10 @@ async function cmdFlowApprove({ change, cwd, specBase, by = null, channelFlag =
   // 面只读，不做 design 问题行自动回填（写盘修复属 done 面）。诚实边界：本门证明「答在批前」，
   // 不证明「答在码前」——时序证据路线已实证不可行（批量收口下 git 时间戳说谎，thin-order-canon
   // 四路调查），不做假装能拦的检查。
+  // 计算单一源 computeSpecFaceChecks（2026-10-23-flow-verify-drafts 抽取共享）——本块只保留
+  // approve 面的渲染与退出，文案与退出码逐字保持（既有测试零改动作回归锚）。
   {
-    const runtimeRoot = resolveRuntimeRoot({}, specBase)
-    const { verifyFlowDrafts, verifyDesignRecordFilled } = await import('./flow-draft.js')
-    const adoptedDesign = st.adopted_from === 'brainstorm' && existsSync(join(changeDir, 'design.md'))
-    const r = verifyFlowDrafts({ changeDir, change, runtimeRoot, skipDesign: adoptedDesign, repair: false })
+    const r = await computeSpecFaceChecks({ changeDir, change, specBase })
     for (const a of r.advisories || []) console.warn(`⚠️ [门柱漂移 advisory] ${a}（不阻断批准）`)
     if (r.applicable && r.violations.length > 0) {
       console.error(`❌ spec 断点未批准——文档未齐（批准是动码前置，先答 spec 面再批）：`)
@@ -2762,15 +2955,10 @@ async function cmdFlowApprove({ change, cwd, specBase, by = null, channelFlag =
     if (!r.applicable) {
       // draft-ledger 机本位缺失（跨机批准/存量变更）：fail-open 降级——仅 v1（AGENT 槽形态）跑
       // 空槽兜底；v2 纯 markdown 无 ledger 无法对锚校验，如实降级放行（不假装能查）。
-      let v1Text = null
-      try { v1Text = readFileSync(join(changeDir, 'design.md'), 'utf8') } catch { /* 无 design */ }
-      if (v1Text && /<!--AGENT:槽\d+/.test(v1Text)) {
-        const dr = verifyDesignRecordFilled({ changeDir })
-        if (dr.applicable && dr.emptySlots.length > 0) {
-          console.error(`❌ spec 断点未批准——design.md 有 ${dr.emptySlots.length} 个空 AGENT 槽（${dr.emptySlots.join('、')}）：每节至少一行（「不适用：<理由>」也算答）`)
-          console.error(`   作答齐备后重跑：sillyspec flow approve --change ${change} [--user-confirmed|--self-approved]`)
-          process.exit(1)
-        }
+      if (r.v1EmptySlots.length > 0) {
+        console.error(`❌ spec 断点未批准——design.md 有 ${r.v1EmptySlots.length} 个空 AGENT 槽（${r.v1EmptySlots.join('、')}）：每节至少一行（「不适用：<理由>」也算答）`)
+        console.error(`   作答齐备后重跑：sillyspec flow approve --change ${change} [--user-confirmed|--self-approved]`)
+        process.exit(1)
       }
       console.log(`ℹ️ 批准校验降级放行：draft-ledger 不在此机（.runtime 机本位/存量变更）——空槽兜底校验通过`)
     }
@@ -2962,6 +3150,15 @@ export async function cmdFlow(args, cwd, specDir = null, opts = {}) {
     await reportAgentLog(change, sub)
     return cmdFlowReject({ change, cwd, specBase, reason: getFlag('--reason') })
   }
+  if (sub === 'verify-drafts') {
+    // spec 面起草自查只读面（2026-10-23-flow-verify-drafts）：与批准门同判定同源——起草完先
+    // 自查、通过再请批准，用户被拒往返消灭在 agent 侧；零写盘零状态副作用。
+    const change = getFlag('--change')
+    if (!change) { console.error('❌ flow verify-drafts 需 --change <名>'); process.exit(2) }
+    validateChangeName(change)
+    await reportAgentLog(change, sub)
+    return cmdFlowVerifyDrafts({ change, cwd, specBase, runtimeRootOpt, json: jsonGlobal || hasFlag('--json') })
+  }
   if (sub === 'diff') {
     // 只读查询面（2026-10-13-flow-diff-cmd）：change 粒度文件统计双态口——与 status 同级自愿面
     const change = getFlag('--change')
@@ -3152,7 +3349,7 @@ 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 "<一句 10-30 字中文概括（首行即变更标题，硬区间 10-30 必须、建议 ~20 字）＋动机与背景详述＋独立一行『成功标准：』＋每行一条『- 可验证标准』>" [--thick|--with-tasks] [--no-prestage（hindsight 标记在场时声明需求已含决策，留痕放行）] | sillyspec flow done --change <名> | sillyspec flow status --change <名> [--json] | sillyspec flow diff --change <名> [--json]（只读文件统计）')
+  console.error('用法: sillyspec flow start --change <名> --input "<一句 10-30 字中文概括（首行即变更标题，硬区间 10-30 必须、建议 ~20 字）＋动机与背景详述＋独立一行『成功标准：』＋每行一条『- 可验证标准』>" [--thick|--with-tasks] [--no-prestage（hindsight 标记在场时声明需求已含决策，留痕放行）] | sillyspec flow done --change <名> | sillyspec flow status --change <名> [--json] | sillyspec flow verify-drafts --change <名> [--json]（spec 面只读自查，通过再请批准） | sillyspec flow diff --change <名> [--json]（只读文件统计）')
   console.error('      --input 可照抄形态（引号内换行合法）：')
   console.error('      sillyspec flow start --change <名> --input "<一句 10-30 字中文概括（首行即变更标题，硬区间 10-30 必须、建议 ~20 字）；随后动机与背景')
   console.error('')

package/src/index.js

@@ -5395,6 +5395,7 @@ SillySpec config — local.yaml 配置键速查
   sillyspec config known-failures list           列 known_failures 豁免键
   sillyspec config known-failures add <key…>     增豁免键（行级手术保注释、原子写；坏 YAML 拒改）
   sillyspec config known-failures remove <key…>  删豁免键（未命中静默忽略）
+  sillyspec config validate [--json]             逐键校验 local.yaml（错误 exit 1；缺文件=零配置可用 exit 0）
 
 说明:
   - 数据源：src/config-schema.js（唯一真相；reader 见各键「读取点」）
@@ -5436,6 +5437,17 @@ SillySpec config — local.yaml 配置键速查
         if (!content.endsWith('\n')) process.stdout.write('\n')
         break;
       }
+      // config validate（2026-10-23-config-validate-skill）：逐键校验（schema 单一源；YAML/
+      // 类型/枚举/段内必填凭据闭合，未知键警告）——agent 写完配置的硬验证门（技能末步=本命令
+      // exit 0 才算完成）；缺文件=零配置可用 info exit 0（69 键仅凭据族真必填）。
+      if (configSub === 'validate') {
+        let specBase = null
+        try { specBase = resolvePlatformSpecDir(dir, specDir) } catch { /* 同 cat：pointer 异常走祖先链 */ }
+        const { cmdConfigValidate } = await import('./config-validate.js')
+        const exitCode = cmdConfigValidate({ dir, specBase, json })
+        process.exitCode = exitCode
+        break;
+      }
       // config known-failures（2026-10-21-p0-p1-hardening FR-07 / dsh z2 实证：known_failures
       // 无 CLI 管理面 → agent 手改 local.yaml，PS5.1 编码把 50KB 文件写成 mojibake 等用户
       // 2h13m）。行级增删查：保注释、原子写、坏 YAML 拒改——消灭手改场景。
@@ -5456,10 +5468,10 @@ SillySpec config — local.yaml 配置键速查
         break;
       }
       if (!isSchema) {
-        const sug = didYouMean(configSub, ['schema', 'cat', 'known-failures']);
+        const sug = didYouMean(configSub, ['schema', 'cat', 'validate', 'known-failures']);
         console.error(`❌ 未知子命令: config ${configSub}`);
         if (sug) console.error(`   你是想输入「config ${sug}」吗？`);
-        console.error('用法: sillyspec config [schema|cat|known-failures] [--json]   打印配置键 / 读内容 / 管理 known_failures 键');
+        console.error('用法: sillyspec config [schema|cat|validate|known-failures] [--json]   打印配置键 / 读内容 / 校验 / 管理 known_failures 键');
         process.exit(2);
       }
       const { renderSchemaHuman, renderSchemaJson } = await import('./config-schema.js');

package/src/review-dispatch.js

@@ -436,6 +436,105 @@ export async function runReviewDispatch(opts = {}) {
   }
 }
 
+// ════════ 薄道评审平台单调用派发（2026-10-23-review-inline-dispatch）════════
+/**
+ * 薄道（thin flow）review 子步的平台单调用通道：flow done 评审缺席分支经 local.yaml
+ * review_inline_wait 键门控调用——薄道任务书（renderReviewerTaskbook 产物+平台产出方式
+ * 尾注，任务书生产权仍在 CLI）派发平台 readOnly worker，有界轮询至完成/超时，三通道
+ * 提取复用厚道 extractReviewFromArtifacts（JSON 对象提取与 schema 无关）+ 薄道
+ * validateReviewJson 同一源校验，通过才落 changeDir/review.json（reviewer=platform-inline
+ * 如实标注）——成功后调用方同调用继续登记子步，missing→PASS 往返消灭。
+ * 任何失败返回 {ok:false, reason}——调用方回退现状任务书面（零治理损失）。
+ * 不写 dispatch record（那是厚道跨命令异步形态；单调用在途态只随返回值与输出留痕）。
+ */
+export async function runThinReviewInline(opts = {}) {
+  const {
+    cwd = process.cwd(), specBase, change, changeDir, taskbookText,
+    waitMs = 60_000, pollIntervalMs = 5_000, budgetUsd = 1.0,
+    client = null, probe = null, log = null,
+  } = opts
+  const say = typeof log === 'function' ? log : () => {}
+  if (!specBase || !change || !changeDir || typeof taskbookText !== 'string' || !taskbookText.trim()) {
+    return { ok: false, reason: '缺少 specBase/change/changeDir/taskbookText' }
+  }
+  let cl = client
+  if (!cl) {
+    try {
+      const { SillyHubMcpClient } = await import('./sillyhub-mcp/client.js')
+      cl = new SillyHubMcpClient({ cwd })
+    } catch (e) {
+      return { ok: false, reason: `client 构建失败（${(e && e.message) || e}）` }
+    }
+  }
+  if (!cl || typeof cl.createMission !== 'function' || typeof cl.dispatchWorker !== 'function'
+    || typeof cl.listWorkers !== 'function' || typeof cl.getWorkerResult !== 'function') {
+    return { ok: false, reason: 'client 不具备平台派发接口（create/dispatch/list/result）' }
+  }
+  try {
+    const probeFn = probe || (await import('./dispatch/probe.js')).probeSillyHub
+    const pr = await probeFn({ client: cl, worktreePath: null, cwd })
+    if (!pr || pr.available !== true) {
+      return { ok: false, reason: `平台通道不可用（${pr && pr.reason ? pr.reason : 'probe 异常'}）` }
+    }
+    const objective = `轻量变更独立评审（${change}）——按任务书产出 review.json 结论`
+    const workerPrompt = taskbookText + '\n' + [
+      '',
+      '【平台通道产出方式（read_only 约束——覆盖上方「写到文件」指引）】',
+      '- 平台 worker 禁止写任何文件、禁止 git 操作：把完整 review.json 文本（上方 schema）作为产出返回。',
+      '- 优先放 artifacts（kind 含 review，content 字段放纯 JSON 文本）；宿主不支持 artifacts 时放回答正文首个 ```json 代码块（CLI 回收链三通道兜底）。',
+    ].join('\n')
+    const mission = await cl.createMission({ objective, orchestrationMode: 'external', budgetUsd })
+    const missionId = mission && mission.missionId
+    if (!missionId) return { ok: false, reason: 'create_mission 未返回 missionId' }
+    say(`🛰️ 平台评审已派发（mission ${String(missionId).slice(0, 8)}）——有界等待 ${Math.round(waitMs / 1000)}s（review_inline_wait）`)
+    let worker = null
+    try {
+      worker = await cl.dispatchWorker({ missionId, objective, readOnly: true, worktreePath: cwd, workerPrompt })
+    } catch (e) {
+      return { ok: false, reason: `dispatch_worker 异常（${(e && e.message) || e}）`, missionId }
+    }
+    const workerId = worker && worker.workerId
+    if (!workerId) return { ok: false, reason: 'dispatch_worker 未返回 workerId', missionId }
+    const deadline = Date.now() + Math.max(1000, waitMs)
+    let lastState = ''
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, Math.max(200, Math.min(pollIntervalMs, deadline - Date.now()))))
+      let w = null
+      try {
+        const workers = await cl.listWorkers(missionId)
+        w = Array.isArray(workers) ? workers.find((x) => x && (x.id === workerId || x.worker_id === workerId)) : null
+      } catch { /* 单次轮询抖动按在途继续（下轮重试） */ }
+      const st = w ? String(w.status || '') : 'unknown'
+      if (st !== lastState) {
+        say(`🛰️ 平台评审状态：${st}（剩 ${Math.max(0, Math.ceil((deadline - Date.now()) / 1000))}s）`)
+        lastState = st
+      }
+      if (st === 'failed' || st === 'killed') return { ok: false, reason: `worker 终态 ${st}`, missionId, workerId }
+      if (st === 'completed') {
+        const gr = await cl.getWorkerResult({ missionId, workerId })
+        const extracted = extractReviewFromArtifacts(gr && gr.artifacts, gr && gr.answer)
+        if (!extracted || typeof extracted !== 'object') {
+          return { ok: false, reason: 'worker completed 但三通道提取不到 review JSON（artifacts kind/文本、answer 正文）——平台 UI 可回看 mission', missionId, workerId }
+        }
+        // reviewer 如实标注（覆盖 worker 任意填法）；change 对齐本变更；其余字段产物原样不改写
+        const candidate = { ...extracted, change, reviewer: 'platform-inline' }
+        const reviewPath = join(changeDir, 'review.json')
+        writeAtomicSync(reviewPath, JSON.stringify(candidate, null, 2) + '\n')
+        const { validateReviewJson } = await import('./flow-review.js')
+        const v = validateReviewJson(reviewPath)
+        if (!v.ok) {
+          try { rmSync(reviewPath, { force: true }) } catch { /* 删件失败由下轮覆盖兜底 */ }
+          return { ok: false, reason: `提取的 review 不符薄道 schema（${v.errors.join('；')}）——原文可参考平台 mission UI`, missionId, workerId }
+        }
+        return { ok: true, missionId, workerId, reviewPath }
+      }
+    }
+    return { ok: false, reason: `等待 ${Math.round(waitMs / 1000)}s 未完成（在途 mission ${missionId} 可在平台 UI 回看；本轮回退任务书面）`, missionId, workerId }
+  } catch (e) {
+    return { ok: false, reason: `inline 派发异常（${(e && e.message) || String(e)}）` }
+  }
+}
+
 // ════════ 影子期派发（2026-09-18-ceremony-risk-pricing task-06 / FR-04 / D-007@v1 / R-04 / R-06）════════
 // 依据：design.md「总体方案 Phase 3」+「风险登记 R-04/R-06」+ plan.md「Wave 4」+ 全局硬约束 2。
 // 定位：S0/S1 轻档变更在明面轻仪主线外，后台静默派发重仪式独立评审**只记账不阻断**——

package/src/run/complete-handlers.js

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

package/src/run/quick-audit.js

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

package/src/verify-postcheck.js

@@ -2162,6 +2162,7 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
   // ① 本变更测试 ∪ ③ import 依赖（discoverModuleDependentTests）；② FR 关联回归（fail-open）。
   let depsAutoFiles = []
   let frPre = null
+  let frCapApplied = null
   if (strategy === 'dynamic' && !gitUnavailable) {
     try {
       depsAutoFiles = discoverModuleDependentTests({ cwd, changedFiles: lastChangedFiles, coveredCommands: [] })
@@ -2169,6 +2170,17 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
     try {
       frPre = collectFrLinkedTests({ specBase, changeName, changedFiles: lastChangedFiles, projectRoot: cwd })
     } catch { frPre = null }
+    // 帽在 frPre 产生点一次成型（2026-10-23-fr-regress-default-off）：决策空判/展示计数/执行
+    // 组面全用帽后面——单一时点单一口径（v2 缺省 0=off：FR 层不进面即不触发 dynamic-subset
+    // 空跑）；capApplied 随行传执行层出披露行（total=真实绑定面，防二次施帽口径失真）。
+    try {
+      const capVal = readFrRegressCap(specBase)
+      if (frPre && capVal !== null) {
+        const capped = applyFrRegressCap(frPre, capVal)
+        frPre = capped.fr
+        frCapApplied = capped.capApplied
+      }
+    } catch { /* 键读取 fail-soft=缺省 off */ }
   }
   const scopeFiles = frPre ? [...new Set([...depsAutoFiles, ...frPre.files])] : [...new Set(depsAutoFiles)]
   const action = decideVerifyTestAction({ strategy, scopeCount: scopeFiles.length, gitUnavailable })
@@ -2235,11 +2247,13 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
         incremental = computeIncrementalFace({ ledger, filesSince, fullFace: lastChangedFiles })
       }
     }
+    // frCount 展示口径随帽（2026-10-23-fr-regress-default-off）：frPre 已在产生点施帽——
+    // 展示计数/空判/执行同源（见上方帽一次成型注释）。
     const frCount = frPre && frPre.files.length ? frPre.files.length : 0
     if (incremental) {
       subsetInput = incremental.files
       console.log(`⚡ ${incremental.note}`)
-      console.log(`ℹ️ 动态测试子集（增量重跑档）：修复面三源重算（本变更测试 ∪ FR 关联回归 ∪ import 依赖），runner 自项目结构推断。恒全子集：local.yaml verify: test_rerun: full`)
+      console.log(`ℹ️ 动态测试子集（增量重跑档）：修复面三源重算（本变更测试 ∪ import 依赖；FR 关联回归层按 fr_regress_cap——缺省不跑归 pre-push/CI 门，2026-10-23-fr-regress-default-off），runner 自项目结构推断。恒全子集：local.yaml verify: test_rerun: full`)
       mainResult = runModuleSubset({ cwd, specBase, changeName, hits: [], knownFailures, changedFiles: subsetInput, frPre: null })
       if (mainResult && typeof mainResult === 'object') {
         mainResult.mode = 'incremental-rerun'
@@ -2248,8 +2262,8 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
           : `增量重跑通过：${incremental.note}`
       }
     } else {
-      console.log(`ℹ️ 动态测试子集（缺省）：本变更测试 ∪ FR 关联回归 ∪ import 依赖 = ${scopeFiles.length} 个（并集去重后的总数；分量 deps ${depsAutoFiles.length}${frCount ? ` + FR 绑定 ${frCount}` : ''}，重叠只计一次）；runner 自项目结构推断。显式 test_strategy: full 恢复全量`)
-      mainResult = runModuleSubset({ cwd, specBase, changeName, hits: [], knownFailures, changedFiles: lastChangedFiles, frPre, observability })
+      console.log(`ℹ️ 动态测试子集（缺省）：本变更测试 ∪ import 依赖${frCount ? ' ∪ FR 关联回归' : '（FR 关联回归层缺省不跑归 pre-push/CI 门——fr_regress_cap: N|all 可开启）'} = ${scopeFiles.length} 个（并集去重后的总数；分量 deps ${depsAutoFiles.length}${frCount ? ` + FR 绑定 ${frCount}` : ''}，重叠只计一次）；runner 自项目结构推断。显式 test_strategy: full 恢复全量`)
+      mainResult = runModuleSubset({ cwd, specBase, changeName, hits: [], knownFailures, changedFiles: lastChangedFiles, frPre, frCapApplied, observability })
     }
     // ledger 记账（无论增/全）：head=当前 HEAD（git 失败 null → 下轮自动回全子集）；失败批文件
     // 落账供下轮增量；passed 后 failedFiles 清空 → 下轮自然回全子集基线
@@ -2266,15 +2280,23 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
     } catch { /* 记账失败不阻断（下轮退化全子集） */ }
   } else {
     // —— dynamic-empty：变更与测试面零关系——
-    // 无自身测试、无 import 依赖测试、无 FR 关联绑定 → 不硬跑全量（防超时/预存失败面，
-    // 同旧 module 0 命中防误伤初衷）；全量覆盖请显式 test_strategy: full。
+    // 无自身测试、无 import 依赖测试（+FR 关联回归层：v2 缺省跳过或绑定面为空）→ 不硬跑
+    // 全量（防超时/预存失败面，同旧 module 0 命中防误伤初衷）；全量覆盖请显式 test_strategy: full。
+    // FR 层被帽跳过（frCapApplied 在场 total>0）≠「无绑定」——reason 如实陈述并打披露行
+    // （2026-10-23-fr-regress-default-off 评审 P1 修复：缺省跳过恒披露不静默）。
+    if (frCapApplied && frCapApplied.total > 0) {
+      console.log(`ℹ️ fr_regress_cap：FR 关联回归面 ${frCapApplied.kept}/${frCapApplied.total} 进实测面，其余 ${frCapApplied.total - frCapApplied.kept} 个归 pre-push/CI 门（可开启：local.yaml fr_regress_cap: <N|all>——N=前 N 个 / all=全跑旧行为；缺省不跑）`)
+    }
+    const frEmptyNote = frCapApplied && frCapApplied.total > 0
+      ? `FR 关联回归层被 fr_regress_cap 跳过（绑定 ${frCapApplied.total} 个未跑，归 pre-push/CI 门）`
+      : '无 FR 关联绑定'
     mainResult = {
       status: 'skipped',
       command: null,
       exitCode: null,
       durationMs: null,
       outputTail: null,
-      reason: `变更与测试面零关系（${lastChangedFiles.length} 个变更文件无自身测试、无 import 依赖测试、无 FR 关联绑定）——动态子集空，不硬跑全量（防超时/预存失败面）。全量覆盖请显式 test_strategy: full。` + eaNote,
+      reason: `变更与测试面零关系（${lastChangedFiles.length} 个变更文件无自身测试、无 import 依赖测试、${frEmptyNote}）——动态子集空，不硬跑全量（防超时/预存失败面）。全量覆盖请显式 test_strategy: full。` + eaNote,
       resultPath: null,
       mode: 'dynamic-empty',
       fallbackReason: null,
@@ -3349,7 +3371,44 @@ export function applyTraceResidual({ mainResult, action, cwd, specBase, changeNa
  * export 供直测（buildDepsBatches 同款先例——fixture 需真跑测试文件，不宜经
  * runVerifyTestCheck 全链只为断言组卷接线）。
  */
-export function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [], changedFiles = [], frPre = null, observability = null }) {
+/**
+ * fr_regress_cap 读取 v2（2026-10-23-fr-regress-default-off，缺省翻转：用户裁决「默认就不跑，
+ * 配置可以开启」）：缺省（无键）/坏值/不可读 → 0（off——FR 关联回归层本地不跑，归 pre-push/CI
+ * 门）；off → 0；N（1-2000 正整数）→ 前 N 个；all → null（无帽=旧行为，显式恢复全跑）。
+ * normalizeLineEndings CRLF 归一保留；轻量正则不引 yaml 依赖（extractTestCommand 同风格）。
+ */
+export function readFrRegressCap(specBase) {
+  try {
+    const raw = normalizeLineEndings(readFileSync(join(specBase, 'local.yaml'), 'utf8'))
+    const m = raw.match(/^[ \t]*fr_regress_cap:[ \t]*([^\n#]+?)[ \t]*(?:#.*)?$/m)
+    if (!m) return 0 // 缺省=off（v2 翻转）
+    const v = m[1].trim().replace(/^["']|["']$/g, '')
+    if (/^all$/i.test(v)) return null // 显式恢复旧行为（无帽整跑）
+    if (/^off$/i.test(v)) return 0
+    if (/^\d+$/.test(v)) {
+      const n = Number(v)
+      if (n >= 1 && n <= 2000) return n
+    }
+    return 0 // 坏值 fail-soft=新缺省 off
+  } catch { return 0 } // 不可读 fail-soft=新缺省 off
+}
+
+/**
+ * FR 回归面帽纯函数（2026-10-23-fr-regress-cap）：fr.files 超帽截前 N 个（现有稳定序）；
+ * cap=0（off）整层归零；null/undefined/帽内零截断 → 原对象零变化。返回 { fr, capApplied }，
+ * capApplied={kept,total}|null 供 loud 披露。下游（frLinked/frReport/优先面标记/批组卷）
+ * 从帽后面对象自然推导，无第二套口径。
+ */
+export function applyFrRegressCap(fr, cap) {
+  if (cap === null || cap === undefined || !fr || !Array.isArray(fr.files) || fr.files.length === 0) {
+    return { fr, capApplied: null }
+  }
+  if (cap === 0) return { fr: { ...fr, files: [] }, capApplied: { kept: 0, total: fr.files.length } }
+  if (fr.files.length <= cap) return { fr, capApplied: null }
+  return { fr: { ...fr, files: fr.files.slice(0, cap) }, capApplied: { kept: cap, total: fr.files.length } }
+}
+
+export function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [], changedFiles = [], frPre = null, frCapApplied = null, observability = null }) {
   const subsetStartedAt = Date.now()
   const perModule = hits.map(h => runOneModule(h.name, h.test, cwd, knownFailures))
   // 依赖测试伪模块（module-test-face-rot，2026-09-16 本会话实证）：硬编码模块测试清单不含
@@ -3365,6 +3424,17 @@ export function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures
   let fr = frPre
   if (!fr) {
     try { fr = collectFrLinkedTests({ specBase, changeName, changedFiles: changedFiles || [], projectRoot: cwd }) } catch { fr = null }
+    // 本地收集路径同样施帽（2026-10-23-fr-regress-default-off 单一口径：直调方/增量重跑未带
+    // frPre——v2 缺省 0=off，FR 层本地不跑归 pre-push/CI 门；all=null 无帽旧行为）。frPre 由
+    // 调用方在产生点施帽并随行带 frCapApplied（防二次施帽口径失真），本块不再重复施帽。
+    try {
+      const capVal = readFrRegressCap(specBase)
+      if (fr && capVal !== null) {
+        const capped = applyFrRegressCap(fr, capVal)
+        fr = capped.fr
+        frCapApplied = capped.capApplied
+      }
+    } catch { /* 键读取 fail-soft=缺省 off */ }
   }
   // 优先面全量口径（2026-10-06-fr-priority-overlap）：frLinked 只含与 deps 无重叠的「新增」
   // 绑定文件——重叠者此前拿不到优先权，仍按普通依赖受帽字母序弃置（resume-title 收口实测
@@ -3382,6 +3452,9 @@ export function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures
       console.warn(`⚠️ ${fr.unresolved.length} 个 FR 绑定测试路径无法自仓根解析（不入实测面）：${fr.unresolved.slice(0, 3).join('、')}${fr.unresolved.length > 3 ? ' 等' : ''}——sillyspec tests repair-paths 可修`)
     }
   }
+  if (frCapApplied) {
+    console.log(`ℹ️ fr_regress_cap：FR 关联回归面 ${frCapApplied.kept}/${frCapApplied.total} 进实测面，其余 ${frCapApplied.total - frCapApplied.kept} 个归 pre-push/CI 门（可开启：local.yaml fr_regress_cap: <N|all>——N=前 N 个 / all=全跑旧行为；缺省不跑）`)
+  }
   const depsAll = [...new Set([...deps, ...frLinked])].sort()
   let depsBatches = []
   if (depsAll.length > 0) {