sillyspec 3.28.11 → 3.28.13

package/src/verify-probes.js

@@ -24,7 +24,7 @@
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs'
 import { join, dirname, basename, resolve, isAbsolute } from 'path'
 import jsYaml from 'js-yaml'
-import { gitQuiet } from './git-helper.js'
+import { gitQuiet, unquoteGitPath } from './git-helper.js'
 import {
   FACTS_SCHEMA_VERSION, EVIDENCE_SLOT_HEADING, RECEIPT_SLOT_HEADING, parseEvidenceSlots,
 } from './verify-facts-schema.js'
@@ -32,6 +32,7 @@ import { parseFileChangeListDetailed } from './change-list.js'
 import { parseDecisions } from './decision-distill.js'
 import { parseAllowedPaths, parseRepo, parseRepoRegistry } from './stages/plan-postcheck.js'
 import { verifyApiParity, _readWorktreeMeta } from './contract-matrix.js'
+import { RECEIPT_SOURCE_CROSS_LAYER_RE as RECEIPT_CROSS_LAYER_RE, RECEIPT_SOURCE_UNIT_RE as RECEIPT_UNIT_RE, CLI_SMOKE_SOURCE_MARK as SMOKE_RECEIPT_SOURCE_MARK } from './change-risk-profile.js'
 import { splitOwnVsForeignDiffFiles } from './foreign-declared.js'
 import { resolveSpecDir, resolveRuntimeRoot, detectWorktreeSpecDrift } from './run/shared.js'
 
@@ -189,6 +190,768 @@ export function extractPayloadKeys(text) {
   return keys
 }
 
+// ── probe8 diff 源采集器（task-01，2026-09-18-probe8-direct-compare / D-001@v1：文件源从
+//    design 清单声明面切到 diff 实际面——三态 fallback 链 + 文件分类 + design 差集 advisory）──
+// 文件分类规则（Grill B-10）：.java→backend；.js/.jsx/.wxml/.vue→frontend（.vue 无条件
+// frontend，N-2）；.ts/.tsx 按目录启发式裁决——目录段词（驼峰拆词，只看目录部分、文件名不
+// 参与——classifyConsumerHints 段级匹配同哲学，'homepages.js' 文件名不命中 pages 段）含
+// routes/pages/components/models→frontend；含 controller/service/mapper/entity/dto/api（含
+// 常见复数形）→backend；目录两不中再看文件头 10 行含 @RequestMapping/@RestController/@Service
+// →backend；仍两不中→other。.css/.less/.json/.md/.sql 等→other。
+const PROBE8_FE_DIR_WORDS = new Set(['routes', 'pages', 'components', 'models'])
+const PROBE8_BE_DIR_WORDS = new Set(['controller', 'controllers', 'service', 'services', 'mapper', 'mappers', 'entity', 'entities', 'dto', 'dtos', 'api', 'apis'])
+const PROBE8_BE_HEAD_RE = /@(?:RequestMapping|RestController|Service)\b/
+
+/** 目录段词化（驼峰拆词 + 非字母数字切段；只取目录部分，根级文件无目录词） */
+function probe8DirWords(p) {
+  const posix = String(p || '').split('\\').join('/')
+  const cut = posix.lastIndexOf('/')
+  return (cut === -1 ? '' : posix.slice(0, cut))
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean)
+}
+
+/**
+ * probe8 文件分类（task-01，纯函数——采集器内部消费；task-02/03 经 collectProbe8DiffFiles 的
+ * fileClassification 字段消费，不直接引用本函数）。
+ * @param {string} filePath 仓根相对路径（反斜杠容忍）
+ * @param {string|null} [headText] 文件头文本（调用方传头 10 行；.ts/.tsx 目录启发式未裁决时消费）
+ * @returns {'frontend'|'backend'|'other'}
+ */
+function classifyProbe8FilePath(filePath, headText = null) {
+  const p = String(filePath || '').split('\\').join('/')
+  const lower = p.toLowerCase()
+  if (lower.endsWith('.java')) return 'backend'
+  if (/\.(js|jsx|wxml|vue)$/.test(lower)) return 'frontend'
+  if (/\.(ts|tsx)$/.test(lower)) {
+    const words = probe8DirWords(p)
+    if (words.some(w => PROBE8_FE_DIR_WORDS.has(w))) return 'frontend'
+    if (words.some(w => PROBE8_BE_DIR_WORDS.has(w))) return 'backend'
+    if (headText && PROBE8_BE_HEAD_RE.test(headText)) return 'backend'
+  }
+  return 'other'
+}
+
+/**
+ * collectProbe8DiffFiles——probe8 文件源 diff 实际面采集器（task-01，D-001@v1）。三态 fallback 链
+ * （各级 fail-open 不抛）：
+ *   ① diff——worktree 可用（_readWorktreeMeta 命中且 gitDir≠主仓 cwd；in-place-fallback/仓
+ *      已删的 meta 落回 ②）：gitQuiet 数组参数取 diff baseline..HEAD ∪ status --porcelain
+ *      （-uall 防目录折叠，同构先例 _resolveDiffFilesForParity，contract-matrix.js）；
+ *   ② in-place——worktree 缺失：主仓 diff HEAD~1..HEAD ∪ porcelain（含已提交窗口，Grill B-9）；
+ *   ③ design-list——主仓两路 git 取数全失败：退 design 清单声明面（parseFileChangeListDetailed）
+ *      + 模式注记「文件源=design 清单（diff 不可用）」（fail-open 不抛）。
+ * 跨仓双源直采（①②态启用，不 import run/ 目录）：parseRepoRegistry 读 local.yaml repos →
+ * 每注册仓根 git diff HEAD~1..HEAD ∪ porcelain（复刻 collectCrossRepoDiffRoots 只读口径，
+ * run/complete.js 同款）；仓根不存在/取数失败跳过不炸；产物仓根相对路径。
+ * design 差集（advisory，不参与对账不阻断）：design 清单有但 diff 面无的路径收 designOnlyPaths
+ * （跨仓条目带 cross-repo:<key>: 前缀消歧）；design-list 态文件源即清单面 → 差集恒空。
+ * 产物路径一律 unquoteGitPath + 正斜杠归一（quotepath=false 下仍防控制字符引号形态）。
+ * @param {{ cwd: string, changeName: string, specBase: string, repoKeys?: string[]|null }} args
+ * @returns {{ source: 'diff'|'in-place'|'design-list', fallbackMode: 'diff'|'in-place'|'design-list',
+ *   diffFiles: string[], fileClassification: {frontend: string[], backend: string[], other: string[]},
+ *   frontend: string[], backend: string[], other: string[], designOnlyPaths: string[], notes: string[] }}
+ */
+export function collectProbe8DiffFiles({ cwd, changeName, specBase, repoKeys = null }) {
+  const out = {
+    source: 'design-list', fallbackMode: 'design-list', diffFiles: [],
+    fileClassification: { frontend: [], backend: [], other: [] },
+    frontend: [], backend: [], other: [], designOnlyPaths: [], notes: [],
+  }
+  if (!cwd || !specBase || !changeName) {
+    out.notes.push('collectProbe8DiffFiles 入参缺失（cwd/specBase/changeName）——文件源空面')
+    return out
+  }
+
+  // 路径归一：剥外层引号 → unquoteGitPath 解码转义（八进制/\"/\\）→ 正斜杠归一
+  const normGitPath = (raw) => unquoteGitPath(String(raw || '').trim().replace(/^"|"$/g, '')).split('\\').join('/')
+  // porcelain 行：XY <path>（前 3 字符状态码，trim:false 保前导空格；重命名 old -> new 取 new）
+  // ——口径同 _resolveDiffFilesForParity（contract-matrix.js）
+  const fromPorcelain = (stOut) => {
+    const files = []
+    for (const line of String(stOut || '').split('\n')) {
+      if (!line || line.length < 4) continue
+      const p = line.slice(3).trim().split(' -> ').pop() || ''
+      if (p) files.push(normGitPath(p))
+    }
+    return files
+  }
+  // git 双源采集：diff --name-only ∪ status --porcelain -uall；两取数任一成功即 ok（全失败
+  // 返 null 交 fallback 链降级）；产物 Set 去重
+  const gitFace = (gitDir, diffSpec) => {
+    let ok = false
+    const files = new Set()
+    const d = gitQuiet(gitDir, ['diff', '--name-only', diffSpec], { timeout: 30000 })
+    if (d !== null) {
+      ok = true
+      for (const line of String(d).split('\n')) {
+        const f = normGitPath(line)
+        if (f) files.add(f)
+      }
+    }
+    const st = gitQuiet(gitDir, ['status', '--porcelain', '--untracked-files=all'], { timeout: 30000, trim: false })
+    if (st !== null) {
+      ok = true
+      for (const f of fromPorcelain(st)) files.add(f)
+    }
+    return ok ? [...files] : null
+  }
+
+  // ── 主仓三态 fallback ──
+  let source = null
+  let mainRoot = cwd
+  const mainFiles = []
+  const wt = _readWorktreeMeta(specBase, cwd, changeName)
+  if (wt && resolve(wt.gitDir) !== resolve(cwd)) {
+    // baseline 口径同 _resolveDiffFilesForParity：baselineCommit / actualBaseHash / baseHash
+    const diffBase = wt.meta.baselineCommit || wt.meta.actualBaseHash || wt.meta.baseHash
+    if (diffBase) {
+      const face = gitFace(wt.gitDir, `${diffBase}..HEAD`)
+      if (face) {
+        source = 'diff'
+        mainRoot = wt.gitDir
+        mainFiles.push(...face)
+        out.notes.push(`文件源=worktree diff（${diffBase.slice(0, 8)}..HEAD ∪ porcelain）`)
+      }
+    }
+  }
+  if (!source) {
+    // in-place（Grill B-9 含已提交窗口）：HEAD~1..HEAD ∪ porcelain（初提交仓 HEAD~1 不存在时
+    // 两取数全失败 → 落 design-list）
+    const face = gitFace(cwd, 'HEAD~1..HEAD')
+    if (face) {
+      source = 'in-place'
+      mainFiles.push(...face)
+      out.notes.push('文件源=in-place diff（HEAD~1..HEAD ∪ porcelain，含已提交窗口）')
+    }
+  }
+
+  // ── local.yaml 注册表（跨仓直采 + design 清单 repoKeys 解析共用；specBase/local.yaml 优先，
+  //    兼容 cwd/.sillyspec/local.yaml——runProbe8PayloadParity / collectCrossRepoDiffRoots 双读点合一）──
+  let registry = new Map()
+  try {
+    for (const yamlPath of [join(specBase, 'local.yaml'), join(cwd, '.sillyspec', 'local.yaml')]) {
+      if (!existsSync(yamlPath)) continue
+      registry = parseRepoRegistry(readFileSync(yamlPath, 'utf8'))
+      if (registry.size > 0) break
+    }
+  } catch { /* 注册表不可读 → 跨仓空面（fail-open） */ }
+  const repoRootOf = (raw) => (isAbsolute(raw) ? raw : resolve(cwd, raw))
+
+  // ── design 清单声明面（③态文件源 + 差集基准；NEW: 待建前缀剥除，probe1-new-prefix-miss 同款）──
+  const designPath = join(specBase, 'changes', changeName, 'design.md')
+  let designList = []
+  try {
+    if (existsSync(designPath)) designList = parseFileChangeListDetailed(designPath, { repoKeys: repoKeys || [...registry.keys()] })
+  } catch { designList = [] }
+  const designNorm = []
+  for (const e of designList) {
+    let p = String((e && e.path) || '').replace(/^NEW:\s*/, '').split('\\').join('/').trim()
+    let repo = (e && e.repo) || null
+    if (!p || p.startsWith('.sillyspec/')) continue
+    // 未注册跨仓前缀兜底识别（change-list 只对注册 key 落 e.repo）：前缀剥掉按路径启发式
+    // 分类 + 未注册注记（runProbe8 readEntry 同款现身原则，不静默吞）
+    if (!repo) {
+      const cr = p.match(/^cross-repo:([A-Za-z0-9_.\-]+):(.*)$/)
+      if (cr) {
+        p = cr[2]
+        out.notes.push(`repo「${cr[1]}」未在 local.yaml repos 注册——该仓文件不进 diff 面，按路径启发式分类`)
+      }
+    }
+    if (p) designNorm.push({ repo, path: p })
+  }
+
+  // ── 跨仓双源直采（diff/in-place 态；design-list 态文件源即清单面不直采）──
+  const fileEntries = [] // { path, roots[] }（roots = 文件头 10 行读取候选根，先主后次）
+  if (source === 'diff' || source === 'in-place') {
+    for (const f of mainFiles) fileEntries.push({ path: f, roots: [mainRoot] })
+    for (const [key, raw] of registry.entries()) {
+      try {
+        if (!raw) continue
+        const root = repoRootOf(raw)
+        if (!root || !existsSync(root) || resolve(root) === resolve(cwd)) continue // 主仓自身不重复计
+        const face = gitFace(root, 'HEAD~1..HEAD')
+        if (!face) { out.notes.push(`跨仓「${key}」diff 取数失败——跳过`); continue }
+        for (const f of face) fileEntries.push({ path: f, roots: [root] })
+      } catch { out.notes.push(`跨仓「${key}」采集异常——跳过`) }
+    }
+  } else {
+    out.notes.push('文件源=design 清单（diff 不可用）')
+    for (const e of designNorm) {
+      const roots = e.repo && registry.has(e.repo)
+        ? [repoRootOf(registry.get(e.repo))]
+        : [wt && resolve(wt.gitDir) !== resolve(cwd) ? wt.gitDir : null, cwd].filter(Boolean)
+      fileEntries.push({ path: e.path, roots })
+    }
+  }
+
+  // ── design 差集（advisory）：design 清单有但 diff 面无（design-list 态清单即面 → 恒空）──
+  if (source === 'diff' || source === 'in-place') {
+    // 主仓面直接对集合；跨仓面按 roots[0] 反查仓根对应的 fileEntries 集合（多仓同根退化为主
+    // 仓口径，advisory 可接受；未注册 repo 无根可查 → 其条目恒落 design-only，如实现身不静默吞）
+    const mainFace = new Set(mainFiles)
+    const faceByRoot = new Map()
+    const faceAt = (root) => {
+      const abs = resolve(root)
+      if (!faceByRoot.has(abs)) {
+        faceByRoot.set(abs, new Set(fileEntries.filter(fe => resolve(fe.roots[0]) === abs).map(fe => fe.path)))
+      }
+      return faceByRoot.get(abs)
+    }
+    for (const e of designNorm) {
+      if (e.repo) {
+        const face = registry.has(e.repo) ? faceAt(repoRootOf(registry.get(e.repo))) : new Set()
+        if (!face.has(e.path)) out.designOnlyPaths.push(`cross-repo:${e.repo}:${e.path}`)
+      } else if (!mainFace.has(e.path)) {
+        out.designOnlyPaths.push(e.path)
+      }
+    }
+  }
+
+  // ── 分类（.ts/.tsx 目录启发式未裁决时才读文件头 10 行，省 IO；读不到按无头处理）──
+  const head10 = (roots, relPath) => {
+    for (const r of roots || []) {
+      try { return readFileSync(join(r, relPath), 'utf8').split('\n').slice(0, 10).join('\n') } catch { /* 试下一根 */ }
+    }
+    return null
+  }
+  const cls = { frontend: [], backend: [], other: [] }
+  const seen = new Set()
+  for (const fe of fileEntries) {
+    if (seen.has(fe.path)) continue
+    seen.add(fe.path)
+    let c
+    if (/\.(ts|tsx)$/i.test(fe.path)) {
+      const words = probe8DirWords(fe.path)
+      const dirResolved = words.some(w => PROBE8_FE_DIR_WORDS.has(w) || PROBE8_BE_DIR_WORDS.has(w))
+      c = classifyProbe8FilePath(fe.path, dirResolved ? null : head10(fe.roots, fe.path))
+    } else {
+      c = classifyProbe8FilePath(fe.path)
+    }
+    cls[c].push(fe.path)
+  }
+  out.source = source || 'design-list'
+  out.fallbackMode = out.source
+  out.diffFiles = [...seen].sort()
+  out.frontend = cls.frontend
+  out.backend = cls.backend
+  out.other = cls.other
+  out.fileClassification = { frontend: cls.frontend, backend: cls.backend, other: cls.other }
+  out.designOnlyPaths.sort()
+  return out
+}
+
+// ── probe8 前端载荷字段提取器（task-02，2026-09-18-probe8-direct-compare / D-002@v1）──
+// 前端面从「单文件键集」（extractPayloadKeys）升级为「字段 + 首命中行号 + URL 关联素材」三元组，
+// 供 task-04 前端×后端直查对账。三后缀选匹配族（.js/.ts/.jsx/.tsx 基础四形态；.vue 追加
+// v-model/prop；.wxml 追加 value 插值/data- 前缀）；DTO 键仅收请求调用 8 行邻近窗口
+// （R-08/Grill B-5：全文件字面量键污染防线，窗口机制对齐 extractPayloadKeys）。
+// 请求调用定位族——词边界前置防 myDelete(/onSearch( 类标识符内误命中（EHS onDelete 形态）
+const PROBE8_REQUEST_CALL_RE = /\b(?:fetch|post|put|delete|getRequest|postRequest|putRequest|deleteRequest|search)\s*\(/
+// DTO 对象字面量起始键（{ key: 形态，{ 与键同行）；控制流/声明关键字经保留字 Set 排除
+const PROBE8_DTO_KEY_RE = /[{]\s*([a-zA-Z]\w+)\s*:/g
+const PROBE8_DTO_KEY_RESERVED = new Set([
+  'if', 'for', 'while', 'switch', 'return', 'function', 'const', 'let', 'var', 'new', 'typeof',
+  'await', 'try', 'catch', 'else', 'do', 'case', 'default', 'export', 'import', 'class',
+  'extends', 'super', 'this', 'null', 'undefined', 'true', 'false',
+])
+// js 族基础三正则（+ 上方 DTO 邻近窗口族）；带 g 供 matchAll（matchAll 不推进原正则 lastIndex）
+const PROBE8_FE_FORMDATA_RE = /formData\.([a-zA-Z]\w+)/g
+const PROBE8_FE_PAYLOAD_RE = /payload\.([a-zA-Z]\w+)/g
+const PROBE8_FE_NAME_RE = /name="(\w+)"/g
+// vue 追加：v-model 绑定值 + prop 属性值（(?<![:\w]) 排 vue 动态绑定 :prop= 与连写词内 prop=）
+const PROBE8_FE_VMODEL_RE = /v-model="(\w+)"/g
+const PROBE8_FE_PROP_RE = /(?<![:\w])prop="(\w+)"/g
+// wxml 追加：value 插值绑定值 + data- 前缀属性名（事件传参 data-xxx= 形态）
+const PROBE8_FE_WXML_VALUE_RE = /value="{{(\w+)}}"/g
+const PROBE8_FE_WXML_DATA_RE = /data-(\w+)=/g
+// URL 捕获：请求调用首参（引号/反引号/斜杠起始；变量首参不收，fail-visible 保守面）
+const PROBE8_URL_CALL_RE = /\b(?:fetch|post|put|delete|getRequest|postRequest|putRequest|deleteRequest|search)\s*\(\s*['"`/]([^'"`,\s]+)/g
+
+/** 字段名归一：snake_case → lowerCamel（_x → X，_ 后随字母数字大写化） */
+const camelProbe8Field = (s) => String(s || '').replace(/_([A-Za-z0-9])/g, (_, c) => c.toUpperCase())
+
+/** URL 归一化三步：去 ?query → 去首 /api/ 前缀 → 去尾斜杠（task-04 段边界匹配消费口径） */
+const normalizeProbe8Url = (u) => String(u || '')
+  .split('?')[0]
+  .replace(/^\/?api\//, '')
+  .replace(/\/+$/, '')
+
+/**
+ * 段边界后缀匹配（task-02）：前端归一 URL 是否为后端完整 path 的路径段边界后缀——
+ * backendPath === frontendUrl ‖ 以 '/'+frontendUrl 收尾 ‖ 以 frontendUrl+'/' 收尾。
+ * 段首对齐：'/orders' 命中 '/api/v1/orders' 不命中 '/rporders'（裸 endsWith 的段中假阳防线）。
+ * @param {string} frontendUrl 前端归一 URL
+ * @param {string} backendPath 后端完整 path（类级+方法级 @RequestMapping 拼接形态）
+ * @returns {boolean}
+ */
+export function isSegmentSuffix(frontendUrl, backendPath) {
+  // 前后都归一去前导/尾随斜杠再比——修前导斜杠缺口（task-06 发现：'/' + '/orders'
+  // 拼成 '//orders' 永不命中，非 /api/ 前缀前端 URL 对 /api 前缀后端端点静默失联）
+  const fe = String(frontendUrl || '').trim().replace(/^\/+|\/+$/g, '')
+  const be = String(backendPath || '').trim().replace(/^\/+|\/+$/g, '')
+  if (!fe || !be) return false
+  return be === fe || be.endsWith('/' + fe)
+}
+
+/**
+ * extractFrontendPayloadFields——前端载荷构造点字段提取（task-02）。
+ *   - 逃生门：文件前 5 行任意一行含 probe8-skip → escapeHatch=true 整文件跳过
+ *     （probe9-skip 文件级豁免同款先例；不限定注释形态——js/vue/wxml 注释语法各异）。
+ *   - fields：归一（snake→lowerCamel）后字段名数组（首命中序，Set 语义去重）；
+ *   - fieldLines：Map<归一字段, 首命中行号（1-based，多族命中取最小行号）>——task-04
+ *     driftWarnings 行号来源；
+ *   - urlsByCall：{ url, normalizedUrl, line }[] 逐请求调用记录——无 URL 文件产出空数组
+ *     （未关联端点面处置归 task-04）。
+ * 三后缀之外的文件返回空面（escapeHatch=false）。
+ * @param {string} filePath 仓根相对路径（反斜杠/大小写容忍）
+ * @param {string} content 文件全文
+ * @returns {{ escapeHatch: boolean, fields: string[], fieldLines: Map<string, number>,
+ *   urlsByCall: Array<{ url: string, normalizedUrl: string, line: number}> }}
+ */
+export function extractFrontendPayloadFields(filePath, content) {
+  const text = String(content || '')
+  // 前 5 行逃生门（slice(0,5) 即第 1-5 行）
+  if (text.split('\n').slice(0, 5).some(l => l.includes('probe8-skip'))) {
+    return { escapeHatch: true, fields: [], fieldLines: new Map(), urlsByCall: [] }
+  }
+  const p = String(filePath || '').split('\\').join('/').toLowerCase()
+  const isJs = /\.(?:js|ts|jsx|tsx)$/.test(p)
+  const isVue = p.endsWith('.vue')
+  const isWxml = p.endsWith('.wxml')
+  if (!isJs && !isVue && !isWxml) {
+    return { escapeHatch: false, fields: [], fieldLines: new Map(), urlsByCall: [] }
+  }
+
+  const lines = text.split('\n')
+  const fieldLines = new Map() // 归一字段 → 首命中行号（行级族与 DTO 族独立扫描，合并取最小）
+  const record = (raw, line) => {
+    const f = camelProbe8Field(raw)
+    if (!f) return
+    const prev = fieldLines.get(f)
+    if (prev === undefined || line < prev) fieldLines.set(f, line)
+  }
+
+  // ── 行级匹配族：js 基础三正则（formData./payload./name=）+ vue/wxml 追加族 ──
+  const lineRes = [PROBE8_FE_FORMDATA_RE, PROBE8_FE_PAYLOAD_RE, PROBE8_FE_NAME_RE]
+  if (isVue) lineRes.push(PROBE8_FE_VMODEL_RE, PROBE8_FE_PROP_RE)
+  if (isWxml) lineRes.push(PROBE8_FE_WXML_VALUE_RE, PROBE8_FE_WXML_DATA_RE)
+  for (let i = 0; i < lines.length; i++) {
+    for (const re of lineRes) {
+      for (const m of lines[i].matchAll(re)) record(m[1], i + 1)
+    }
+  }
+
+  // ── 请求调用：调用行起 8 行窗口 DTO 键（窗口口径对齐 extractPayloadKeys）+ 首参 URL 捕获 ──
+  const urlsByCall = []
+  for (let i = 0; i < lines.length; i++) {
+    if (!PROBE8_REQUEST_CALL_RE.test(lines[i])) continue
+    for (let j = i; j < Math.min(i + 8, lines.length); j++) {
+      for (const m of lines[j].matchAll(PROBE8_DTO_KEY_RE)) {
+        if (!PROBE8_DTO_KEY_RESERVED.has(m[1])) record(m[1], j + 1)
+      }
+    }
+    for (const um of lines[i].matchAll(PROBE8_URL_CALL_RE)) {
+      urlsByCall.push({ url: um[1], normalizedUrl: normalizeProbe8Url(um[1]), line: i + 1 })
+    }
+  }
+  return { escapeHatch: false, fields: [...fieldLines.keys()], fieldLines, urlsByCall }
+}
+
+// ── probe8 后端字段两趟提取器（task-03，2026-09-18-probe8-direct-compare / D-003@v1）──
+// 后端面两趟结构（Grill B-4——@RequestBody 类型名跨文件解析，单文件签名不可行）：一趟 Controller
+// 定位（类级 @RequestMapping 前缀 × 方法级动词注解 path 拼接完整端点）+ 方法签名区参数提取
+// （Grill B-3 修正正则）；二趟 @RequestBody 类型名经 resolveTypeContent 全仓回调解析出字段集
+// （R-07——变更不动实体时不再全量假阳：只解析被引用类型非全仓字段；全仓性体现在检索面由回调
+// 承担）。函数本体零文件系统 IO（纯函数可测）——全仓检索经回调注入，工厂 createTypeResolver
+// 另行导出供调用侧组装（task-05 接线）。
+// 类级前缀：@RequestMapping(value = "/x") 且位置在 class 声明前（首个命中）
+const PROBE8_CLASS_PREFIX_RE = /@RequestMapping\(\s*(?:value\s*=\s*)?["']([^"']+)["']/
+// class 声明锚（前缀只认首个 class/interface/enum 声明之前；方法级注解按 index 与之比较）
+const PROBE8_CLASS_DECL_RE = /\b(?:class|interface|enum)\s+\w+/
+// 含任一 mapping 注解 → 本文件进一趟端点提取（service/entity 的 .java 不含，天然排除）
+const PROBE8_CONTROLLER_RE = /@(?:RequestMapping|GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping)\b/
+// 方法级端点（动词组含 Request → 无动词时 'REQUEST'）：注解 path → 注解余段 [^)]* → 方法签名
+// 可见性修饰符。m[2]=方法子路径；m[0] 尾部止于可见性修饰符后（签名区起点 = m.index+m[0].length）
+const PROBE8_METHOD_MAPPING_RE = /@(Get|Post|Put|Delete|Patch|Request)Mapping\(\s*(?:value\s*=\s*)?["']([^"']+)["'][^)]*\)\s*(?:public|protected|private)\s+/g
+// 方法参数三注解（Grill B-3 修正——捕获组 2=参数名：可选注解参数串 + 可选 final + 泛型/数组
+// 类型（Grill F-6——String[]/List<String> 方括号泛型边界不误捕）+ 最后一个标识符；@RequestParam
+// 注解参数串含 required=false → 该参数非必填）
+const PROBE8_REQUEST_PARAM_RE = /@RequestParam\s*(?:\(([^)]*)\))?\s+(?:final\s+)?(?:\w+(?:<[^>]+>)?(?:\[\])?)\s+(\w+)/g
+// @RequestParam 注解显式 value 名命中时参数名取它（括号紧邻裸串或 value= 形态；defaultValue=
+// 等其他键不命中——括号紧邻约束保证）
+const PROBE8_REQUEST_PARAM_VALUE_RE = /@RequestParam\(\s*(?:value\s*=\s*)?["'](\w+)["']/
+const PROBE8_REQUIRED_FALSE_RE = /required\s*=\s*false/
+const PROBE8_PATH_VARIABLE_RE = /@PathVariable\s+(?:final\s+)?(?:\w+\s+)?(\w+)/g
+const PROBE8_REQUEST_BODY_RE = /@RequestBody\s+(?:final\s+)?(\w+)/g
+// 必填形态①（D-003）：校验注解行起向下 5 行窗口内首个 private 字段声明
+const PROBE8_NOT_NULL_RE = /@(?:NotNull|NotBlank|NotEmpty)\b/
+const PROBE8_PRIVATE_FIELD_RE = /private\s+\w+(?:<[^>]+>)?(?:\[\])?\s+(\w+)\s*;/
+// 必填形态③：方法体前 30 行校验调用三模式（StringBlankValidator 首参 / Valid.valid 同行或
+// 上一行字段名 / if 判空字段名）
+const PROBE8_SBV_RE = /StringBlankValidator\s*\(\s*["'](\w+)["']/
+const PROBE8_VALID_LINE_RE = /\bValid\.valid/
+const PROBE8_VALID_ARG_RE = /\bValid\.valid\w*\(\s*(\w+)/
+// 上一行标识符宽收（形态③「上一行字段名」落点）：小写起始 + 不紧邻 `(`（排调用名）+ 停用词集
+const PROBE8_VALID_IDENT_RE = /\b([a-z][A-Za-z0-9]*)\b(?!\s*\()/g
+const PROBE8_VALID_IDENT_STOP = new Set([
+  'valid', 'final', 'new', 'return', 'if', 'else', 'while', 'for', 'switch', 'case', 'catch',
+  'null', 'true', 'false', 'this', 'super', 'static', 'public', 'private', 'protected',
+  'string', 'integer', 'int', 'long', 'double', 'float', 'boolean', 'date', 'object',
+])
+const PROBE8_IF_NULL_RE = /if\s*\(\s*(\w+)\s*==\s*null/
+// 实体/dto 文件形（diff 面直接解析不依赖 @RequestBody 引用链）
+const PROBE8_ENTITY_CLASS_RE = /class\s+\w+\s*(?:extends|implements|\{)/
+
+/** 端点 path 拼接：prefix × 方法子路径，去重复 /（"/api/" + "/add" → "/api/add"） */
+function joinProbe8Path(prefix, methodPath) {
+  const p = String(prefix || '')
+  const m = String(methodPath || '')
+  if (!p) return m
+  if (!m) return p
+  return (p.endsWith('/') ? p.slice(0, -1) : p) + (m.startsWith('/') ? m : '/' + m)
+}
+
+/** private 字段声明名集（二趟 DTO / diff 面实体共用；g 正则局部化 matchAll，无共享 lastIndex 风险） */
+function probe8PrivateFieldNames(content) {
+  const out = new Set()
+  for (const m of String(content || '').matchAll(/private\s+\w+(?:<[^>]+>)?(?:\[\])?\s+(\w+)\s*;/g)) out.add(m[1])
+  return out
+}
+
+/** 必填形态①（D-003）：@(NotNull|NotBlank|NotEmpty) 行起向下 5 行窗口内首个 private 字段声明名集 */
+function probe8NotNullFields(content) {
+  const lines = String(content || '').split('\n')
+  const out = new Set()
+  for (let i = 0; i < lines.length; i++) {
+    if (!PROBE8_NOT_NULL_RE.test(lines[i])) continue
+    for (let j = i; j < Math.min(i + 5, lines.length); j++) {
+      const fm = lines[j].match(PROBE8_PRIVATE_FIELD_RE)
+      if (fm) { out.add(fm[1]); break }
+    }
+  }
+  return out
+}
+
+/**
+ * 必填形态③（D-003）：方法体前 30 行校验调用三模式字段名集——
+ * StringBlankValidator("x") 首参 / Valid.valid 同行首参 + 上一行标识符宽收（R-02 宁多勿漏）/
+ * if (x == null) 判空字段。
+ */
+function probe8BodyCheckFields(winLines) {
+  const out = new Set()
+  for (let k = 0; k < winLines.length; k++) {
+    const line = winLines[k]
+    const sbv = line.match(PROBE8_SBV_RE)
+    if (sbv) out.add(sbv[1])
+    const ifn = line.match(PROBE8_IF_NULL_RE)
+    if (ifn) out.add(ifn[1])
+    if (PROBE8_VALID_LINE_RE.test(line)) {
+      const arg = line.match(PROBE8_VALID_ARG_RE)
+      if (arg) out.add(arg[1])
+      if (k > 0) {
+        for (const idm of winLines[k - 1].matchAll(PROBE8_VALID_IDENT_RE)) {
+          if (!PROBE8_VALID_IDENT_STOP.has(idm[1])) out.add(idm[1])
+        }
+      }
+    }
+  }
+  return out
+}
+
+/**
+ * extractBackendFields——后端面两趟提取（task-03，D-003@v1）。
+ *   - 逃生门：文件前 5 行任意一行含 probe8-skip → escapeHatchCount++ 整文件跳过（与前端
+ *     task-02 同门，不限定注释形态；优先于非 Java 判定——hatch 是整文件主动退出）；
+ *   - 非 Java：分类面 backend 但非 .java（目录启发式命中的 .ts 等）→ nonJavaSkipCount++；
+ *   - 一趟 Controller（含六个 mapping 注解任一）：类级 @RequestMapping 前缀 × 方法级动词注解
+ *     path 拼接完整端点（去重复 /）；方法级 @RequestMapping → method='REQUEST'；prefix 存在
+ *     但零方法级端点 → 类级通配 {prefix, 'REQUEST'}；方法签名区（注解尾至方法体首 `{`）提取
+ *     @RequestParam（三态：正常参数名 / required=false 非必填 / value 注解显式名）/ @PathVariable
+ *     （URL 段参数，非载荷字段只进参数集）/ @RequestBody（类型名收二趟待解析集）；
+ *   - 必填三形态（D-003）：①校验注解 5 行窗口（二趟类型内容上扫，命中归引用该类型的端点）；
+ *     ②@RequestParam 排除 required=false 后全必填（Spring 缺省 true）；③方法体前 30 行校验
+ *     调用三模式；
+ *   - 二趟：@RequestBody 类型名经 resolveTypeContent(typeName) 全仓回调解析（返 null / 抛错
+ *     均 fail-soft 不炸）→ private 字段集 = 端点 bodyFields（并入 entityFields）+ ①必填扫描；
+ *     diff 面非 Controller 实体文件（class 声明形）直接解析（不依赖 @RequestBody 引用链）；
+ *   - backendAllFields = 二趟类型字段 ∪ 一趟 Controller 方法参数名 ∪ diff 面实体字段
+ *     （全仓并集非仅 diff 面，Grill B-7）。
+ * @param {Array<{path: string, content: string}>} files 分类面 backend 文件集
+ * @param {(typeName: string) => string|null} [resolveTypeContent] 二趟全仓类型定义查找回调
+ * @returns {{ entityFields: string[], endpoints: Array<{path: string, method: string,
+ *   requiredFields: string[], bodyFields: string[]}>, backendAllFields: string[],
+ *   escapeHatchCount: number, nonJavaSkipCount: number }}
+ */
+export function extractBackendFields(files, resolveTypeContent) {
+  const resolve = typeof resolveTypeContent === 'function' ? resolveTypeContent : () => null
+  const entityFields = new Set() // 二趟类型字段 ∪ diff 面实体字段
+  const controllerParams = new Set() // 一趟全部 Controller 方法参数名
+  const endpoints = [] // {path, method, required:Set, bodyFields:Set, bodyTypes:string[]}
+  let escapeHatchCount = 0
+  let nonJavaSkipCount = 0
+
+  for (const f of Array.isArray(files) ? files : []) {
+    const path = String((f && f.path) || '').split('\\').join('/')
+    const text = String((f && f.content) || '')
+    if (text.split('\n').slice(0, 5).some(l => l.includes('probe8-skip'))) { escapeHatchCount++; continue }
+    if (!path.toLowerCase().endsWith('.java')) { nonJavaSkipCount++; continue }
+
+    if (!PROBE8_CONTROLLER_RE.test(text)) {
+      // 非 Controller：diff 面实体/dto 直接解析（class 声明形，不依赖 @RequestBody 引用链）
+      if (PROBE8_ENTITY_CLASS_RE.test(text)) {
+        for (const name of probe8PrivateFieldNames(text)) entityFields.add(name)
+      }
+      continue
+    }
+
+    // ── 一趟：类级前缀 + 方法级端点 ──
+    const lines = text.split('\n')
+    const classDecl = text.match(PROBE8_CLASS_DECL_RE)
+    const classIdx = classDecl ? classDecl.index : -1
+    let prefix = ''
+    const pm = text.match(PROBE8_CLASS_PREFIX_RE)
+    if (pm && (classIdx < 0 || pm.index < classIdx)) prefix = pm[1]
+
+    let fileEndpointCount = 0
+    for (const m of text.matchAll(PROBE8_METHOD_MAPPING_RE)) {
+      if (classIdx >= 0 && m.index < classIdx) continue // 类级 @RequestMapping 非方法端点
+      const method = m[1] === 'Request' ? 'REQUEST' : m[1].toUpperCase()
+      // 方法签名区：注解尾（m[0] 止于可见性修饰符）至方法体首 `{`；无 `{`（抽象/接口）取到文末
+      const sigStart = m.index + m[0].length
+      const braceIdx = text.indexOf('{', sigStart)
+      const sigText = text.slice(sigStart, braceIdx < 0 ? text.length : braceIdx)
+      const ep = {
+        path: joinProbe8Path(prefix, m[2]),
+        method,
+        required: new Set(),
+        bodyFields: new Set(),
+        bodyTypes: [],
+      }
+      // @RequestParam 三态（数组/泛型边界不误捕；value 注解显式名优先于声明参数名）
+      for (const rp of sigText.matchAll(PROBE8_REQUEST_PARAM_RE)) {
+        const annoSeg = rp[1] === undefined ? '' : `@RequestParam(${rp[1]})`
+        const vm = annoSeg ? annoSeg.match(PROBE8_REQUEST_PARAM_VALUE_RE) : null
+        const name = vm ? vm[1] : rp[2]
+        controllerParams.add(name)
+        if (!(rp[1] && PROBE8_REQUIRED_FALSE_RE.test(rp[1]))) ep.required.add(name) // ② Spring 缺省必填
+      }
+      // @PathVariable 参数名进一趟参数集（URL 段非载荷字段，不计端点必填）
+      for (const pv of sigText.matchAll(PROBE8_PATH_VARIABLE_RE)) controllerParams.add(pv[1])
+      // @RequestBody 类型名收二趟待解析集
+      for (const rb of sigText.matchAll(PROBE8_REQUEST_BODY_RE)) ep.bodyTypes.push(rb[1])
+      // ③ 方法体前 30 行校验调用三模式 → 端点必填
+      if (braceIdx >= 0) {
+        const braceLine = text.slice(0, braceIdx).split('\n').length // `{` 所在行（1-based）
+        const win = lines.slice(braceLine - 1, braceLine - 1 + 30)
+        for (const name of probe8BodyCheckFields(win)) ep.required.add(name)
+      }
+      endpoints.push(ep)
+      fileEndpointCount++
+    }
+    // prefix 存在但零方法级端点 → 类级通配（无动词可判，method='REQUEST'）
+    if (prefix && fileEndpointCount === 0) {
+      endpoints.push({ path: prefix, method: 'REQUEST', required: new Set(), bodyFields: new Set(), bodyTypes: [] })
+    }
+  }
+
+  // ── 二趟：@RequestBody 类型名经全仓回调解析（typeCache 去重同名类型重复解析）──
+  const typeCache = new Map()
+  for (const ep of endpoints) {
+    for (const tn of ep.bodyTypes) {
+      if (!typeCache.has(tn)) {
+        let c = null
+        try { c = resolve(tn) } catch { c = null } // 回调抛错 fail-soft 视为 null
+        typeCache.set(tn, typeof c === 'string' ? c : null)
+      }
+      const content = typeCache.get(tn)
+      if (!content) continue // 类型不可解析（null）不炸——bodyFields 留空
+      for (const name of probe8PrivateFieldNames(content)) { ep.bodyFields.add(name); entityFields.add(name) }
+      // ① 校验注解 5 行窗口必填 → 归引用该类型的端点
+      for (const name of probe8NotNullFields(content)) ep.required.add(name)
+    }
+  }
+
+  const backendAllFields = new Set([...entityFields, ...controllerParams])
+  return {
+    entityFields: [...entityFields].sort(),
+    endpoints: endpoints.map(e => ({
+      path: e.path,
+      method: e.method,
+      requiredFields: [...e.required].sort(),
+      bodyFields: [...e.bodyFields].sort(),
+    })),
+    backendAllFields: [...backendAllFields].sort(),
+    escapeHatchCount,
+    nonJavaSkipCount,
+  }
+}
+
+// 二趟全仓检索的 .java 文件大小上限（Grill F-6——超大生成文件不进类型表）
+const PROBE8_JAVA_FILE_CAP = 500 * 1024
+
+/**
+ * createTypeResolver——二趟全仓类型解析回调工厂（task-05 调用侧组装）。readdirSync 递归扫
+ * srcRoot 下 .java（statSync 大小 cap 500KB，超限跳过），内容首个 class/interface/enum 声明名
+ * （缺失退文件名 stem）→ Map<className, content>；同名类先见先留（不覆写不炸）。srcRoot 不可
+ * 读/不存在 → 空表闭包（恒返 null，fail-soft）。做 IO 的是本工厂非 extractBackendFields 本体
+ * （纯函数约束）。
+ * @param {string} srcRoot 扫描根（仓根的 src/ 或 src/main/java 等——由调用侧定）
+ * @returns {(typeName: string) => string|null}
+ */
+export function createTypeResolver(srcRoot) {
+  const typeMap = new Map()
+  const walk = (dir) => {
+    let entries
+    try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return }
+    for (const e of entries) {
+      const full = join(dir, e.name)
+      try {
+        if (e.isDirectory()) { walk(full); continue }
+        if (!e.isFile() || !e.name.toLowerCase().endsWith('.java')) continue
+        if (statSync(full).size > PROBE8_JAVA_FILE_CAP) continue
+        const content = readFileSync(full, 'utf8')
+        const decl = content.match(/\b(?:class|interface|enum)\s+([A-Za-z_]\w*)/)
+        const name = (decl && decl[1]) || e.name.replace(/\.java$/, '')
+        if (!typeMap.has(name)) typeMap.set(name, content)
+      } catch { /* 单文件不可读——跳过 */ }
+    }
+  }
+  walk(String(srcRoot || ''))
+  return (typeName) => typeMap.get(typeName) || null
+}
+
+// ── probe8 direct-compare 对账+渲染（task-04，2026-09-18-probe8-direct-compare / D-002@v1·D-004@v1）──
+// 消费 task-02 前端提取面（fields/fieldLines/urlsByCall）× task-03 后端提取面（endpoints/
+// backendAllFields）做代码级字段直比，两嫌疑面（Grill B-7——backendAllFields 全仓并集防全量假阳）：
+//   - 漂移嫌疑：前端发送字段 ∉ backendAllFields（Jackson 静默丢弃风险面）；
+//   - 必填漏发嫌疑：端点 requiredFields ∉ 该端点关联前端文件发送集（EHS 缺发 reportOrgId 同族）。
+// 纯函数零 IO、advisory 档（D-004——不进 errors/warnings，独立渲染子段，命中统计供后续批次
+// 评估升格）。
+
+/**
+ * comparePayloadFields——前端×后端字段直比对账（task-04，纯函数零 IO）。
+ *   - 漂移嫌疑：非 escapeHatch 前端文件的每个 field ∉ backendAllFields → driftWarnings 逐条
+ *     {file, line（fieldLines 首命中行号，缺失 null）, field}；
+ *   - 必填漏发嫌疑：端点 requiredFields ∉ 该端点关联前端文件发送集 → missingRequiredWarnings
+ *     逐条 {endpoint, method, field, frontendFiles}。关联判定 = 端点 path 与文件 urlsByCall 的
+ *     normalizedUrl 满足 isSegmentSuffix（段边界后缀，Grill B-8——/orders 命中 /api/v1/orders
+ *     不误命中 /rporders；全等分支容忍无 /api 前缀可剥的归一原值如 /rporders）。无 URL 文件归
+ *     「未关联端点」面——仅漂移参与、漏发不参与（design §2 口径）；端点零关联文件 → 跳过漏发
+ *     判定（无发送集可比，「端点无人调用」属覆盖面非载荷面）；
+ *   - escapeHatchCount = 前端面 escapeHatch 文件聚合 + backendStats.escapeHatchCount（后端 hatch
+ *     自两提取面透传）；nonJavaSkipCount 自 backendStats 透传（后端提取面计数，三主参无承载点
+ *     → 第四可选参，缺省零）。
+ * @param {Array<{filePath: string, extract: {escapeHatch: boolean, fields: string[],
+ *   fieldLines: Map<string, number>, urlsByCall: Array<{url: string, normalizedUrl: string, line: number}>}}>} frontendByFile
+ *   逐前端文件提取面（task-02 产物按文件包装）
+ * @param {Array<{path: string, method: string, requiredFields: string[], bodyFields: string[]}>} backendEndpoints
+ *   后端端点集（task-03 产物 endpoints）
+ * @param {string[]} backendAllFields 后端全字段并集（task-03 产物 backendAllFields）
+ * @param {{escapeHatchCount?: number, nonJavaSkipCount?: number}} [backendStats]
+ *   后端提取面计数透传（缺省 {escapeHatchCount: 0, nonJavaSkipCount: 0}）
+ * @returns {{ driftWarnings: Array<{file: string, line: number|null, field: string}>,
+ *   missingRequiredWarnings: Array<{endpoint: string, method: string, field: string, frontendFiles: string[]}>,
+ *   escapeHatchCount: number, nonJavaSkipCount: number }}
+ */
+export function comparePayloadFields(frontendByFile, backendEndpoints, backendAllFields, backendStats) {
+  const feFiles = Array.isArray(frontendByFile) ? frontendByFile : []
+  const eps = Array.isArray(backendEndpoints) ? backendEndpoints : []
+  const beFields = new Set(Array.isArray(backendAllFields) ? backendAllFields : [])
+  const stats = backendStats && typeof backendStats === 'object' ? backendStats : {}
+  const statCount = (v) => (Number.isInteger(v) && v > 0 ? v : 0)
+
+  const driftWarnings = []
+  let feEscapeCount = 0
+  const urlLinkedFiles = [] // 有 URL 调用的文件 {filePath, fieldSet, urls}——漏发关联面
+  for (const fe of feFiles) {
+    const filePath = String((fe && fe.filePath) || '')
+    const ex = (fe && fe.extract) || {}
+    if (ex.escapeHatch) { feEscapeCount++; continue }
+    const fields = Array.isArray(ex.fields) ? ex.fields : []
+    for (const f of fields) {
+      if (!beFields.has(f)) {
+        const line = ex.fieldLines instanceof Map ? ex.fieldLines.get(f) : undefined
+        driftWarnings.push({ file: filePath, line: typeof line === 'number' ? line : null, field: f })
+      }
+    }
+    const urlsByCall = Array.isArray(ex.urlsByCall) ? ex.urlsByCall : []
+    if (urlsByCall.length === 0) continue // 无 URL 文件：未关联端点面——仅上方漂移参与
+    urlLinkedFiles.push({
+      filePath,
+      fieldSet: new Set(fields),
+      urls: urlsByCall.map(u => u && u.normalizedUrl).filter(Boolean),
+    })
+  }
+
+  const missingRequiredWarnings = []
+  for (const ep of eps) {
+    const path = String((ep && ep.path) || '')
+    const method = String((ep && ep.method) || '')
+    const required = Array.isArray(ep && ep.requiredFields) ? ep.requiredFields : []
+    if (required.length === 0) continue
+    const linked = urlLinkedFiles.filter(f => f.urls.some(u => isSegmentSuffix(u, path)))
+    if (linked.length === 0) continue // 零关联文件：无发送集可比，漏发不判（覆盖面归 API 矩阵）
+    const sentUnion = new Set()
+    for (const f of linked) for (const x of f.fieldSet) sentUnion.add(x)
+    for (const field of required) {
+      if (!sentUnion.has(field)) {
+        missingRequiredWarnings.push({ endpoint: path, method, field, frontendFiles: linked.map(f => f.filePath) })
+      }
+    }
+  }
+
+  return {
+    driftWarnings,
+    missingRequiredWarnings,
+    escapeHatchCount: feEscapeCount + statCount(stats.escapeHatchCount),
+    nonJavaSkipCount: statCount(stats.nonJavaSkipCount),
+  }
+}
+
+/** direct-compare 子段标题前缀（renderProbe8Lines 尾部子段调用锚） */
+const PROBE8_DIRECT_COMPARE_PREFIX = '- direct-compare:'
+
+/**
+ * renderDirectCompareSection——direct-compare 子段渲染（task-04，advisory 独立面）。
+ * 命中统计行 + 逐条明细行（漂移/漏发各一节）；全零态输出「无命中」行。防撞约束（task 卡
+ * acceptance）：明细行以 `` - ⚠️ ` `` 反引号开头，行首字面与 verify-postcheck.js 的
+ * PROBE8_CONTRACT_ORPHANS_LINE_RE / PROBE8_MISSING_REQUIRED_LINE_RE（`- ⚠️ 契约外载荷键 N 条`/
+ * `- ⚠️ 契约必填漏发 N 条` 字面前缀）严格不同——渲染行永不进两锚点的 N 求和（负例断言归
+ * task-06）；PROBE1_HIT_LINE_RE 虽同形但按探针子节定界只统计 s1，本子段落 s8 不进其计数。
+ * @param {{ driftWarnings?: Array<{file: string, line: number|null, field: string}>,
+ *   missingRequiredWarnings?: Array<{endpoint: string, method: string, field: string, frontendFiles: string[]}>,
+ *   escapeHatchCount?: number, nonJavaSkipCount?: number }} compareResult
+ * @returns {string[]} 行数组（不含段标题——拼进探针 8 段尾部）
+ */
+export function renderDirectCompareSection(compareResult) {
+  const r = compareResult && typeof compareResult === 'object' ? compareResult : {}
+  const drift = Array.isArray(r.driftWarnings) ? r.driftWarnings : []
+  const missing = Array.isArray(r.missingRequiredWarnings) ? r.missingRequiredWarnings : []
+  const esc = r.escapeHatchCount ?? 0
+  const nonJava = r.nonJavaSkipCount ?? 0
+  const L = []
+  if (drift.length === 0 && missing.length === 0) {
+    L.push(`${PROBE8_DIRECT_COMPARE_PREFIX} 无命中（漂移 0 / 漏发 0）`)
+    // 全零态仍保全跳过面计数（advisory 信息不丢——hatch/非 Java 跳过与命中数是独立维度）
+    if (esc > 0 || nonJava > 0) {
+      L.push(`- ℹ️ direct-compare: escape hatch ${esc} 文件 / 非 Java 后端跳过 ${nonJava} 文件`)
+    }
+    return L
+  }
+  L.push(`${PROBE8_DIRECT_COMPARE_PREFIX} 漂移嫌疑 ${drift.length} 条 / 必填漏发嫌疑 ${missing.length} 条 / escape hatch ${esc} 文件 / 非 Java 后端跳过 ${nonJava} 文件`)
+  for (const d of drift) {
+    L.push(`- ⚠️ \`${d.file}:${d.line ?? '?'}\` ${d.field} —— 不在后端字段集（漂移嫌疑）`)
+  }
+  for (const m of missing) {
+    L.push(`- ⚠️ \`${m.endpoint} ${m.method} ${m.field}\` —— 后端必填但前端未发送（必填漏发嫌疑，关联面：${(m.frontendFiles || []).join('、') || '?'}）`)
+  }
+  return L
+}
+
+
 // ── 探针 8 契约维度（task-01，2026-09-16 跨层契约探针扩展）──
 // design.md 的契约类章节（接口定义/数据模型等）字段表是「文档契约面」——既有三面（Java 字段/
 // SQL NOT NULL/前端载荷键）对不上「文档 vs 实现」漂移：契约改了代码没跟上（orphan）、契约必填
@@ -290,16 +1053,107 @@ function designHasSubmitEndpoint(text) {
   return false
 }
 
+// ── 接口面解析 + 消费端归类（2026-09-17-api-coverage-smoke task-04 / FR-05 / D-005~D-007）──
+// parseDesignApiTable：design.md 接口段 tolerant 解析（D-005：不做 normative 接口表格式硬
+// 契约）。双重防线：段头宽收（含 接口/端点/API/REST 子串、不区分大小写的 ##/### 段——宁多
+// 勿漏，R-01：漏端点→漏覆盖假绿比多端点更糟）+ 行级双条件紧守（R-02 误报防护）：HTTP 方法
+// token 词边界（GETTING/BUCKET 内嵌词形不误认）× 路径样式 token（/xxx 类路径或 {xxx}/:xxx
+// 模板段，取行内首个类路径串；?query 尾自然截断——端点身份是 path）。非接口段（非目标/
+// 先例引用段）内的表格/示例行靠段头过滤不计（「示例行跳过」的机制即此）。产物三面：
+//   endpoints [{method, path, rowIdx}]（rowIdx = 命中段内端点产出序号，1-based）；
+//   declared（「本变更接口面：N 端点」声明行提取的 N，全文首个命中，缺席 null——声明与
+//     解析并存以解析为准并注记，渲染侧体现）；
+//   sectionHint（命中的接口段头列表，审计注记）。
+// 落盘面（数据通道=落盘即消费，stage-contract 零 import 纪律）：backfillFactsFromMdAndTests
+// 主路径写 facts.apiFace / facts.consumerHints，task-05 validator 经 facts 消费不经函数调用。
+const API_FACE_SECTION_RE = /接口|端点|api|rest/i
+const API_FACE_METHOD_RE = /(?:^|[^A-Za-z])(GET|POST|PUT|DELETE|PATCH)(?![A-Za-z])/
+// 路径样式 token：/ 起始、前邻非字母数字（日期 2026/09/17 的 /09 前是数字段不认），
+// 首字符字母数字/_/-/{，后续段字符含 {}/: 模板形态（/orders/{id}、/orders/:id 全串命中）
+const API_FACE_PATH_RE = /(?:^|[^A-Za-z0-9])(\/[A-Za-z0-9_\-{}][\w\-./{}:]*)/
+const API_FACE_DECLARED_RE = /本变更接口面[：:]\s*(\d+)\s*端点/
+
+/**
+ * design.md 接口段 tolerant 解析（task-04 / D-005）。纯函数、本地正则零新依赖；输入统一
+ * CRLF→LF 归一（parseRuntimeEndpointExcluded 同款，Windows/Linux/macOS 兼容）。
+ * @param {string} designMd design.md 全文
+ * @returns {{ endpoints: Array<{method: string, path: string, rowIdx: number}>,
+ *   declared: number|null, sectionHint: string[] }}
+ */
+export function parseDesignApiTable(designMd) {
+  const text = String(designMd || '').replace(/\r\n/g, '\n')
+  const dm = text.match(API_FACE_DECLARED_RE)
+  const declared = dm ? parseInt(dm[1], 10) : null
+  const endpoints = []
+  const sectionHint = []
+  for (const sec of splitMdSections(text)) {
+    if (!API_FACE_SECTION_RE.test(sec.heading)) continue
+    sectionHint.push(sec.heading)
+    let rowIdx = 0
+    for (const line of sec.lines) {
+      const t = line.trim()
+      if (!t || t.startsWith('#')) continue
+      const mm = t.match(API_FACE_METHOD_RE)
+      if (!mm) continue // 缺方法列（有路径无方法 token）不认——双条件缺一不可
+      const pm = t.match(API_FACE_PATH_RE)
+      if (!pm) continue // 有方法无路径样式 token（说明行/纯文档行）不认
+      rowIdx++
+      endpoints.push({ method: mm[1], path: pm[1], rowIdx })
+    }
+  }
+  return { endpoints, declared, sectionHint }
+}
+
+// ── 消费端归类启发式（task-04 / D-006 / FR-05，仅 advisory 提示面）──
+// design 清单文件面路径段归类 web/mp/script：routes/pages/model 目录词 → web；mp/miniapp →
+// mp；scripts/test → script。归类只用于 task-05 的「有消费端未填子行」warning 提示（R-05：
+// 启发式假提示无害）——不做语义判定。路径段级匹配非裸子串（'homepages.js' 文件名不命中
+// pages 段）；mp 检查先于 web（mp/pages/index 小程序页归 mp 不归 web）；NEW: 前缀剥除
+// （probe1-new-prefix-miss 同款）。
+const CONSUMER_WEB_SEGMENTS = new Set(['routes', 'pages', 'model'])
+const CONSUMER_MP_SEGMENT_RE = /^(?:mp|miniapp|miniprogram|weapp)$/i
+const CONSUMER_SCRIPT_SEGMENTS = new Set(['scripts', 'script', 'test', 'tests'])
+const CONSUMER_HINT_FILE_CAP = 20
+/**
+ * 清单路径 → 消费端归类（task-04，导出供 task-05 经落盘/传参双通道消费）。
+ * @param {string[]} paths design 清单文件路径（NEW: 前缀/CRLF 容忍）
+ * @returns {Record<string, string[]>} 命中类别的支撑文件（键 ∈ web/mp/script，零命中 {}）
+ */
+export function classifyConsumerHints(paths) {
+  const hints = {}
+  const push = (kind, p) => {
+    if (!hints[kind]) hints[kind] = []
+    if (hints[kind].length < CONSUMER_HINT_FILE_CAP && !hints[kind].includes(p)) hints[kind].push(p)
+  }
+  for (const raw of paths || []) {
+    const p = String(raw || '').replace(/^NEW:\s*/, '').split('\\').join('/')
+    if (!p || p.startsWith('.sillyspec/')) continue
+    const segs = p.toLowerCase().split('/')
+    if (segs.some(s => CONSUMER_MP_SEGMENT_RE.test(s))) push('mp', p)
+    else if (segs.some(s => CONSUMER_WEB_SEGMENTS.has(s))) push('web', p)
+    else if (segs.some(s => CONSUMER_SCRIPT_SEGMENTS.has(s))) push('script', p)
+  }
+  return hints
+}
+
 /**
  * 探针 8 主体：design 清单三面文件（Java/SQL/前端）→ 双根（主仓 ∪ worktree）∪ 跨仓注册仓根
  * 读取 → 归一化比对。advisory：所有输出是「候选」不是结论（UI 本地态键/服务端填充列会自然
  * 出现在差异里，agent 逐条复核——口径注记随渲染输出）。
- * @param {{ specBase: string, cwd: string, wtRoot?: string|null, changeName: string }} args
+ * @param {{ specBase: string, cwd: string, wtRoot?: string|null, changeName: string,
+ *   diffFiles?: {frontend?: string[], backend?: string[]}|null }} args
+ *   diffFiles（task-04 参数化预留，task-05 已接线）：显式传入时优先（测试注入口）直接组装
+ *   direct-compare；缺省 null → 内部 collectProbe8DiffFiles 三态采集（worktree diff /
+ *   in-place diff / design-list 兜底）喂同一组装块，并落模式注记（design-list 态含
+ *   「direct-compare 面可能不全」）与 designOnlyPaths advisory 行（详见函数尾接线块）。
  * @returns {{applicable, backendFieldCount, feKeyCount, notNullCount, javaFileCount, sqlFileCount, feFileCount,
  *   mispairs: Array<{fe,be}>, feOnly: string[], missingNotNull: Array<{col}>, notes: string[],
- *   contractCount: number, contractOrphans: Array<{fe, hint?}>, missingRequired: Array<{field, contract}>}}
+ *   contractCount: number, contractOrphans: Array<{fe, hint?}>, missingRequired: Array<{field, contract}>,
+ *   directCompare?: {driftWarnings: Array<{file, line: number|null, field}>,
+ *     missingRequiredWarnings: Array<{endpoint, method, field, frontendFiles: string[]}>,
+ *     escapeHatchCount: number, nonJavaSkipCount: number}}}
  */
-export function runProbe8PayloadParity({ specBase, cwd, wtRoot = null, changeName }) {
+export function runProbe8PayloadParity({ specBase, cwd, wtRoot = null, changeName, diffFiles = null }) {
   const out = {
     applicable: false, backendFieldCount: 0, feKeyCount: 0, notNullCount: 0,
     javaFileCount: 0, sqlFileCount: 0, feFileCount: 0,
@@ -465,6 +1319,57 @@ export function runProbe8PayloadParity({ specBase, cwd, wtRoot = null, changeNam
   out.backendFieldCount = backendFields.size
   out.feKeyCount = feKeys.size
   out.notNullCount = notNullCols.size
+
+  // ── probe8 diff 源接线（task-05，D-001@v1）：direct-compare 维度的文件面从 design 清单
+  // 切换为 collectProbe8DiffFiles 三态采集（worktree diff / in-place diff / design-list 兜底），
+  // 分类面（frontend/backend）喂 task-04 组装块；上文 design 清单三面/契约面对账（readEntry
+  // 消费 detailed 的既有逻辑 + contractOrphans/missingRequired）零改动——diff 源只替换
+  // direct-compare 维度文件面，不替换契约面文件面。外部 diffFiles 显式传入时优先（测试注
+  // 入口，跳过采集零注记）。采集器 notes 全量转发（三态模式注记/跨仓失败注记 fail-visible）；
+  // design-list 态补「direct-compare 面可能不全」风险注记；designOnlyPaths 非空落 advisory
+  // 行（design 声明但 diff 面无——不参与对账不阻断，供人工复核）。跨仓 diff 面产物是仓根相对
+  // 路径且无 repo 标记，readEntry 按主仓双根读不到即跳过（fail-soft，直比面跨仓缺位是已知
+  // 边界；主仓恰有同名路径时读主仓文件，advisory 面可接受）。──
+  let diffFace = diffFiles
+  if (!diffFace) {
+    const collected = collectProbe8DiffFiles({ cwd, changeName, specBase, repoKeys: [...registry.keys()] })
+    for (const n of collected.notes) out.notes.push(n)
+    if (collected.source === 'design-list') {
+      out.notes.push('文件源=design 清单（diff 不可用）——direct-compare 面可能不全')
+    }
+    if (collected.designOnlyPaths.length > 0) {
+      out.notes.push(`design 声明但 diff 无的路径（advisory，不阻断）：${collected.designOnlyPaths.join('、')}`)
+    }
+    diffFace = { frontend: collected.frontend, backend: collected.backend }
+  }
+
+  // ── direct-compare 组装（task-04 参数化，task-05 接线）：diffFace（外部注入或内部采集，
+  // collectProbe8DiffFiles 产物形态 {frontend, backend} 路径数组）时组装代码级直比面挂
+  // out.directCompare（渲染经 renderProbe8Lines 尾部子段消费）；两数组全缺 → 键恒缺省。
+  // 读取复用 readEntry（主仓∪worktree 双根 + 跨仓注册，fail-visible 注记）；二趟类型解析
+  // wtRoot/src→cwd/src 串行 miss-chain（createTypeResolver 各自 fail-soft，零新增 IO 边）。──
+  if (diffFace && (Array.isArray(diffFace.frontend) || Array.isArray(diffFace.backend))) {
+    const frontendByFile = []
+    for (const p of Array.isArray(diffFace.frontend) ? diffFace.frontend : []) {
+      const content = readEntry({ path: p })
+      if (content == null) continue
+      frontendByFile.push({ filePath: p, extract: extractFrontendPayloadFields(p, content) })
+    }
+    const backendFiles = []
+    for (const p of Array.isArray(diffFace.backend) ? diffFace.backend : []) {
+      const content = readEntry({ path: p })
+      if (content == null) continue
+      backendFiles.push({ path: p, content })
+    }
+    const resolvers = [wtRoot, cwd].filter(Boolean).map(b => createTypeResolver(join(b, 'src')))
+    const be = extractBackendFields(backendFiles, (tn) => {
+      for (const r of resolvers) { const c = r(tn); if (c) return c }
+      return null
+    })
+    out.directCompare = comparePayloadFields(frontendByFile, be.endpoints, be.backendAllFields, {
+      escapeHatchCount: be.escapeHatchCount, nonJavaSkipCount: be.nonJavaSkipCount,
+    })
+  }
   return out
 }
 
@@ -1258,7 +2163,20 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
     probe9.notes = [`探针 9 执行失败（fail-soft 跳过）：${e && e.message ? e.message : e}`]
   }
 
-  return { probe1, probe3, probe5, probe6, probe7, probe8, probe9 }
+  // ── 接口面 + 消费端归类（task-04 / FR-05 / D-005~D-007）：design.md 接口段 tolerant
+  // 解析 + 清单消费端归类——骨架「## 接口验证覆盖矩阵」段预填与 facts 落盘
+  // （backfillFactsFromMdAndTests）共用同一解析器（单一产物源，不各读各的）。fail-soft：
+  // design 缺失/解析异常 → 空面（骨架渲染「无接口面」注记，validator 判 N=0 走零行为注记）。──
+  let apiFace = { endpoints: [], declared: null, sectionHint: [] }
+  let consumerHints = {}
+  try {
+    if (existsSync(designPath)) {
+      apiFace = parseDesignApiTable(readFileSync(designPath, 'utf8'))
+      consumerHints = classifyConsumerHints(detailed.map(e => String(e.path)))
+    }
+  } catch { /* design 读/解析异常 → 空面（fail-soft） */ }
+
+  return { probe1, probe3, probe5, probe6, probe7, probe8, probe9, apiFace, consumerHints }
 }
 
 /**
@@ -1373,7 +2291,12 @@ export function renderVerifyProbesReport(result) {
  * @param {{applicable: boolean, backendFieldCount?: number, feKeyCount?: number, notNullCount?: number,
  *   javaFileCount?: number, sqlFileCount?: number, feFileCount?: number,
  *   mispairs: Array<{fe,be}>, feOnly: string[], missingNotNull: Array<{col}>, notes: string[],
- *   contractCount?: number, contractOrphans?: Array<{fe, hint?}>, missingRequired?: Array<{field, contract}>}} p8
+ *   contractCount?: number, contractOrphans?: Array<{fe, hint?}>, missingRequired?: Array<{field, contract}>,
+ *   directCompare?: {driftWarnings: Array<{file, line: number|null, field}>,
+ *     missingRequiredWarnings: Array<{endpoint, method, field, frontendFiles: string[]}>,
+ *     escapeHatchCount: number, nonJavaSkipCount: number}}} p8
+ *   directCompare（task-04）：runProbe8PayloadParity 在外部传入 diffFiles 时组装的代码级直比
+ *   面——缺失（存量调用/兜底形态）时子段 if 块静默跳过，零回归。
  * @returns {string[]} 行数组（含段标题）
  */
 function renderProbe8Lines(p8) {
@@ -1407,6 +2330,10 @@ function renderProbe8Lines(p8) {
     L.push('- ✅ 载荷字段面零疑似差异（归一化覆盖 + NOT NULL 全见）')
   }
   for (const n of p8.notes || []) L.push(`- ℹ️ ${n}`)
+  // direct-compare 子段（task-04）：代码级直比面（漂移嫌疑/必填漏发嫌疑，advisory 独立面——
+  // 不进 errors/warnings）。独立 if 块，删除即整体回退；p8.directCompare 缺失（存量调用/兜底
+  // 形态）时静默跳过零回归。明细行防撞 verify-postcheck PROBE8 锚点（行首字面前缀不同）。
+  if (p8.directCompare) L.push(...renderDirectCompareSection(p8.directCompare))
   return L
 }
 
@@ -1442,6 +2369,54 @@ function renderProbe9Lines(p9) {
   return L
 }
 
+// ── 接口验证覆盖矩阵段渲染（task-04 / FR-05 / D-005~D-007）──
+// 骨架新写路径（generateVerifyResultSkeleton）与缺段补齐（ensureApiCoverageMatrixSection）
+// 共用单一实现——renderProbe7Lines 先例。不动 probe7 既有矩阵（独立 ## 章节并行存在，口径
+// 注记互指区分，D-009 非目标 / R-07）。预填口径同 probe7：CLI 机械预填、agent 逐格复核改写。
+const API_MATRIX_HEADING = '## 接口验证覆盖矩阵'
+// 写端点集合（D-007/FR-06 表间完备性 advisory 数据面）：method ∈ 此集的端点须在 design
+// 权限矩阵段有对应行或显式豁免（「无权限约束」）——warning 计算归 task-05，此处只定集合。
+const API_MATRIX_WRITE_METHODS = new Set(['POST', 'PUT', 'DELETE', 'PATCH'])
+
+/**
+ * 渲染「## 接口验证覆盖矩阵」段（task-04）。
+ * 三态：解析有端点 → 逐端点预填行（判定列 `<待填：四选一>` 占位，同 probe7 预填口径供 agent
+ * 复核）；解析零行有声明 → 声明占位行「本变更接口面：<N> 端点（agent 声明）」（D-005 零解析
+ * 降级，对账分母=声明数）；零解析零声明 → 「无接口面」注记行（非判级 critical 变更零行为
+ * 注记即可——判级 critical 的 error 拦截归 task-05 validator）。段尾 advisory 占位注记
+ * （消费面/表间完备性，warning 计算归 task-05，本段只留位）。
+ * @param {{endpoints?: Array<{method: string, path: string, rowIdx: number}>, declared?: number|null}|null} apiFace
+ * @returns {string[]} 行数组（含段标题；调用方自理前后空行）
+ */
+function renderApiCoverageMatrixLines(apiFace) {
+  const face = apiFace && typeof apiFace === 'object' ? apiFace : null
+  const endpoints = face && Array.isArray(face.endpoints) ? face.endpoints : []
+  const declared = face && typeof face.declared === 'number' ? face.declared : null
+  const L = [`${API_MATRIX_HEADING} [层：人工判断——CLI 预填复核]`]
+  L.push('<!-- 口径注记（与探针 7 互指，R-07）：探针 7 = 验收项 × 测试承接面（每条 acceptance 由哪些测试承接）；本矩阵 = 接口端点 × 验证用例面（design 接口段每个端点由哪些验证用例/冒烟步骤覆盖）——两者并排互补，双矩阵并行存在。端点集来自 design.md 接口段 tolerant 解析（parseDesignApiTable：段头宽收 + 方法/路径双条件），预填≠结论，agent 逐行复核。判定枚举（四选一）：covered / partial / uncovered / non-testable。 -->')
+  L.push('<!-- 预填说明：端点行由 CLI 机械预填，判定/用例依据 ID/结果/证据由 agent 逐格填写——用例依据 ID 锚点五形态：design接口表#METHOD /path、权限矩阵[角色×动作]、契约表@行标识、DDL@列名、载荷@构造点路径（须真实命中对应表/段，防空指）。 -->')
+  L.push('<!-- 文法注释：子行 = 端点行下一行、两空格缩进、以「↳ <消费端>:」前缀书写（消费端细分承接面，不计矩阵行账）；探索行 = 判定 uncovered 且证据列含 [探索] 标记（探索性验证不算覆盖）。 -->')
+  if (endpoints.length === 0 && declared === null) {
+    L.push('- 无接口面（design 接口段解析零端点且无「本变更接口面：N 端点」声明行）——本变更若实际触碰接口，先补 design 接口段表格或声明行，再重跑 `verify-probes --init` 刷新本段；判级 critical 的零面拦截归 validator')
+    return L
+  }
+  if (endpoints.length > 0 && declared !== null && declared !== endpoints.length) {
+    L.push(`<!-- 声明与解析并存（声明 ${declared} 端点 / 解析 ${endpoints.length} 端点）——以解析为准，差异需复核（design 接口段与声明行不同步的漂移信号） -->`)
+  }
+  L.push('| 端点 | 判定 | 用例依据 ID | 结果 | 证据 |')
+  L.push('|---|---|---|---|---|')
+  if (endpoints.length > 0) {
+    for (const ep of endpoints) {
+      L.push(`| ${mdEscapeCell(`${ep.method} ${ep.path}`, 160)} | <待填：四选一> | <待填：用例 ID> | <待填> | <待填：锚点> |`)
+    }
+  } else {
+    L.push(`| 本变更接口面：${declared} 端点（agent 声明） | <待填：四选一> | <待填：用例 ID> | <待填> | <待填：锚点> |`)
+    L.push('<!-- 解析零行降级（D-005）：接口面以 agent 声明为准（对账分母=声明数）；声明与实际不符时补 design 接口段表格后重跑 --init 刷新本段 -->')
+  }
+  L.push('<!-- advisory 尾注（warning 计算归 validator，本段只留位）：有消费端未填子行的端点将列于此（advisory——消费端归类=design 清单启发式，数据面 facts.consumerHints）；写端点（POST/PUT/DELETE/PATCH）未在权限矩阵段声明的将列于此（advisory——补行或显式豁免「无权限约束」，数据面 facts.apiFace.writeEndpoints；表缺行会让派生框架继承你的洞） -->')
+  return L
+}
+
 /**
  * 从 runVerifyProbes 结果构造 verify-facts.json 机器底稿对象（P3b 可复跑审计底稿）。
  * 命令行统一 `sillyspec verify-probes --change <name>`；指标 fail-soft——字段不可得时少列
@@ -1604,7 +2579,7 @@ const HANDOVER_DEFAULT_SEVERITY = (type) =>
 // 降级理由文法（X-02）：（降级：<理由>，依据 <file:line 或 D-xxx>）——全角括号/冒号/逗号，
 // 依据锚点 D-xxx 或 file:line。JS 正则不转义全角括号（知识库坑）。blocking→advisory 降级
 // 未命中本文法 → 仍按 blocking（fail-closed，防「全标 advisory」钻空——D-005@v2）。
-const HANDOVER_DOWNGRADE_REASON_RE = /（降级：.+?，依据\s*(?:D-\d+|[^\s，）:]+:\d+)）/
+const HANDOVER_DOWNGRADE_REASON_RE = /（降级：.+?，依据\s*(?:D-\d+(?:@\d+)?|[^\s，）:]+:\d+)）/
 // severity 解析：显式 blocking 优先（混写保守）；显式 advisory 对 blocking 缺省类型构成降级，
 // 理由文法在第 4 列或条件列任一命中即认（骨架第 4 列定型前 producer 宽收两侧；抽查面归
 // checkProbeConsistency 消费侧后续任务）；两枚举都不含 → 缺省映射。
@@ -1634,6 +2609,8 @@ export function parseHandoverRows(md) {
     const condition = row[3].trim()
     if (type === '类型' || /^-{2,}$/.test(type.replace(/\|/g, ''))) continue // 表头/分隔行
     if (type.startsWith('<') || item.startsWith('<')) continue // 骨架占位行
+    if (type === '无' || item === '无') continue // 裸「无」行=骨架指引的空表占位（结论=PASS/FAIL 写「无」）——
+    // 真「无可移交」的合法表达是矩阵干净+零有效行，不是一行无；精确相等防误杀「无明确去向」类真条目
     if (!type || !item) continue
     const normalizedType = type.toLowerCase().replace(/[\s_]+/g, '-')
     items.push({
@@ -1687,16 +2664,20 @@ export function parseDbScriptDeclarations(md) {
 // 退役判据：批次 C commands.smoke 落地后由 smoke 回执一票判定「集成实测已跑」——起服务冒烟
 // 即跨层实测，不得默认 build 误拦金路径）；unit=单测 runner 直跑（JUnitCore/node --test/
 // mocha/jest/vitest/pytest 等）；其余（compile/lint/构建/mvn test 等混合形态）一律 build。
-const RECEIPT_CROSS_LAYER_RE = new RegExp([
-  '\\bcurl\\b', '\\bwget\\b', '\\bhttpie\\b', '\\bInvoke-WebRequest\\b', '\\bInvoke-RestMethod\\b',
-  '\\biwr\\b', '\\birm\\b', 'https?://',
-  'spring-boot:run', '\\bjava\\b[^|\\n]*\\s-jar\\b',
-  '\\b(?:npm|pnpm|yarn|bun)\\s+(?:run\\s+)?(?:dev|start|serve|smoke)\\b',
-  '\\bdotnet\\s+run\\b', '\\bflask\\s+run\\b', '\\buvicorn\\b', '\\bgunicorn\\b',
-  '\\b(?:nc|netcat|telnet|socat)\\b',
-].join('|'), 'i')
-const RECEIPT_UNIT_RE = /\bJUnitCore\b|\bnode\s+--test\b|\bmocha\b|\bjest\b|\bvitest\b|\bpytest\b|\bphpunit\b|\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?test\b/i
-function classifyReceiptCommandSource(command) {
+//
+// 来源标记直判（2026-09-17-api-coverage-smoke task-02 / Grill B-1 修正，FR-03）：条目 source
+// 标记 'cli-noai-smoke'（parseEvidenceSlots additive 第五字段——本文件 ensureSmokeReceiptSection
+// 注入的机器段行尾注回填）→ 直判 cross-layer，**优先于命令词正则分类**——修正点在标记识别
+// 而非命令词增补：node scripts/smoke.mjs / bash smoke.sh / python smoke.py 等脚本形态在既有
+// 正则下全判 build 会误拦金路径，且脚本形态词表不可枚举（RECEIPT_CROSS_LAYER_RE 正则族
+// 零词变动）。对齐目标：change-risk-profile.js classifyReceiptSourceTag(sourceMark 参数与
+// CLI_SMOKE_SOURCE_MARK 常量)——**任一侧增改标记族必须双侧同步**（G-3 铁律）。
+// （正则族单点收敛 ql-20260918-001：RECEIPT_CROSS_LAYER_RE/SMOKE_RECEIPT_SOURCE_MARK
+// 从 change-risk-profile.js 导入（RECEIPT_SOURCE_CROSS_LAYER_RE/CLI_SMOKE_SOURCE_MARK 别名）——
+// 消灭双文件逐词同步的口径漂移面（G-3 根因）。
+/** CLI 机器段来源标记（与 change-risk-profile.js CLI_SMOKE_SOURCE_MARK / task-01 记录 source 同值，双侧同步） */
+function classifyReceiptCommandSource(command, sourceMark) {
+  if (sourceMark === SMOKE_RECEIPT_SOURCE_MARK) return 'cross-layer'
   const cmd = String(command || '')
   if (RECEIPT_CROSS_LAYER_RE.test(cmd)) return 'cross-layer'
   if (RECEIPT_UNIT_RE.test(cmd)) return 'unit'
@@ -1734,7 +2715,9 @@ function judgeIntegrationRan(factsPath, runtimeEvidence) {
   const scanRan = Boolean(record && record.testResult && record.testResult.status && record.testResult.status !== 'skipped')
   if (scanRan && ['full', 'module', 'evidence-auto'].includes(strategy)) return { ran: 'ran', notes: [] }
   const receipts = Array.isArray(runtimeEvidence) ? runtimeEvidence : []
-  if (receipts.some(r => classifyReceiptCommandSource(r && r.command) === 'cross-layer')) {
+  // 条目 source 标记透传（task-02 Grill B-1）：source='cli-noai-smoke' 直判 cross-layer——
+  // 机器段命令（node scripts/smoke.mjs 等脚本形态）不再落 build 误拦金路径。
+  if (receipts.some(r => classifyReceiptCommandSource(r && r.command, r && r.source) === 'cross-layer')) {
     return { ran: 'ran', notes: [] }
   }
   const notes = []
@@ -1778,6 +2761,22 @@ function countMatrixPartialRows(md) {
 }
 
 export function backfillFactsFromMdAndTests(factsPath, { verifyMd, testCheckResult = null, conclusion = null }) {
+  // smoke 机器段 ensure（2026-09-17-api-coverage-smoke task-02，挂 backfill 合并时点——
+  // quality-scan step 6 noAI 亲跑落记录先于本步，读得到实录）：read-modify-write 盘上 md
+  // 最新态（不基于 verifyMd 快照写回，防覆盖多 agent 并发改动）；注入/态更新成功后解析源
+  // 切盘上最新内容——机器段行立即参与 slots 解析，judgeIntegrationRan 同轮即吃到
+  // source 标记直判 cross-layer。ensure 落盘失败/无记录 fail-soft，不阻断 facts 回填。
+  let verifyMdText = verifyMd
+  try {
+    const ensureDir = dirname(factsPath)
+    const ensured = ensureSmokeReceiptSection(join(ensureDir, 'verify-result.md'), {
+      specBase: dirname(dirname(ensureDir)),
+      changeName: basename(ensureDir),
+    })
+    if (ensured.changed) {
+      verifyMdText = readFileSync(join(ensureDir, 'verify-result.md'), 'utf8')
+    }
+  } catch { /* ensure 异常 fail-soft，按传入快照继续回填 */ }
   let facts = null
   try { facts = JSON.parse(readFileSync(factsPath, 'utf8')) } catch { /* 缺失见下 */ }
   // 只固化既有底稿，不无中生有（2026-09-08-ir-verify-facts 接线实证）：无 facts 的存量变更
@@ -1790,7 +2789,7 @@ export function backfillFactsFromMdAndTests(factsPath, { verifyMd, testCheckResu
   if (facts.schemaVersion !== FACTS_SCHEMA_VERSION) {
     facts = { ...facts, schemaVersion: FACTS_SCHEMA_VERSION, probes: (facts && facts.probes) || {} }
   }
-  const slots = parseEvidenceSlots(verifyMd || '')
+  const slots = parseEvidenceSlots(verifyMdText || '')
   // conclusion 由调用方传 stage-contract.extractVerifyConclusionSlot(verifyMd) 的结果
   // （避免 verify-probes → stage-contract 静态 import 的潜在环，分层单向）
   const conclusionSlot = conclusion || null
@@ -1804,14 +2803,15 @@ export function backfillFactsFromMdAndTests(factsPath, { verifyMd, testCheckResu
   if (slots.hasReceiptSlot && slots.runtimeEvidence.length > 0) {
     facts.runtimeEvidence = slots.runtimeEvidence
   }
-  // 移交项结构化回填（handover-only-in-prose）：有有效行 → facts.handover 落盘（机器可读）；
+  // 移交项结构化回填（handover-only-in-prose）：facts.handover **恒落盘**（零行= {count:0, items:[]}——
+  // 2026-09-18-fr-index-l1 verify 期实证死锁修复：原「有行才写」使 零移交+结论 PASS 被
+  // evaluatePassEligibility 条件② handoverFieldMissing fail-closed 拦死（PASS+真零移交结构性不可能）；
+  // eligibility 测试的 CLEAN_FACTS 本就是 count:0 形态——字段在场零行=净，本行只是对齐既有契约）；
   // PASS WITH NOTES 零有效行 → advisory 警告（不阻断——存量 PASS WITH NOTES 无此章节是常态，
   // 渐进采纳）。EHS 实证：被环境阻断 deferred 的集成测试里藏着 5 个 P1，清单化才有
   // 「谁兜、怎么复跑」的可追溯面。
-  const handoverItems = parseHandoverRows(verifyMd || '')
-  if (handoverItems.length > 0) {
-    facts.handover = { count: handoverItems.length, items: handoverItems }
-  }
+  const handoverItems = parseHandoverRows(verifyMdText || '')
+  facts.handover = { count: handoverItems.length, items: handoverItems }
   if (conclusionSlot === 'PASS WITH NOTES' && handoverItems.length === 0) {
     console.warn('⚠️ 结论=PASS WITH NOTES 但「移交项（结构化）」章节零有效行——正文叙述的移交项（环境阻断复跑条件/人工验收步骤/待执行脚本）请结构化进 ## 移交项（结构化） 表格（类型枚举 env-blocked/manual-acceptance/db-script/other），避免移交项只活在 prose 里没人兜（2026-09-15 EHS 实证：被环境阻断 deferred 的集成测试里藏着 5 个 P1）。')
   }
@@ -1820,12 +2820,45 @@ export function backfillFactsFromMdAndTests(factsPath, { verifyMd, testCheckResu
   // testCheckResult 时点（task-02 validator 在 runValidators 时点消费，已就位）；误挂二次
   // 回填的 testCheckResult 分支则消费时点读不到、恒误拦。判定输入自推导自读（quality-scan
   // 记录按 specBase 推导 / 矩阵经动态绑定），不依赖调用方传参。
-  facts.dbScriptDeclarations = parseDbScriptDeclarations(verifyMd || '')
-  facts.runtimeEndpointExcluded = parseRuntimeEndpointExcluded(verifyMd || '')
+  facts.dbScriptDeclarations = parseDbScriptDeclarations(verifyMdText || '')
+  facts.runtimeEndpointExcluded = parseRuntimeEndpointExcluded(verifyMdText || '')
   const integration = judgeIntegrationRan(factsPath, slots.runtimeEvidence)
   facts.integrationRan = integration.ran
   for (const note of integration.notes) console.warn(note)
-  facts.matrixPartialRows = countMatrixPartialRows(verifyMd || '')
+  facts.matrixPartialRows = countMatrixPartialRows(verifyMdText || '')
+  // ── facts.apiFace / facts.consumerHints（2026-09-17-api-coverage-smoke task-04 / FR-05 /
+  // D-005~D-007 producer 侧）──X-08 主路径无条件产出（同上口径，不依赖 testCheckResult
+  // 时点）：apiFace = design 接口段 tolerant 解析面（endpoints/declared + writeEndpoints
+  // 子集=表间完备性数据面），consumerHints = 清单消费端归类启发式（web/mp/script，仅
+  // warning 提示面）。数据通道=落盘即消费（stage-contract 零 import 纪律，分层单向）——
+  // task-05 validator 经 facts 读，不经函数调用。design.md 缺失 → 空面落盘（判定面稳定，
+  // validator 判 N=0 走零行为注记）；与 runVerifyProbes 同一解析器（单一产物源）。
+  {
+    const changeDir = dirname(factsPath)
+    const designPath = join(changeDir, 'design.md')
+    let designText = null
+    if (existsSync(designPath)) {
+      try { designText = readFileSync(designPath, 'utf8') } catch { designText = null }
+    }
+    const face = parseDesignApiTable(designText || '')
+    facts.apiFace = {
+      endpoints: face.endpoints,
+      declared: face.declared,
+      writeEndpoints: face.endpoints.filter(e => e && API_MATRIX_WRITE_METHODS.has(e.method)),
+    }
+    let designPaths = []
+    if (designText !== null) {
+      try { designPaths = parseFileChangeListDetailed(designPath).map(e => String(e.path)) } catch { designPaths = [] }
+    }
+    facts.consumerHints = classifyConsumerHints(designPaths)
+  }
+  // ── facts.smokeRan（2026-09-17-api-coverage-smoke task-03 / FR-02 / D-002@v1 producer 侧）──
+  // X-08 主路径无条件产出（同上四字段口径，不依赖 testCheckResult 时点）：唯一事实源 =
+  // quality-scan 记录 smokeResult 段（judgeSmokeRan 五边界态封闭），不受 verify-result.md
+  // 篡改影响（R-06 双源兜底）。消费方 = evaluatePassEligibility 第五条件（smoke-not-run）。
+  const smokeRanJudge = judgeSmokeRan(factsPath)
+  facts.smokeRan = smokeRanJudge.value
+  for (const note of smokeRanJudge.notes) console.warn(note)
   let testsBackfilled = false
   if (testCheckResult && testCheckResult.status && testCheckResult.status !== 'skipped') {
     facts.tests = {
@@ -1931,6 +2964,235 @@ export function ensureAcceptanceMatrixSection(mdPath, probe7) {
   return { added: true }
 }
 
+/**
+ * 接口验证覆盖矩阵段幂等补齐（task-04；ensureAcceptanceMatrixSection 先例形态）：verify-
+ * result.md 已存在但缺「## 接口验证覆盖矩阵」段时补骨架段。幂等口径（renderProbe7Lines
+ * 补段同款）：段已在场（agent 已填/未填）一律不触碰——预填只在骨架生成与缺段补齐两条新写
+ * 路径生效，agent 已填内容永不被覆盖；二跑零改动。插入位置：「## 探针结果」章节之后（下一
+ * ## 标题前，保持骨架章节序），无探针章则文末追加（旧格式/手写正文）。
+ * @param {string} mdPath verify-result.md 路径
+ * @param {{endpoints?: Array<{method: string, path: string, rowIdx: number}>, declared?: number|null}|null} apiFace
+ * @returns {{ added: boolean, reason?: string }}
+ */
+export function ensureApiCoverageMatrixSection(mdPath, apiFace) {
+  let text
+  try { text = readFileSync(mdPath, 'utf8') } catch { return { added: false, reason: 'verify-result.md 不存在或不可读' } }
+  const normalized = text.replace(/\r\n/g, '\n')
+  if (/^## 接口验证覆盖矩阵/m.test(normalized)) return { added: false, reason: '接口验证覆盖矩阵段已在场' }
+  const blockLines = [...renderApiCoverageMatrixLines(apiFace), '']
+  try {
+    const lines = normalized.split('\n')
+    const probeIdx = lines.findIndex(l => /^## 探针结果/.test(l))
+    if (probeIdx === -1) {
+      writeFileSync(mdPath, normalized.replace(/\n?$/, '\n') + '\n' + blockLines.join('\n'))
+    } else {
+      // 探针结果章终点 = 下一个 ## 级标题行（矩阵段紧随其后，与骨架章节序一致）
+      let end = lines.length
+      for (let i = probeIdx + 1; i < lines.length; i++) {
+        if (/^## /.test(lines[i])) { end = i; break }
+      }
+      lines.splice(end, 0, ...blockLines)
+      writeFileSync(mdPath, lines.join('\n'))
+    }
+  } catch (e) {
+    console.warn(`⚠️ 接口验证覆盖矩阵段补齐落盘失败（fail-soft，不阻断）: ${e && e.message ? e.message : e}`)
+    return { added: false, reason: '落盘失败' }
+  }
+  return { added: true }
+}
+
+// ============ smoke 回执槽机器段（2026-09-17-api-coverage-smoke task-02 / FR-03，design §3） ============
+//
+// 唯一事实源 = .runtime/verify-quality-scan-<change>.json 的 smokeResult 段（task-01 契约，
+// R-06 双源兜底——md 被篡改不影响 facts 推导）；本组函数把该记录 ensure 式渲染成
+// verify-result.md「## 集成验证回执」槽内 CLI 拥有的机器段行（source: cli-noai-smoke 标注
+// 识别），agent 只可追加段、不可改写机器段（改写/删除由 verify-postcheck
+// checkProbeConsistency 回执槽一致性对比打回，Grill #6 / R-06）。
+/** 机器段行首锚（ensure 幂等识别——claim 钦定文案；单行管道与多行 YAML 双形态首行均命中。
+ *  注意不可用 \b 锚中文词尾：CJK 不属 \w，「亲跑」后与「 |」之间无 word 边界恒 false（实证
+ *  幂等失效重复注入）——改前瞻断言（后随管道分隔或行尾）。 */
+const SMOKE_MACHINE_CLAIM_RE = /^- claim: commands\.smoke CLI 亲跑(?=\s*[|｜]|$)/
+/** 缺态注释行（态捕获 m[1]，not-configured / not-ran 两态——非回执行形态，parseEvidenceSlots 不收取） */
+const SMOKE_ABSENT_LINE_RE = /^<!--\s*smoke 机器段缺态：(not-configured|not-ran)\b[^>]*source: cli-noai-smoke[^>]*-->$/
+
+/**
+ * 读 quality-scan 记录的 smokeResult 段（路径规则同 judgeIntegrationRan：specBase/
+ * .runtime/verify-quality-scan-<changeName>.json）。共享读取点——ensure 注入与 postcheck
+ * 一致性对比同源取数，不各读各的。记录缺失/损坏/无 smokeResult 段 → null。
+ */
+export function readSmokeResultRecord(specBase, changeName) {
+  try {
+    const rec = JSON.parse(readFileSync(join(specBase, '.runtime', `verify-quality-scan-${changeName}.json`), 'utf8'))
+    if (rec && rec.schemaVersion === 1 && rec.source === 'cli-noai'
+      && rec.smokeResult && typeof rec.smokeResult === 'object') {
+      return rec.smokeResult
+    }
+  } catch { /* 记录缺失/损坏 → null */ }
+  return null
+}
+
+/**
+ * 由 smokeResult 记录推导机器段目标态（ensure 与 postcheck 共享口径，不二算）：
+ * 'passed'（configured 且亲跑绿）| 'not-configured'（未配置）| 'not-ran'（配置但
+ * failed/超时——task-01 契约 timeout 归 status='failed'）。
+ */
+export function deriveSmokeSectionState(smoke) {
+  if (!smoke || typeof smoke !== 'object') return null
+  if (smoke.configured === false) return 'not-configured'
+  return smoke.status === 'passed' ? 'passed' : 'not-ran'
+}
+
+/**
+ * facts.smokeRan 判定（2026-09-17-api-coverage-smoke task-03 / FR-02 / D-002@v1）：
+ * 唯一事实源 = quality-scan 记录 smokeResult 段（readSmokeResultRecord 共享读取点，R-06
+ * 双源兜底——不受 verify-result.md 篡改影响；judgeIntegrationRan 同款自读先例：specBase/
+ * changeName 自 factsPath 目录上推，不依赖调用方传参）。五边界态封闭：
+ *   configured=false（未配置键 / commands.smoke: unavailable / local.yaml 不可读）→
+ *     not-configured；status='passed'（exit 0）→ ran；status='failed'（exit 非 0/超时——
+ *     task-01 契约 timeout 归 failed，失败也是未通过）→ not-ran；记录在场但无 smokeResult
+ *     段（升级过渡期存量记录）→ not-ran + fail-open 注记；记录缺失/损坏 → not-ran +
+ *     fail-open 注记（X-01 口径，不阻断——出路=重跑质量扫描步或降级 NOTES）。
+ * @param {string} factsPath verify-facts.json 路径（<specBase>/changes/<name>/verify-facts.json）
+ * @returns {{ value: 'ran'|'not-ran'|'not-configured', notes: string[] }}
+ */
+function judgeSmokeRan(factsPath) {
+  const changeDir = dirname(factsPath)
+  const changeName = basename(changeDir)
+  const specBase = dirname(dirname(changeDir))
+  const recordPath = join(specBase, '.runtime', `verify-quality-scan-${changeName}.json`)
+  const smoke = readSmokeResultRecord(specBase, changeName)
+  if (smoke) {
+    if (smoke.configured === false) return { value: 'not-configured', notes: [] }
+    return { value: smoke.status === 'passed' ? 'ran' : 'not-ran', notes: [] }
+  }
+  // readSmokeResultRecord null 两缺因区分注记：记录在场但无 smokeResult 段（升级过渡期
+  // 存量记录）vs 记录缺失/损坏——同判 not-ran，注记各自点名（X-01 fail-open，不阻断）。
+  let recordPresent = false
+  try {
+    const rec = JSON.parse(readFileSync(recordPath, 'utf8'))
+    if (rec && rec.schemaVersion === 1 && rec.source === 'cli-noai') recordPresent = true
+  } catch { recordPresent = false }
+  return {
+    value: 'not-ran',
+    notes: [recordPresent
+      ? `ℹ️ quality-scan 记录在场但无 smokeResult 段（${recordPath}，升级过渡期存量记录）——facts.smokeRan 按 not-ran 判定（X-01 fail-open 注记，不阻断；出路=重跑质量扫描步或降级 NOTES）`
+      : `ℹ️ quality-scan 实测记录缺失（${recordPath}）——facts.smokeRan 按 not-ran 判定（X-01 fail-open 注记，不阻断；--done 亲测替代扫描的场景记录时序不可得，出路=重跑质量扫描步或降级 NOTES）`],
+  }
+}
+
+/**
+ * 扫描 verify-result.md 回执槽内 CLI 拥有的 smoke 机器段标记（ensure 幂等判定与
+ * verify-postcheck 一致性对比共享解析点）：①机器段回执条目 = parseEvidenceSlots 收取且
+ * source='cli-noai-smoke' 的条目（含 agent 冒充行——冒充也是打回面）；②缺态注释行态。
+ * @param {string} mdText verify-result.md 全文（CRLF 归一内部处理）
+ * @returns {{ machineEntries: Array<{claim,command,exitCode,logPath,source}>, absentState: 'not-configured'|'not-ran'|null }}
+ */
+export function scanSmokeReceiptSection(mdText) {
+  const text = String(mdText || '').replace(/\r\n/g, '\n')
+  let machineEntries = []
+  try {
+    machineEntries = (parseEvidenceSlots(text).runtimeEvidence || [])
+      .filter(e => e && e.source === SMOKE_RECEIPT_SOURCE_MARK)
+  } catch { machineEntries = [] }
+  let absentState = null
+  for (const line of text.split('\n')) {
+    const am = line.match(SMOKE_ABSENT_LINE_RE)
+    if (am) { absentState = am[1]; break }
+  }
+  return { machineEntries, absentState }
+}
+
+/**
+ * 回执槽 smoke 机器段 ensure 式注入（ensureAcceptanceMatrixSection 先例形态，task-02）：
+ * 挂 backfill 合并时点（backfillFactsFromMdAndTests——quality-scan step 6 noAI 亲跑落记录
+ * 先于 verify 门禁，读得到实录）。行为：记录态 passed → 段内注入机器段行（单行管道形态，
+ * command 含 ｜/| 时降多行 YAML 防字段截断）+ 说明注释行；not-configured / not-ran →
+ * 注缺态注释行；无记录 → no-op（不注入，task-03 判 not-ran）。幂等——段内已有同态 CLI 行
+ * 零改动；态迁移（如配置后亲跑：not-configured → passed）时替换 CLI 拥有行为新态。
+ * read-modify-write 基于盘上 md 最新态（不基于调用方快照写回，防覆盖多 agent 并发改动）。
+ * @param {string} mdPath verify-result.md 路径
+ * @param {{ specBase?: string, changeName?: string }} [opts] 缺省自 mdPath 目录上推（judgeIntegrationRan 同款）
+ * @returns {{ changed: boolean, state?: string, reason?: string }}
+ */
+export function ensureSmokeReceiptSection(mdPath, opts = {}) {
+  const changeDir = dirname(String(mdPath || ''))
+  const changeName = opts.changeName || basename(changeDir)
+  const specBase = opts.specBase || dirname(dirname(changeDir))
+  let text
+  try { text = readFileSync(mdPath, 'utf8') } catch { return { changed: false, reason: 'verify-result.md 不存在或不可读' } }
+  const smoke = readSmokeResultRecord(specBase, changeName)
+  const state = deriveSmokeSectionState(smoke)
+  if (!state) return { changed: false, reason: '无 quality-scan smokeResult 记录（未跑质量扫描）——不注入机器段' }
+  const lines = text.replace(/\r\n/g, '\n').split('\n')
+  const hIdx = lines.findIndex(l => l.startsWith(RECEIPT_SLOT_HEADING))
+  if (hIdx === -1) return { changed: false, reason: `回执槽段（${RECEIPT_SLOT_HEADING}）不在场——backfillMissingEvidenceSlots 先补段，下次 ensure 注入` }
+  // 段终点（parseEvidenceSlots sectionOf 同口径：下一 #/## 级标题或文末）
+  let end = lines.length
+  for (let i = hIdx + 1; i < lines.length; i++) {
+    if (/^#{1,2}\s/.test(lines[i])) { end = i; break }
+  }
+  let machineIdx = -1 // 机器段行（单行形态行或多行形态首行）
+  let absentIdx = -1 // 缺态注释行
+  for (let i = hIdx + 1; i < end; i++) {
+    if (machineIdx === -1 && SMOKE_MACHINE_CLAIM_RE.test(lines[i])) machineIdx = i
+    if (absentIdx === -1 && SMOKE_ABSENT_LINE_RE.test(lines[i])) absentIdx = i
+  }
+  // 目标行渲染（passed 双形态：command 含 ｜/| 时单行管道形态会字段截断 → 降多行 YAML 形态；
+  // exitCode/logPath 非法空值如实渲染——收取侧 fail-closed 不收，postcheck 对比兜底）
+  let targetLines
+  if (state === 'passed') {
+    const command = String(smoke.command || '')
+    const exitVal = typeof smoke.exitCode === 'number' ? smoke.exitCode : ''
+    const noteLine = `<!-- smoke 机器段（CLI ensure 注入，source: ${SMOKE_RECEIPT_SOURCE_MARK}）——唯一事实源是 .runtime/verify-quality-scan-${changeName}.json 的 smokeResult，agent 不可改写/删除（verify 一致性抽查会打回）；ranAt 实录：${smoke.ranAt || '未知'}，durationMs：${typeof smoke.durationMs === 'number' ? smoke.durationMs : '未知'} -->`
+    targetLines = /[|｜]/.test(command)
+      ? [
+        noteLine,
+        '- claim: commands.smoke CLI 亲跑',
+        `  command: ${command}`,
+        `  exit: ${exitVal}`,
+        `  log: ${smoke.logPath || ''}`,
+        `  source: ${SMOKE_RECEIPT_SOURCE_MARK}`,
+      ]
+      : [
+        noteLine,
+        `- claim: commands.smoke CLI 亲跑 | command: ${command} | exit: ${exitVal} | log: ${smoke.logPath || ''} | source: ${SMOKE_RECEIPT_SOURCE_MARK}`,
+      ]
+  } else {
+    const absentNote = state === 'not-configured'
+      ? 'commands.smoke 未配置——配置 local.yaml 后下次 verify 亲跑并自动注入机器段'
+      : `commands.smoke 已配置但未绿跑（${smoke.reason || '失败/超时'}）——修复后重跑 verify 亲测自动更新本段`
+    targetLines = [`<!-- smoke 机器段缺态：${state}（${absentNote}）source: ${SMOKE_RECEIPT_SOURCE_MARK} -->`]
+  }
+  // 幂等/态迁移：同态 CLI 行在场 → no-op；异态（含旧缺态行 / 机器段行）→ 原位替换；缺 → 段内末尾注入
+  const inPlaceIdx = machineIdx !== -1 ? machineIdx : absentIdx
+  if (state === 'passed' && machineIdx !== -1) return { changed: false, state, reason: '机器段已在场（幂等跳过）' }
+  if (state !== 'passed' && absentIdx !== -1) {
+    const am = lines[absentIdx].match(SMOKE_ABSENT_LINE_RE)
+    if (am && am[1] === state) return { changed: false, state, reason: `缺态标注已在场（${state}，幂等跳过）` }
+  }
+  try {
+    if (inPlaceIdx !== -1) {
+      // 原位替换（CLI 拥有行的态迁移；机器段行 1 行 ↔ 缺态行 1 行，多行 YAML 形态首行替换为整块）
+      let replaceEnd = inPlaceIdx + 1
+      if (SMOKE_MACHINE_CLAIM_RE.test(lines[inPlaceIdx]) && state !== 'passed') {
+        // 旧机器段是多行 YAML 形态时连带其缩进续行一并替换
+        while (replaceEnd < end && /^[ \t]+\w/.test(lines[replaceEnd])) replaceEnd++
+      }
+      lines.splice(inPlaceIdx, replaceEnd - inPlaceIdx, ...targetLines)
+    } else {
+      // 段内末尾注入（最后一个非空行之后）
+      let last = end - 1
+      while (last > hIdx && lines[last].trim() === '') last--
+      lines.splice(last + 1, 0, ...targetLines)
+    }
+    writeFileSync(mdPath, lines.join('\n'))
+  } catch (e) {
+    console.warn(`⚠️ smoke 机器段 ensure 落盘失败（fail-soft，不阻断）: ${e && e.message ? e.message : e}`)
+    return { changed: false, state, reason: '落盘失败' }
+  }
+  return { changed: true, state }
+}
+
 /**
  * 结论草稿槽行预填（P0-1 前置三，noai-ir-roadmap §3）：机械事实全绿时把骨架「结论枚举：」
  * 待填槽替换为 PASS 草稿——显式「草稿待确认」内联标注（非默认值语义），agent 复核后可改写；
@@ -2085,6 +3347,10 @@ export function generateVerifyResultSkeleton(result) {
     '## 探针结果（CLI 机械预填） [层：可复跑探针——gate 抽查防篡改]',
     renderVerifyProbesReport(result),
     '',
+    // 接口验证覆盖矩阵段（task-04 / FR-05）：紧随探针结果章（probe7 矩阵渲染面之后的独立
+    // ## 章节）；result 无 apiFace 键（存量调用方/合成 result）→ 空面渲染「无接口面」注记，零回归。
+    ...renderApiCoverageMatrixLines(result.apiFace),
+    '',
     '## 测试结果 [层：确定性检查——CLI 实测对账]',
     '<!--TODO: 测试命令 + 结果（通过数/失败数；known_failures 豁免逐条注明）-->', /* probe1-noqa */
     '',