sillyspec 3.28.9 → 3.28.10

package/src/verify-probes.js

@@ -5,7 +5,8 @@
  * verify-probes.md 模板定义六个探针，agent 此前逐条手跑 grep/递归查找/git 对账再手工拼表格。
  * 本模块把纯机械的四个探针命令化（语义判断的留 agent，输出里显式标注）：
  *   探针1 未实现标记扫描：design §6 清单的具体文件逐行 grep TODO/FIXME/尚未实现 等
- *   探针3 测试覆盖：逐 task 按 allowed_paths 定位模块目录，递归找测试文件（co-located tests/ 陷阱）
+ *   探针3 测试覆盖：逐 task 按 allowed_paths 定位模块目录，递归找测试文件（co-located tests/ 陷阱
+ *        + JVM src/test/<lang> 同包镜像根——Maven/Gradle 布局测试与 main 侧永不 co-located）
  *   探针5 API 契约对账：复用 contract-matrix.verifyApiParity（endpoints.json × 前端调用）+ 表格渲染
  *   探针6 删除对账：git diff --name-status HEAD 的 D/R × design 声明操作三态判定
  *   探针7 验收×测试覆盖矩阵：task 卡 acceptance 自解析（jsYaml，string/array 双形态）+ 双源结构
@@ -21,7 +22,7 @@
  * 供事后独立复跑审计；重复 --init 覆盖为最近一次 init 快照）。
  */
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs'
-import { join, dirname, basename } from 'path'
+import { join, dirname, basename, resolve, isAbsolute } from 'path'
 import jsYaml from 'js-yaml'
 import { gitQuiet } from './git-helper.js'
 import {
@@ -29,13 +30,47 @@ import {
 } from './verify-facts-schema.js'
 import { parseFileChangeListDetailed } from './change-list.js'
 import { parseDecisions } from './decision-distill.js'
-import { parseAllowedPaths } from './stages/plan-postcheck.js'
+import { parseAllowedPaths, parseRepo, parseRepoRegistry } from './stages/plan-postcheck.js'
 import { verifyApiParity, _readWorktreeMeta } from './contract-matrix.js'
 import { splitOwnVsForeignDiffFiles } from './foreign-declared.js'
 import { resolveSpecDir, resolveRuntimeRoot, detectWorktreeSpecDrift } from './run/shared.js'
 
-const TODO_MARKER_RE = /尚未实现|TODO|FIXME|HACK|XXX/
-const TEST_FILE_RE = /test|spec/i
+// 探针1 未实现标记匹配（坑 probe1-literal-false-positive，2026-09-15 复盘实证：16 命中全
+// 字面误报——TODO_FLAG_TODO 业务常量、「XXX完成处置」中文占位模板）。口径分三级：
+// - 尚未实现：中文短语高置信，保持子串匹配；
+// - TODO/FIXME/HACK：ASCII 标识符边界匹配——TODO_FLAG_TODO / parseHackArgs 等标识符内部不再
+//   命中（两侧任一边贴 [A-Za-z0-9_] 即视为标识符成分）；
+// - XXX：边界匹配且前或后紧邻 CJK 表意字符即排除——「XXX完成处置」「订单XXX号」类中文占位
+//   模板不再命中（独立代码注释 `XXX:` / `// XXX fix` 紧邻标点空白，仍命中）。
+const CJK_IDEOGRAPH_CLASS = '\\u4e00-\\u9fff\\u3400-\\u4dbf'
+const TODO_ASCII_MARKER_RE = new RegExp(`(^|[^A-Za-z0-9_])(?:TODO|FIXME|HACK)(?![A-Za-z0-9_])`)
+const XXX_MARKER_RE = new RegExp(`(^|[^A-Za-z0-9_${CJK_IDEOGRAPH_CLASS}])XXX(?![A-Za-z0-9_${CJK_IDEOGRAPH_CLASS}])`)
+export function isUnimplementedMarkerLine(line) {
+  if (line.includes('尚未实现')) return true
+  if (TODO_ASCII_MARKER_RE.test(line)) return true
+  if (XXX_MARKER_RE.test(line)) return true
+  return false
+}
+// 测试文件名判定（坑 probe3-testname-false-positive，2026-09-15 EHS 生产实证：model 目录下
+// TestData.java 数据夹具被旧 /test|spec/i 子串命中 → task-01 假绿「找到 1 个测试文件」；
+// specification.md / contest.css 同族反向噪音）。三路命中，任一即测试文件：
+// - 分隔符分词（按非字母数字切段）含 test/tests/spec/specs —— foo.test.js、test_utils.py、foo-spec.ts
+// - 裸词文件名（去扩展名即上述词，大小写归一）—— test.js、Tests.java
+// - 驼峰末段后缀 Test/Tests/Spec/Specs/IT（Java/Kotlin 惯例 FooTest/FooIT）——只认末位驼峰段：
+//   RpFlowEngineTest 命中；TestData/TestUtil/TestMain（Test 是首段=夹具命名惯势）不命中
+// 取向：漏检罕见命名（FooTestCase/TestFoo 前缀式）→ ⚠️ 落 agent 手查（fail-visible 可接受）；
+// 假绿掩盖真缺测是 fail-hidden，更糟——宁紧勿松。
+const TEST_NAME_TOKENS = new Set(['test', 'tests', 'spec', 'specs'])
+const TEST_NAME_SUFFIXES = new Set(['Test', 'Tests', 'Spec', 'Specs', 'IT'])
+export function isTestFileName(name) {
+  const stem = String(name || '').replace(/\.[^.]+$/, '')
+  if (!stem) return false
+  if (TEST_NAME_TOKENS.has(stem.toLowerCase())) return true
+  const tokens = stem.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean)
+  if (tokens.some(t => TEST_NAME_TOKENS.has(t))) return true
+  const lastHump = stem.match(/(?:[A-Z][a-z0-9]*|[A-Z]+)$/)
+  return !!lastHump && TEST_NAME_SUFFIXES.has(lastHump[0])
+}
 const PROBE1_MAX_MATCHES = 200
 
 /**
@@ -89,7 +124,7 @@ function findTestFiles(rootDir, cwd, cap = 10) {
       const full = join(d, e.name)
       if (e.isDirectory()) {
         if (!skip.has(e.name)) walk(full)
-      } else if (e.isFile() && TEST_FILE_RE.test(basename(e.name))) {
+      } else if (e.isFile() && isTestFileName(e.name)) {
         found.push(full.split('\\').join('/').replace(cwd.split('\\').join('/').replace(/\/$/, '') + '/', ''))
         if (found.length >= cap) return
       }
@@ -99,7 +134,179 @@ function findTestFiles(rootDir, cwd, cap = 10) {
   return found
 }
 
-// ── 探针 7（验收×测试覆盖矩阵，2026-09-14-acceptance-test-matrix FR-01）常量与纯函数 ──
+// ── 探针 8（载荷字段契约对账，2026-09-16 EHS 二次独立复核驱动）常量与纯函数 ──
+// 5 个 P1 里 4 处是字段/载荷错位（leaderUserId↔rpLeaderUserId 三处 Jackson 静默丢弃、小程序
+// 缺发 reportOrgId、sourceShdId↔safelyHiddenId、report_org_name NOT NULL 边界）——探针 5 只对
+// 账 method+path（URL 级），载荷级错位零覆盖。本探针三面启发式比对（advisory，命中≠结论）：
+// 前端请求载荷键 × 后端 Java 字段（归一化覆盖）∪ 子串疑似错位配对 ∪ SQL NOT NULL 列缺送核对。
+const PROBE8_HEADING = '#### 探针 8：载荷字段契约对账（advisory）'
+// 服务端填充/标准列豁免（NOT NULL 但不该由前端送）
+const PROBE8_SERVER_FILLED_RE = /^(id|create_by|create_date|update_by|update_date|remarks|dept_id|tenant_id|del_flag)$/i
+
+/**
+ * 归一化键：小写 + 剥全部分隔线（snake/连字符）——两侧同构（rp_category / rpCategory /
+ * rp-category → rpcategory）。注意不能「小写后再 camel 化」（会单侧引入大写不对称）。
+ */
+const normFieldKey = (s) => String(s || '').trim().toLowerCase().replace(/[_-]/g, '')
+
+/** Java private 字段名提取（全大写常量 TODO_FLAG_TODO 排除——EHS 探针1 同款教训） */
+export function extractJavaFields(text) {
+  const names = new Set()
+  const re = /private\s+(?:static\s+|final\s+)*[\w.$<>[\]]+\s+([A-Za-z_][A-Za-z0-9_]*)\s*[;=]/g
+  let m
+  while ((m = re.exec(String(text || ''))) !== null) {
+    if (!/^[A-Z0-9_]+$/.test(m[1])) names.add(m[1])
+  }
+  return names
+}
+
+/** SQL CREATE TABLE 行的 NOT NULL 业务列（审计列豁免） */
+export function extractSqlNotNullColumns(text) {
+  const cols = new Set()
+  for (const line of String(text || '').split('\n')) {
+    const m = line.match(/^\s*`?([a-zA-Z_][a-zA-Z0-9_]*)`?\s+(?:varchar|char|int|integer|bigint|decimal|datetime|date|timestamp|text|double|float)\b[^,]*NOT NULL\b/i)
+    if (m && !PROBE8_SERVER_FILLED_RE.test(m[1])) cols.add(m[1])
+  }
+  return cols
+}
+
+/**
+ * 请求载荷键提取：apiFetch/request/axios/$http/fetch( 调用行后 8 行窗口内的对象键
+ * （key: 后随值起始为字面量/对象/数组/null/undefined/负号——排除 case/三元等形态）。
+ * UI 本地态对象（请求区外）天然不收。
+ */
+export function extractPayloadKeys(text) {
+  const keys = new Set()
+  const lines = String(text || '').split('\n')
+  for (let i = 0; i < lines.length; i++) {
+    if (!/\b(apiFetch|request|axios|\$http|fetch)\s*\(/.test(lines[i])) continue
+    for (let j = i; j < Math.min(i + 8, lines.length); j++) {
+      for (const m of lines[j].matchAll(/(?:^|[{,(\s])([A-Za-z_][A-Za-z0-9]*)\s*:\s(?:["'`\d{[tfn-]|null\b|undefined\b)/g)) {
+        keys.add(m[1])
+      }
+    }
+  }
+  return keys
+}
+
+/**
+ * 探针 8 主体：design 清单三面文件（Java/SQL/前端）→ 双根（主仓 ∪ worktree）∪ 跨仓注册仓根
+ * 读取 → 归一化比对。advisory：所有输出是「候选」不是结论（UI 本地态键/服务端填充列会自然
+ * 出现在差异里，agent 逐条复核——口径注记随渲染输出）。
+ * @param {{ specBase: string, cwd: string, wtRoot?: string|null, changeName: string }} args
+ * @returns {{applicable, backendFieldCount, feKeyCount, notNullCount, javaFileCount, sqlFileCount, feFileCount,
+ *   mispairs: Array<{fe,be}>, feOnly: string[], missingNotNull: Array<{col}>, notes: string[]}}
+ */
+export function runProbe8PayloadParity({ specBase, cwd, wtRoot = null, changeName }) {
+  const out = {
+    applicable: false, backendFieldCount: 0, feKeyCount: 0, notNullCount: 0,
+    javaFileCount: 0, sqlFileCount: 0, feFileCount: 0,
+    mispairs: [], feOnly: [], missingNotNull: [], notes: [],
+  }
+  if (!specBase || !changeName) return out
+  const designPath = join(specBase, 'changes', changeName, 'design.md')
+  if (!existsSync(designPath)) return out
+  let registry = new Map()
+  try {
+    const yamlPath = join(specBase, 'local.yaml')
+    if (existsSync(yamlPath)) registry = parseRepoRegistry(readFileSync(yamlPath, 'utf8'))
+  } catch { /* 注册表不可读 → 跨仓条目落未注册注记 */ }
+  const detailed = parseFileChangeListDetailed(designPath, { repoKeys: [...registry.keys()] })
+
+  const readEntry = (e) => {
+    // NEW: 待建前缀剥离（坑 probe1-new-prefix-miss 同款）：design 清单的 NEW: 是新建意图标记，
+    // 文件系统实体无前缀——按目标路径读。
+    const probePath = String(e.path).replace(/^NEW:\s*/, '')
+    // 未注册跨仓前缀兜底识别（change-list 只对注册 key 落 e.repo；未注册 key 整条 path 保留
+    // cross-repo: 前缀原样）——现身「未注册」注记而非静默不可读。
+    const crPrefix = probePath.match(/^cross-repo:([A-Za-z0-9_.\-]+):(.*)$/)
+    if (e.repo || crPrefix) {
+      const key = e.repo || (crPrefix && crPrefix[1])
+      const relPath = e.repo ? probePath : crPrefix[2]
+      const raw = registry.get(key)
+      if (!raw) { out.notes.push(`repo「${key}」未在 local.yaml repos 注册——该仓前端文件未进探针 8 比对`); return null }
+      const root = isAbsolute(raw) ? raw : resolve(cwd, raw)
+      try { return readFileSync(join(root, relPath), 'utf8') } catch { out.notes.push(`跨仓文件不可读：${key}:${relPath}`); return null }
+    }
+    // 主仓 ∪ worktree 双根（与探针 1 同款回退）
+    for (const base of [cwd, wtRoot].filter(Boolean)) {
+      try { return readFileSync(join(base, probePath), 'utf8') } catch { /* 试下一根 */ }
+    }
+    return null
+  }
+
+  const backendFields = new Set()
+  const notNullCols = new Set()
+  const feKeys = new Set()
+  for (const e of detailed) {
+    if (!e.path || e.path.startsWith('.sillyspec/')) continue
+    const text = readEntry(e)
+    if (text == null) continue
+    if (e.path.endsWith('.java')) {
+      out.javaFileCount++
+      for (const f of extractJavaFields(text)) backendFields.add(f)
+    } else if (e.path.endsWith('.sql')) {
+      out.sqlFileCount++
+      for (const c of extractSqlNotNullColumns(text)) notNullCols.add(c)
+    } else if (/\.(js|jsx|ts|tsx)$/.test(e.path)) {
+      out.feFileCount++
+      for (const k of extractPayloadKeys(text)) feKeys.add(k)
+    }
+  }
+  // 后端零面（无 Java 无 SQL）→ 不适用（纯前端/文档变更不打扰）
+  if (out.javaFileCount === 0 && out.sqlFileCount === 0) return out
+  out.applicable = true
+
+  const backendNorm = new Map() // norm → 原名
+  for (const f of backendFields) backendNorm.set(normFieldKey(f), f)
+  const feNorm = new Map()
+  for (const k of feKeys) feNorm.set(normFieldKey(k), k)
+  // 配对 token（camelCase/snake 切词；单字符段只保留 id）——子串关系抓 leaderUserId⊂rpLeaderUserId，
+  // token 重叠（Jaccard≥0.6）抓语义近形 punishedDutyUserId↔punishedLeaderUserId（EHS 二次复核
+  // 两类实证形态）。并列取长度差最小者（leaderUserId 优先配 rpLeaderUserId 而非更长的
+  // punishedLeaderUserId）。
+  const fieldTokens = (s) => String(s).replace(/([a-z0-9])([A-Z])/g, '$1 $2').split(/[^A-Za-z0-9]+/)
+    .map(t => t.toLowerCase()).filter(t => t.length > 1 || t === 'id')
+
+  for (const [nk, original] of feNorm) {
+    if (backendNorm.has(nk)) continue // 归一化覆盖（rpCategory ↔ rp_category）
+    const feToks = fieldTokens(original)
+    let best = null
+    let bestScore = 0
+    let bestLenPenalty = Infinity
+    for (const [bn, beOrig] of backendNorm) {
+      let score = 0
+      if ((bn.includes(nk) || nk.includes(bn)) && Math.min(bn.length, nk.length) >= 4) score = 1
+      else if (feToks.length >= 2) {
+        const bt = fieldTokens(beOrig)
+        if (bt.length >= 2) {
+          const inter = feToks.filter(t => bt.includes(t)).length
+          const union = new Set([...feToks, ...bt]).size
+          if (union > 0) score = inter / union
+        }
+      }
+      if (score <= 0) continue
+      const lenPenalty = Math.abs(bn.length - nk.length)
+      if (score > bestScore || (score === bestScore && lenPenalty < bestLenPenalty)) {
+        bestScore = score
+        bestLenPenalty = lenPenalty
+        best = beOrig
+      }
+    }
+    if (best && bestScore >= 0.6) out.mispairs.push({ fe: original, be: best })
+    else out.feOnly.push(original)
+  }
+  for (const col of notNullCols) {
+    const nc = normFieldKey(col)
+    if (!feNorm.has(nc) && !backendNorm.has(nc)) out.missingNotNull.push({ col })
+  }
+  out.backendFieldCount = backendFields.size
+  out.feKeyCount = feKeys.size
+  out.notNullCount = notNullCols.size
+  return out
+}
+
+
 const PROBE7_HEADING = '#### 探针 7：验收×测试覆盖矩阵'
 // execute run id 格式（与 task-review.js isValidExecuteRunId 同口径锚定，防提示词注入/路径穿越）
 const PROBE7_EXEC_RUN_ID_RE = /^exec-\d{4}-\d{2}-\d{2}-\d{6}(?:-[a-z0-9]{1,8}){0,2}$/
@@ -137,7 +344,7 @@ export function parseTaskAcceptance(content) {
 /**
  * allowed_paths 条目是否测试形态（结构归属面）：test/ 前缀，或文件名含 .test. / _test. / spec
  * 惯例（(?:^|[._-])test(?:[._-]|$) 覆盖 foo.test.mjs / foo_test.js / test-foo.js 三形）。
- * 比探针 3 的存在性面（TEST_FILE_RE 子串宽松匹配）严格——这是 3/7 口径差异的落点。
+ * 比探针 3 的存在性面（isTestFileName 文件名形态判定，宽松存在性提示）严格——这是 3/7 口径差异的落点。
  */
 function isProbe7TestPath(p) {
   const posix = String(p).split('\\').join('/')
@@ -324,6 +531,11 @@ function renderProbe7Lines(p7) {
   }
   L.push('<!-- 口径注记：探针 3 = 模块目录递归存在性面（allowed_paths 目录附近有没有测试）；探针 7 = allowed_paths ∪ review changedFiles 结构归属承接面（每条 acceptance 由哪些测试承接）；两者并排冲突以 7 为准。判定枚举（四选一）：covered / partial / uncovered / non-testable（文档/部署类显式逃生门）。关键词命中只是提示，命中≠判定。 -->')
   L.push('<!-- 预填说明（ql-20260915-004）：判定列为 CLI 机械预填，agent 逐格复核改写——规则：无归属→uncovered（文档/部署/doc/deploy/manual/config 类词→non-testable）；有归属且命中≥1→covered；有归属零命中→partial。证据列给首命中 file:line 锚点或人工核验提示。预填≠结论：与事实不符的格子必须改写（枚举须保持 covered/partial/uncovered/non-testable 纯值，备注写在证据列）。 -->')
+  // 零自动化承接计数（坑 review-zero-coverage-unwalked，2026-09-16 EHS 二次复核实证：execute
+  // 期 review 走查面事实上跟着测试覆盖走——「新增-部门支线测试充分，编辑路径与相关方支线
+  // 零覆盖」恰是 5 个 P1 的藏身处。矩阵渲染时顺带计数零承接条目，verify 复核强制显式走查
+  // 这些路径并在「代码审查」节登记走查结论——把二次复核「提前兑现移交项」的打法固化）。
+  let zeroCoverage = 0
   for (const t of (p7.tasks || [])) {
     L.push('')
     L.push(`**${t.task}**`)
@@ -342,9 +554,14 @@ function renderProbe7Lines(p7) {
         ? `${h.terms.map(x => mdEscapeCell(x)).join('、')}（${(h.files || []).map(f => `\`${f}\``).join('、')}）`
         : '—'
       const pre = prefillMatrixCells(item, t.testFiles, h)
+      if (pre.verdict === 'uncovered' || pre.verdict === 'partial') zeroCoverage++
       L.push(`| ${mdEscapeCell(item)} | ${attribCell} | ${hintCell} | ${pre.verdict} | ${pre.evidence} |`)
     })
   }
+  if (zeroCoverage > 0) {
+    L.push('')
+    L.push(`- ⚠️ 零/半自动化承接条目 ${zeroCoverage} 条——这些路径无测试兜底，verify 复核必须**显式走查**（尤其编辑/更新链路与非主分支流：二次复核实证它们正是 P1 藏身处），走查结论登记进「代码审查」节`)
+  }
   return L
 }
 
@@ -394,7 +611,7 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
       const lines = readFileSync(abs, 'utf8').split('\n')
       lines.forEach((line, i) => {
         if (probe1.matches.length >= PROBE1_MAX_MATCHES) return
-        if (TODO_MARKER_RE.test(line)) probe1.matches.push({ file: probePath, line: i + 1, content: line.trim().slice(0, 160) })
+        if (isUnimplementedMarkerLine(line)) probe1.matches.push({ file: probePath, line: i + 1, content: line.trim().slice(0, 160) })
       })
     } catch {
       probe1.skippedFiles.push(e.path)
@@ -409,8 +626,23 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
     let allowed = []
     if (existsSync(cardPath)) allowed = parseAllowedPaths(readFileSync(cardPath, 'utf8'))
     const moduleDirs = [...new Set(allowed.map(p => dirname(p.split('\\').join('/'))).filter(d => d && d !== '.'))]
-    const testFiles = []
+    // JVM 镜像测试根（坑 probe3-java-mirror-blind，2026-09-15 EHS 生产实证 task-02~06 五连
+    // 假⚠️）：Maven/Gradle 布局测试在 src/test/<lang> 同包镜像树，与 src/main 侧永不
+    // co-located——只递归 allowed_paths 目录（全在 main 侧）必然落空。对命中 src/main/<lang>
+    // 的目录补推镜像目录进扫描集（主仓或 worktree 任一侧存在才列/才扫——不存在的镜像根=
+    // 该包真无测试，保持 ⚠️ 真信号）。
+    const mirrorDirs = []
     for (const d of moduleDirs) {
+      const m = d.match(/^(.*\/src\/)main(\/(?:java|kotlin|scala|groovy)(?:\/.*)?)$/)
+      if (!m) continue
+      const mirror = `${m[1]}test${m[2]}`
+      if (mirrorDirs.includes(mirror) || moduleDirs.includes(mirror)) continue
+      if (existsSync(join(cwd, mirror)) || (wtRoot && wtRoot !== cwd && existsSync(join(wtRoot, mirror)))) {
+        mirrorDirs.push(mirror)
+      }
+    }
+    const testFiles = []
+    for (const d of [...moduleDirs, ...mirrorDirs]) {
       // 双根并集扫描（坑 probe3-worktree-test-false-negative，2026-09-10 驾驭小结第五批②，
       // 用户实证 5 条假 warning）：apply 前新测试文件只在 worktree（untracked），而模块目录在
       // 主仓**已存在**——旧「主仓目录缺失才回退 worktree」条件不触发，探针 3 报「未找到测试
@@ -428,6 +660,7 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
     probe3.tasks.push({
       task: taskId,
       moduleDirs,
+      mirrorDirs,
       testFiles: testFiles.slice(0, 10),
       testFileCount: testFiles.length,
       hasTest: testFiles.length > 0,
@@ -438,6 +671,19 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
   // ── 探针 5：API 契约对账（复用 verifyApiParity：endpoints.json × 前端调用）──
   const runtimeRoot = resolveRuntimeRoot({ specRoot: specDir }, specBase)
   const probe5 = verifyApiParity(specBase, cwd, runtimeRoot, changeName)
+  // 跨仓 task 卡计数（坑 probe5-cross-repo-scope-blindness，2026-09-15 复盘：跨仓仓的前端
+  // 调用不在 parity 扫描根内，「frontend 0 调用」会被误读为漏配——渲染侧显式注记扫描面
+  // 边界。计数失败按 0（不渲染注记，零新增失败面）。
+  try {
+    const tasksDir = join(changeDir, 'tasks')
+    if (changeName && existsSync(tasksDir)) {
+      let crossRepoCardCount = 0
+      for (const f of readdirSync(tasksDir).filter(n => /^task-\d+\.md$/.test(n))) {
+        if (parseRepo(readFileSync(join(tasksDir, f), 'utf8'))) crossRepoCardCount++
+      }
+      if (crossRepoCardCount > 0) probe5.crossRepoCardCount = crossRepoCardCount
+    }
+  } catch { /* tasks 目录不可读 → 不注记 */ }
 
   // ── 探针 6：代码删除对账（git diff --name-status HEAD 的 D/R × design 声明三态）──
   const probe6 = { deletions: [], unavailable: false, note: '以 git 事实为准（真实 > 声明）；是否 FAIL blocker 由 agent 诚实判定' }
@@ -510,7 +756,16 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
     }
   }
 
-  return { probe1, probe3, probe5, probe6, probe7 }
+  // ── 探针 8：载荷字段契约对账（advisory；2026-09-16 EHS 二次复核驱动——字段错位族 4 处
+  // P1 是 URL 级 parity 的真空带）。fail-soft：内部全兜，异常降级 not-applicable 不炸整体。──
+  let probe8 = { applicable: false, mispairs: [], feOnly: [], missingNotNull: [], notes: [] }
+  try {
+    probe8 = runProbe8PayloadParity({ specBase, cwd, wtRoot, changeName })
+  } catch (e) {
+    probe8.notes = [`探针 8 执行失败（fail-soft 跳过）：${e && e.message ? e.message : e}`]
+  }
+
+  return { probe1, probe3, probe5, probe6, probe7, probe8 }
 }
 
 /**
@@ -543,9 +798,13 @@ export function renderVerifyProbesReport(result) {
       if (!t.located) {
         L.push(`- ⚠️ ${t.task}: 无 task 卡/allowed_paths，无法定位模块目录（agent 手查）`)
       } else if (t.hasTest) {
-        L.push(`- ✅ ${t.task}: 模块目录（${t.moduleDirs.join('、')}）找到 ${t.testFileCount} 个测试文件（${t.testFiles.slice(0, 5).join('、')}${t.testFileCount > 5 ? ' …' : ''}）`)
+        const mirrorNote = (t.mirrorDirs && t.mirrorDirs.length > 0)
+          ? `；JVM 镜像测试根（${t.mirrorDirs.join('、')}）` : ''
+        L.push(`- ✅ ${t.task}: 模块目录（${t.moduleDirs.join('、')}）${mirrorNote}找到 ${t.testFileCount} 个测试文件（${t.testFiles.slice(0, 5).join('、')}${t.testFileCount > 5 ? ' …' : ''}）`)
       } else {
-        L.push(`- ⚠️ ${t.task}: 模块目录（${t.moduleDirs.join('、')}）递归未找到测试文件（含 co-located tests/）`)
+        const mirrorNote = (t.mirrorDirs && t.mirrorDirs.length > 0)
+          ? '（含 co-located tests/ 与 JVM src/test 镜像根）' : '（含 co-located tests/）'
+        L.push(`- ⚠️ ${t.task}: 模块目录（${t.moduleDirs.join('、')}）递归未找到测试文件${mirrorNote}`)
       }
     }
   }
@@ -564,6 +823,9 @@ export function renderVerifyProbesReport(result) {
 
   L.push('#### 探针 5：API Contract Parity')
   L.push(`- ${probe5.summary || `backend ${probe5.backendCount ?? 0} 端点 / frontend ${probe5.frontendCount ?? 0} 调用`}`)
+  if (probe5.crossRepoCardCount > 0) {
+    L.push(`- ℹ️ parity 扫描面只含主仓——另有 ${probe5.crossRepoCardCount} 张跨仓 task 卡的仓不在扫描根内，跨仓前端调用/端点请到对应仓核对（D-004 跨仓对账不在本变更范围）`)
+  }
   if ((probe5.scanRoots || []).length > 1) {
     L.push(`- ℹ️ 后端端点比对集为多根并集（主仓既有 ∪ worktree 新增 ∪ 存量 artifact），共扫 ${probe5.scanRoots.length} 个根`)
   }
@@ -581,7 +843,16 @@ export function renderVerifyProbesReport(result) {
     L.push('- ❌ contract gap 是真实集成缺陷——诚实判 FAIL 并回 execute 补端点（CLI 仅 advisory 不硬阻断）')
   }
   if ((probe5.unusedBackend || []).length > 0) {
-    L.push(`- ⚠️ ${probe5.unusedBackend.length} 个后端端点前端未调用（warning 不阻断）：${probe5.unusedBackend.slice(0, 5).map(u => `${u.method} ${u.path}`).join('、')}${probe5.unusedBackend.length > 5 ? ' …' : ''}`)
+    // unused 分层展示（probe5-unused-stock-noise）：本变更相关（artifact 端点集内）逐条列出，
+    // 存量其余折叠计数——EHS 实证 490 个存量端点刷屏淹没了真信号。旧字段形态（无分层）零回归全列。
+    const relevant = Array.isArray(probe5.unusedChangeRelevant) && probe5.unusedChangeRelevant.length >= 0
+      ? probe5.unusedChangeRelevant : probe5.unusedBackend
+    const stock = typeof probe5.unusedStockCount === 'number' ? probe5.unusedStockCount : 0
+    L.push(`- ⚠️ ${relevant.length} 个本变更端点前端未调用（warning 不阻断）：${relevant.slice(0, 5).map(u => `${u.method} ${u.path}`).join('、')}${relevant.length > 5 ? ' …' : ''}`)
+    if (stock > 0) L.push(`- ℹ️ 另有 ${stock} 个存量端点未调用（他模块存量噪音，已折叠不逐条列出）`)
+  }
+  if ((probe5.crossRepoNotes || []).length > 0) {
+    for (const n of probe5.crossRepoNotes.slice(0, 5)) L.push(`- ℹ️ ${n}`)
   }
   L.push('')
 
@@ -596,9 +867,43 @@ export function renderVerifyProbesReport(result) {
     }
   }
   L.push(`- ℹ️ ${probe6.note}`)
+  L.push('')
+  L.push(...(renderProbe8Lines(result.probe8 || { applicable: false, mispairs: [], feOnly: [], missingNotNull: [], notes: [] })))
   return L.join('\n')
 }
 
+/**
+ * 渲染探针 8 段（advisory 口径注记随段输出——命中≠结论，agent 逐条复核）。
+ * @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[]}} p8
+ * @returns {string[]} 行数组（含段标题）
+ */
+function renderProbe8Lines(p8) {
+  const L = [PROBE8_HEADING]
+  if (!p8 || !p8.applicable) {
+    L.push('- 不适用（清单无 Java/SQL 后端面，或 design.md 缺失）')
+    for (const n of (p8 && p8.notes) || []) L.push(`- ℹ️ ${n}`)
+    return L
+  }
+  L.push('<!-- 口径注记：静态启发式对账——前端请求载荷键（apiFetch/request/axios/fetch 调用邻近对象键）× 后端 Java private 字段（归一化覆盖）∪ 疑似错位配对 ∪ SQL NOT NULL 列缺送。命中≠结论：UI 本地态键/服务端填充列会自然出现在差异里，agent 逐条复核（2026-09-16 EHS 二次复核实证：leaderUserId↔rpLeaderUserId 字段错位致相关方支线三端不可用、缺发 reportOrgId 致小程序开立被拒——URL 级 parity 抓不住载荷级错位）。 -->')
+  L.push(`- ℹ️ 比对面：前端载荷键 ${p8.feKeyCount ?? 0}（${p8.feFileCount ?? 0} 前端文件）× 后端字段 ${p8.backendFieldCount ?? 0}（${p8.javaFileCount ?? 0} Java 文件）+ NOT NULL 列 ${p8.notNullCount ?? 0}（${p8.sqlFileCount ?? 0} SQL 文件）`)
+  if ((p8.mispairs || []).length > 0) {
+    L.push(`- ⚠️ 疑似字段错位配对（前后端名近形，人工核实一对一映射）：${p8.mispairs.slice(0, 8).map(p => `${p.fe} ↔ ${p.be}`).join('、')}${p8.mispairs.length > 8 ? ` …共 ${p8.mispairs.length} 对` : ''}`)
+  }
+  if ((p8.feOnly || []).length > 0) {
+    L.push(`- ℹ️ 前端独有键（候选 UI 本地态/字段错位/跨层无关）：${p8.feOnly.slice(0, 10).join('、')}${p8.feOnly.length > 10 ? ` …共 ${p8.feOnly.length} 个` : ''}`)
+  }
+  if ((p8.missingNotNull || []).length > 0) {
+    L.push(`- ⚠️ NOT NULL 列前端未见（候选必填缺送/服务端填充）：${p8.missingNotNull.slice(0, 8).map(c => c.col).join('、')}${p8.missingNotNull.length > 8 ? ` …共 ${p8.missingNotNull.length} 个` : ''}`)
+  }
+  if ((p8.mispairs || []).length === 0 && (p8.missingNotNull || []).length === 0) {
+    L.push('- ✅ 载荷字段面零疑似差异（归一化覆盖 + NOT NULL 全见）')
+  }
+  for (const n of p8.notes || []) L.push(`- ℹ️ ${n}`)
+  return L
+}
+
 /**
  * 从 runVerifyProbes 结果构造 verify-facts.json 机器底稿对象（P3b 可复跑审计底稿）。
  * 命令行统一 `sillyspec verify-probes --change <name>`；指标 fail-soft——字段不可得时少列
@@ -617,6 +922,7 @@ export function buildVerifyFacts(result, { changeName, now } = {}) {
   const p3 = (result && result.probe3) || {}
   const p5 = (result && result.probe5) || {}
   const p6 = (result && result.probe6) || {}
+  const p8 = (result && result.probe8) || {}
   // v2（2026-09-08-ir-verify-facts）：probes 机器段原样；conclusion/tests/requiredEvidence/
   // runtimeEvidence/factsConsistency 五段是 slot-backfill/实测回填段（D-001@v2），--init 快照
   // 不落键（writeVerifyFacts 分段合并时保留既有固化段），由 backfillFactsFromMdAndTests 填。
@@ -655,6 +961,16 @@ export function buildVerifyFacts(result, { changeName, now } = {}) {
           unavailable: typeof p6.unavailable === 'boolean' ? p6.unavailable : undefined,
         }),
       },
+      probe8: {
+        command,
+        metrics: defined({
+          mispairs: len(p8.mispairs),
+          feOnly: len(p8.feOnly),
+          missingNotNull: len(p8.missingNotNull),
+          feKeys: num(p8.feKeyCount),
+          backendFields: num(p8.backendFieldCount),
+        }),
+      },
     },
   }
 }
@@ -717,6 +1033,36 @@ export function writeVerifyFacts(changeDir, result, changeName, opts = {}) {
  * @param {{ verifyMd: string, testCheckResult?: object|null }} opts
  * @returns {{ facts: object, conclusion: string|null, evidenceCount: number, receiptCount: number, testsBackfilled: boolean }}
  */
+// 移交项结构化（坑 handover-only-in-prose，2026-09-15/16 EHS 生产实证）：verify 结论
+// PASS WITH NOTES 的移交条目（环境阻断复跑/人工验收/待执行脚本）此前只活在结论槽正文
+// 叙述——后续独立复核发现被环境阻断 deferred 的集成测试里正藏着 5 个 P1；「移交项没有
+// 结构化清单 = 没人兜」。骨架新增「## 移交项（结构化）」章节（三列表格 + 类型枚举注释），
+// 本函数解析其表行为机器可读 items（facts.handover 回填 + advisory 判定用）。
+// 容错：占位行（<待填…）跳过；类型归一小写连字符（ENV-BLOCKED→env-blocked）；未知类型
+// 保留原值（advisory 面向 agent 复核，不静默丢弃）；非表格行（prose/注释）忽略。
+const HANDOVER_HEADING_RE = /^## 移交项（结构化）[^\n]*$/m
+export function parseHandoverRows(md) {
+  const text = String(md || '').replace(/\r\n/g, '\n')
+  const m = text.match(HANDOVER_HEADING_RE)
+  if (!m) return []
+  const after = text.slice(m.index + m[0].length)
+  const nextSection = after.match(/\n## /)
+  const section = nextSection ? after.slice(0, nextSection.index) : after
+  const items = []
+  for (const line of section.split('\n')) {
+    const row = line.match(/^\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]*?)\s*\|\s*$/)
+    if (!row) continue
+    const type = row[1].trim()
+    const item = row[2].trim()
+    const condition = row[3].trim()
+    if (type === '类型' || /^-{2,}$/.test(type.replace(/\|/g, ''))) continue // 表头/分隔行
+    if (type.startsWith('<') || item.startsWith('<')) continue // 骨架占位行
+    if (!type || !item) continue
+    items.push({ type: type.toLowerCase().replace(/[\s_]+/g, '-'), item, condition })
+  }
+  return items
+}
+
 export function backfillFactsFromMdAndTests(factsPath, { verifyMd, testCheckResult = null, conclusion = null }) {
   let facts = null
   try { facts = JSON.parse(readFileSync(factsPath, 'utf8')) } catch { /* 缺失见下 */ }
@@ -744,6 +1090,17 @@ export function backfillFactsFromMdAndTests(factsPath, { verifyMd, testCheckResu
   if (slots.hasReceiptSlot && slots.runtimeEvidence.length > 0) {
     facts.runtimeEvidence = slots.runtimeEvidence
   }
+  // 移交项结构化回填（handover-only-in-prose）：有有效行 → facts.handover 落盘（机器可读）；
+  // 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 }
+  }
+  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）。')
+  }
   let testsBackfilled = false
   if (testCheckResult && testCheckResult.status && testCheckResult.status !== 'skipped') {
     facts.tests = {
@@ -961,11 +1318,21 @@ export function generateVerifyResultSkeleton(result) {
     '',
     '> 探针结果已机械预填；其余章节把 `<!--TODO-->` 替换为真实内容。**结论只认「结论枚举：」槽行**——',
     '> 槽行留「<待填：三选一>」会被 gate 判不过（fail-closed），正文其他位置的 PASS/FAIL 字样不参与判定。',
+    '>',
+    '> 「层」=证据可核验性分层（非执行者声明）：「人工判断」指本节为语义判断，由执行 agent 填写、',
+    '> CLI 不机械复跑（gate 抽查 + 人类审批点复核兜底）；「可复跑探针/确定性检查/CLI 一致性校验」= gate 可机械复核段。',
     '',
     '## 结论 [层：人工判断]',
     '',
     '结论枚举：`<待填：三选一>`（把尖括号占位整体替换为 PASS / PASS WITH NOTES / FAIL 之一；一句话理由写在枚举后同行或下一行）',
     '',
+    '## 移交项（结构化） [层：人工判断——CLI 清单核验]',
+    '<!-- 结论=PASS WITH NOTES 时本节必填（prose 移交叙述转结构化，复跑/验收有据可查、agent 可恢复复跑）；结论=PASS/FAIL 写「无」 -->',
+    '<!-- 类型枚举：env-blocked（环境阻断，条件列必填复跑口径）/ manual-acceptance（人工验收，条件列必填验收步骤）/ db-script（待执行脚本，条件列必填执行环境与顺序）/ other -->',
+    '| 类型 | 条目 | 复跑/验收条件 |',
+    '|---|---|---|',
+    '| <待填：env-blocked / manual-acceptance / db-script / other> | <待填：移交条目> | <待填：复跑/验收条件> |',
+    '',
     '## 证据账（cannot_verify 任务） [层：人工判断——CLI 核验]',
     '<!-- 无 cannot_verify 任务时本节写「无」；有则逐 task 一行 -->',
     '- task-NN: <待填：三选一> | verifiedFiles: <精确路径，逗号分隔>（satisfied 必填；豁免时填 missing 并加（豁免：<一句话理由>）后缀）',
@@ -999,7 +1366,15 @@ export function generateVerifyResultSkeleton(result) {
     '<!--TODO: 关键命令输出/时间戳/commit hash 证据链；integration/deployment-critical 必填，按实际触碰的运行时组件写（启动命令/端点/请求响应/日志片段/生命周期终态断言/失败模式排除），未涉及的行写「不涉及」-->',
     '',
     '## 代码审查 [层：人工判断]',
-    '<!--TODO: 问题列表 + 总体评价-->',
+    '<!--TODO: 问题列表 + 总体评价。走查清单（零覆盖路径必查——探针 7 ⚠️ 条目即定向面）：',
+    '     ① 编辑/更新链路（回显、字段映射、残留态）——非新增主链路，实证盲区；',
+    '     ② 非主分支流（相关方/旁路支线等未走查路径）；',
+    '     ③ 守卫一致性：同资源端点的操作人/权限校验模式对比（实证 doSubmit 无操作人校验而 delete/withdraw 有——越权）；',
+    '     ④ 载荷字段契约（探针 8 ⚠️ 配对逐条核实）；',
+    '     ⑤ 分页/并发/事务原子性（无测试基建端的纯逻辑面）-->',
+    '',
+    '## 独立复核（可选回流槽） [层：人工判断——复核后追加]',
+    '<!-- verify 完成后的深度复核（独立子代理/二次审查）结论回流至此：缺陷分级（P1 功能不可用 / P2 需求子项 / P3 建议修）+ 修复证据链 + 对「结论枚举」的影响改写。无复核时本节写「无」或删除。复核结论不再只活在聊天记录（2026-09-16 EHS 二次复核实证：5 个 P1 只有聊天可查，变更档案仍写 PASS WITH NOTES）。 -->',
     '',
   ]
   return L.join('\n')