sillyspec 3.31.0 → 3.32.0

package/src/verify-postcheck.js

@@ -751,11 +751,16 @@ function parseFlowValue(flowText, key) {
  * @returns {string[]} 相对 cwd 的测试文件路径（posix 形态，已排序；无可发现 → []）
  */
 /**
- * 测试文件判定（polyglot，2026-09-24 deps-auto 泛化）：JS/TS 测试（*.test/spec.[cm]js/ts）
- * + Python 测试（test_*.py / *_test.py），任意目录深度（tests?/ 目录或散置均可）。
+ * 测试文件判定（polyglot，2026-09-24 deps-auto 泛化）：JS/TS 测试
+ * （*.test/spec.[cm]js/ts/jsx/tsx）+ Python 测试（test_*.py / *_test.py），
+ * 任意目录深度（tests?/ 目录或散置均可）。
+ * 2026-09-30 补 jsx|tsx（坑 dynamic-deps-e2e-vitest-exclude-false-red，用户授权修复）：
+ * 原正则漏配 .test.tsx/.spec.jsx——changedTests 拆分把自家 tsx 测试当 src、changedSrc
+ * 内容匹配又因 import 走别名而不中，自家单测反而不进依赖面（而 .spec.ts 的 e2e 文件
+ * 反倒经 changedTests 直入，被 vitest exclude 拦成假红）。
  */
 function isTestFilePath(p) {
-  return /\.(test|spec)\.[cm]?(js|ts)$/.test(p) || /(^|\/)test_[^\/]+\.py$/.test(p) || /(^|\/)[^\/]+_test\.py$/.test(p)
+  return /\.(test|spec)\.[cm]?(js|jsx|ts|tsx)$/.test(p) || /(^|\/)test_[^\/]+\.py$/.test(p) || /(^|\/)[^\/]+_test\.py$/.test(p)
 }
 
 /** 递归收集测试文件（跳过 node_modules/.venv/.git/dist/build/.runtime/.sillyspec，深度帽 6 层防野目录）。 */
@@ -782,6 +787,58 @@ function pythonImportCandidates(changedPy) {
   return [...out]
 }
 
+/**
+ * 剥注释（字符串感知状态机）——依赖命中只认代码内引用（坑
+ * dynamic-deps-e2e-vitest-exclude-false-red，2026-09-30 multi-agent-platform 实证，
+ * 用户授权修复）：原裸子串 content.includes(src) 连注释一起扫——e2e 用例**注释**里
+ * 字面引用源文件完整路径（出处标注）被误判成 import 依赖边，端到端用例进单测运行器
+ * 批又被 exclude 面拦成恒假红。剥注释后匹配：import/require/dynamic import/vi.mock
+ * 等代码内引用（含引号内路径串）照常命中，注释引用不再算依赖边。
+ * 状态机：单双引号/模板串内的注释起始符是字面量不剥；反斜杠转义不闭合串。
+ * 近似边界（可接受，方向=少误报）：模板串 ${} 内嵌套注释/字符串不识别——最坏保留
+ * 一段注释（假阳性边缘存续）或剥掉嵌套串内容（假阴性），主场景（顶层注释块/行注释）全覆盖。
+ * @param {string} content 源文本
+ * @param {boolean} isPy Python 语义（# 行注释）；JS 系走 // 与块注释
+ */
+function stripCommentsForDepMatch(content, isPy = false) {
+  const n = content.length
+  let out = ''
+  let i = 0
+  let quote = null // 当前字符串引号字符（' " `），null=代码态
+  while (i < n) {
+    const c = content[i]
+    const next = i + 1 < n ? content[i + 1] : ''
+    if (quote) {
+      out += c
+      if (c === '\\') {
+        if (i + 1 < n) { out += next; i += 2; continue }
+      } else if (c === quote) {
+        quote = null
+      }
+      i++
+      continue
+    }
+    if (c === '\'' || c === '"' || c === '`') { quote = c; out += c; i++; continue }
+    if (!isPy && c === '/' && next === '/') {
+      while (i < n && content[i] !== '\n') i++
+      continue // 行注释整段剥（换行符留给后续行）
+    }
+    if (!isPy && c === '/' && next === '*') {
+      i += 2
+      while (i < n && !(content[i] === '*' && content[i + 1] === '/')) i++
+      i += 2
+      continue
+    }
+    if (isPy && c === '#') {
+      while (i < n && content[i] !== '\n') i++
+      continue
+    }
+    out += c
+    i++
+  }
+  return out
+}
+
 export function discoverModuleDependentTests({ cwd, changedFiles, coveredCommands = [] }) {
   if (!Array.isArray(changedFiles) || changedFiles.length === 0) return []
   const norm = (p) => String(p).replace(/\\/g, '/')
@@ -804,9 +861,13 @@ export function discoverModuleDependentTests({ cwd, changedFiles, coveredCommand
     if (covered.includes(fname) || covered.includes(tf)) continue
     let content = ''
     try { content = readFileSync(join(cwd, tf), 'utf8') } catch { continue }
-    let hit = jsSrc.some(src => content.includes(src))
+    // 2026-09-30（坑 dynamic-deps-e2e-vitest-exclude-false-red，用户授权修复）：依赖命中
+    // 改在剥注释后的内容上做——注释里的路径/导入串字面引用不再算依赖边（字符串感知剥离，
+    // 代码内 import/require/dynamic import/vi.mock 引用照常命中）。
+    const contentCode = stripCommentsForDepMatch(content, tf.endsWith('.py'))
+    let hit = jsSrc.some(src => contentCode.includes(src))
     if (!hit) {
-      hit = [...pyCandidates].some(d => content.includes(`from ${d}`) || content.includes(`import ${d}`))
+      hit = [...pyCandidates].some(d => contentCode.includes(`from ${d}`) || contentCode.includes(`import ${d}`))
     }
     if (hit) found.add(tf)
   }
@@ -938,7 +999,7 @@ export function extractKnownFailures(yamlText) {
 // 刻意用 FAIL/FAILED + 配合 SUMMARY_LINE_RE 排除汇总行：否则 pytest/jest 的
 // "N failed" 汇总会被误判为「需豁免的失败行」→ 永远 remaining>0 → known_failures 失效。
 // ×(U+00D7) 是 vitest 失败行的实际前缀标记（✕✗✘ 是 jest/mocha 形态）。
-const PER_TEST_FAIL_RE = /(FAILED|\bFAIL\b|✕|✗|✘|×|panic\s*:|assertionerror|traceback|---\s*fail|error:|exception)/i
+const PER_TEST_FAIL_RE = /(FAILED|\bFAIL\b|✖|✕|✗|✘|×|panic\s*:|assertionerror|traceback|---\s*fail|error:|exception)/i
 // 汇总/计数行（非单条失败）：pytest === 框、jest "Tests:"、vitest "Test Files  N failed"/"Tests  N failed | M passed"
 // （无冒号形态）、裸 "N failed/passed"、go "FAILED in Ns"、pnpm "ELIFECYCLE Test failed" 退出横幅等。
 const SUMMARY_LINE_RE = /(={2,}.*={2,}|^\s*\d+\s+(failed|passed|skipped|pending)\b|tests?\s*:|test\s+suites?\s*:|^\s*(?:test\s+files|tests?)\s+\d|failed\s+in\s+\d|failed\s+tests\s+\d|elifecycle)/i
@@ -995,6 +1056,50 @@ const ADVISORY_LINE_RE = /^[ \t]*(?:⚠️?|ℹ️?|🔄)/
 const FAIL_COMPOUND_NEUTRALIZE_RE = /fail-(?:closed|open|soft|safe|loud|fast)/gi
 // ANSI 色码剥离（分类用）：TTY 捕获的输出里 ✓/× 前缀可能被色码包裹，行首锚定会失配。
 const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g
+// 泛用裸模式（2026-09-28-known-failures-hardening）：整条模式文本是失败标记词本身或极短标点/
+// 符号串的裸子串，豁免资格停用（须改锚定式 ^…）——防「裸 "--- " 吞 go --- FAIL: 行」「裸
+// "AssertionError" 吞真实断言行」（M1 评审实证）。文件名/用例名等具体模式（主用例：按名豁免
+// 预存失败测试）不在此列，不受限。
+/**
+ * 嵌套测试环境清洗（2026-09-28-tap-judge 实证根因 + 本变更具象为共用单点）：父级 node:test
+ * 进程带 NODE_TEST_CONTEXT env，execSync 全量继承会让内层 node --test 误入 child 模式
+ * stdout 全空——所有跑测试命令的 execSync 调用点统一经此剥离（普通进程本无此键零变化）。
+ */
+// 摘 export（2026-09-29：lint 22e-b 死导出——src+test 其余文件零引用，本文件内三处调用保留）
+function stripNestedTestEnv(env = process.env) {
+  const next = { ...env }
+  delete next.NODE_TEST_CONTEXT
+  return next
+}
+
+const GENERIC_BARE_PATTERN_RE = /^(?:[-=_~*#·✖✕✗✘×✗\s]{1,6}|assertionerror|error|fail|failed|failure|failing|not ok|exception|traceback|panic|assert|error:|fail:)$/i
+
+/** 豁免模式编译（partitionFailures 与 TAP 判账共用单点，2026-09-28-tap-judge）：锚定式（^…/$…
+ * 对 trim 后整行正则）／裸子串（兼容语义），泛用裸模式停用。 */
+function buildExemptPats(knownFailures) {
+  return (knownFailures || [])
+    .map(p => String(p).replace(ANSI_RE, '').trim())
+    .filter(Boolean)
+    .map(p => {
+      const anchored = p.startsWith('^') || p.endsWith('$')
+      if (anchored) { try { return { sub: null, regex: new RegExp(p) } } catch { return { sub: p.toLowerCase(), regex: null } } }
+      if (GENERIC_BARE_PATTERN_RE.test(p)) return { sub: null, regex: null, refused: true }
+      return { sub: p.toLowerCase(), regex: null }
+    })
+}
+
+/** 单行豁免匹配（剥 ANSI 后）：返回 {pattern, anchored} 或 null。 */
+function matchExemptLine(rawLine, pats, knownFailures) {
+  const bare = String(rawLine).replace(ANSI_RE, '')
+  const ll = bare.toLowerCase()
+  const trimmed = bare.trim()
+  for (let i = 0; i < pats.length; i++) {
+    const p = pats[i]
+    const matched = p.regex ? p.regex.test(trimmed) : (p.sub != null && ll.includes(p.sub))
+    if (matched) return { pattern: (knownFailures || [])[i], anchored: !!p.regex }
+  }
+  return null
+}
 
 /**
  * 把测试输出按行筛出「失败行」，再按 known_failures 模式分为已豁免 / 未豁免。
@@ -1046,15 +1151,23 @@ export function partitionFailures(output, knownFailures) {
   // 工具复盘）：TTY 捕获的失败行里色码把可见词拦腰拆开（`× \x1b[31mtests/foo.test.ts\x1b[0m > case`
   // 连不成 `tests/foo.test.ts > case`），同一行被迫拆成两段各配一条模式才能豁免。模式侧同步剥
   // ANSI（从原始输出誊抄来的模式可能自带码）；返回仍保留原文（remaining/exempted 展示不变形）。
-  const pats = (knownFailures || []).map(p => String(p).replace(ANSI_RE, '').toLowerCase()).filter(Boolean)
+  //
+  // 锚定式与泛用裸模式停用（2026-09-28-known-failures-hardening，M1 评审实证「裸子串吞真失败」）：
+  // - 模式以 ^ 开头或以 $ 结尾 = 锚定式（对 trim 后的原始大小写整行跑正则）；
+  // - 泛用裸模式停用：整条模式文本就是失败标记词/极短标点串（如 "---"、"AssertionError"、"✖"）
+  //   的裸子串失去豁免资格（物理关闭「裸 "--- " 吞 go --- FAIL: 行」通路）——须改写为锚定式；
+  // - 具体裸模式（文件名、用例名——known_failures 的主用例：按名豁免预存失败测试）不受限，
+  //   硬失败行照常可被其豁免（跨仓零破坏）。
+  // 匹配器编译/单行匹配抽为 buildExemptPats/matchExemptLine 共用单点（2026-09-28-tap-judge）。
+  const pats = buildExemptPats(knownFailures)
   const exempted = []
   const remaining = []
+  const exemptedBy = []
   for (const l of failureLines) {
-    const ll = l.replace(ANSI_RE, '').toLowerCase()
-    if (pats.some(p => ll.includes(p))) exempted.push(l)
-    else remaining.push(l)
+    const hit = matchExemptLine(l, pats, knownFailures)
+    if (hit) { exempted.push(l); exemptedBy.push(hit) } else remaining.push(l)
   }
-  return { failureLines, exempted, remaining }
+  return { failureLines, exempted, remaining, exemptedBy }
 }
 
 /**
@@ -1075,19 +1188,27 @@ export function partitionFailures(output, knownFailures) {
  *             remainingLines: string[], exemptedLines: string[] }}
  */
 export function judgeWithKnownFailures(exitCode, output, baseReason, knownFailures) {
-  if (exitCode === 0) return { status: 'passed', reason: baseReason, exemptedCount: 0, remainingLines: [], exemptedLines: [] }
-  const { failureLines, exempted, remaining } = partitionFailures(output, knownFailures || [])
+  if (exitCode === 0) return { status: 'passed', reason: baseReason, exemptedCount: 0, remainingLines: [], exemptedLines: [], exemptedBy: [] }
+  const { failureLines, exempted, remaining, exemptedBy } = partitionFailures(output, knownFailures || [])
   if (!knownFailures || knownFailures.length === 0) {
     // 无清单分支同样带行集：豁免与否都不该丢判账依据（tail 盲区归因同权）
-    return { status: 'failed', reason: baseReason, exemptedCount: 0, remainingLines: remaining, exemptedLines: [] }
+    return { status: 'failed', reason: baseReason, exemptedCount: 0, remainingLines: remaining, exemptedLines: [], exemptedBy: [] }
   }
   if (failureLines.length > 0 && remaining.length === 0) {
+    // 豁免形态披露（2026-09-28-known-failures-hardening）：锚定式（^…/$…）与裸子串命中分别
+    // 计数——裸子串命中给收敛提示（硬行已不可被裸子串吞，非硬行的裸子串命中仍建议锚定收窄）。
+    const anchoredHits = (exemptedBy || []).filter(x => x && x.anchored).length
+    const bareHits = exempted.length - anchoredHits
+    const formNote = bareHits > 0
+      ? `；其中裸子串命中 ${bareHits} 行（建议收敛为锚定式 ^…，硬失败行已不可被裸子串豁免）`
+      : '（全部为锚定式命中）'
     return {
       status: 'passed',
-      reason: `全部 ${failureLines.length} 个失败行命中 known_failures 已豁免（${exempted.length} 条）— 请人工复核豁免清单是否过宽`,
+      reason: `全部 ${failureLines.length} 个失败行命中 known_failures 已豁免（${exempted.length} 条）${formNote} — 请人工复核豁免清单是否过宽`,
       exemptedCount: exempted.length,
       remainingLines: [],
       exemptedLines: exempted,
+      exemptedBy: exemptedBy || [],
     }
   }
   // 剩余未豁免失败行：列出具体行 + 预存债指引（坑 verify-known-failures-stale-list）。
@@ -1266,16 +1387,150 @@ export function decideVerifyTestAction({ strategy, scopeCount = 0, gitUnavailabl
   return scopeCount > 0 ? 'dynamic-subset' : 'dynamic-empty-skip'
 }
 
+// ── 实测门增量重跑（2026-10-07-test-incremental-rerun）──
+// postmortem 实测：verify --done 跑 10 分钟级测试子集 → 挂 N 个 → 修一行 → 重跑 --done 又
+// 全量重跑子集（green cache 只在指纹不变时命中，改一行即失效）——每轮返工整轮全跑。修法：
+// 失败轮把「失败批测试文件 + 当时 git HEAD」落稳定指针 ledger；下一轮先算增量面 =
+// 「自失败 HEAD 以来的变更文件（含未提交与 untracked）∪ 前轮失败批文件」，是其真子集时
+// 只跑增量面（三源推断以增量输入重算——修复文件的 import 依赖与 FR 关联回归自然入面），
+// 基线绿面（未触碰文件）复用不重跑。逃生：local.yaml verify.test_rerun: full / env
+// SILLYSPEC_TEST_RERUN=full 恒全子集（2026-10-07 前现状）。
+
+/** 增量重跑档位读取：env SILLYSPEC_TEST_RERUN 优先，次 local.yaml verify: 段 test_rerun（宽松匹配行，fail-open incremental）。 */
+function readTestRerunConfig(specBase) {
+  const env = String(process.env.SILLYSPEC_TEST_RERUN || '').trim().toLowerCase()
+  if (env === 'full' || env === 'incremental') return env
+  try {
+    const p = join(specBase, 'local.yaml')
+    if (!existsSync(p)) return 'incremental'
+    const m = readFileSync(p, 'utf8').match(/^\s*test_rerun:\s*(full|incremental)\s*$/m)
+    return m ? m[1] : 'incremental'
+  } catch { /* 读失败 → 缺省 */ }
+  return 'incremental'
+}
+
+function testRerunLedgerPath(specBase, changeName) {
+  return join(specBase, '.runtime', `test-rerun-${changeName || 'change'}.json`)
+}
+
+/**
+ * 读增量重跑 ledger（fail-soft：缺失/损坏/null）。shape: { head, failedFiles, inputFiles, mode, status, ranAt }
+ */
+export function readTestRerunLedger({ specBase, changeName }) {
+  try {
+    return JSON.parse(readFileSync(testRerunLedgerPath(specBase, changeName), 'utf8'))
+  } catch { return null }
+}
+
+/** 写增量重跑 ledger（fail-soft：git 失败记 head=null——下一轮自动回全子集）。 */
+export function writeTestRerunLedger({ specBase, changeName, head, inputFiles, failedFiles, scopeFiles = [], mode, status }) {
+  try {
+    const dir = join(specBase, '.runtime')
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(testRerunLedgerPath(specBase, changeName), JSON.stringify({
+      change: changeName || null, head: head || null,
+      inputFiles: inputFiles || [], failedFiles: failedFiles || [], scopeFiles: scopeFiles || [],
+      mode: mode || null, status: status || null, ranAt: new Date().toISOString(),
+    }, null, 2) + '\n')
+  } catch { /* ledger 写失败不阻断实测门（下轮退化全子集） */ }
+}
+
+/** 自基线 HEAD 以来的变更文件（committed+unstaged diff ∪ untracked），posix 归一。 */
+function listFilesSince({ cwd, sinceHead }) {
+  const out = []
+  try {
+    const diff = gitQuiet(cwd, ['diff', '--name-only', sinceHead])
+    if (diff) out.push(...diff.split('\n'))
+  } catch { /* diff 失败 → 空贡献 */ }
+  try {
+    const untracked = gitQuiet(cwd, ['ls-files', '--others', '--exclude-standard'])
+    if (untracked) out.push(...untracked.split('\n'))
+  } catch { /* untracked 失败 → 空贡献 */ }
+  return [...new Set(out.map(s => s.trim().replace(/\\/g, '/')).filter(Boolean))]
+}
+
+function currentGitHead(cwd) {
+  try { return (gitQuiet(cwd, ['rev-parse', 'HEAD']) || '').trim() || null } catch { return null }
+}
+
+/**
+ * 增量重跑面计算（纯函数，export 供测）：返回 null = 不增量（走全子集现状），否则返回
+ * { files, note }。判定：ledger 在场、有失败文件、有基线 head；since 非空或失败面非空；
+ * 对比基线 = ledger.scopeFiles（基线实测的测试文件集——评审 P2 清偿：拿「失败测试文件数」
+ * 对比「输入面文件数」是口径错位，级联失败（失败测试数≥输入面数）时增量永不触发，恰是其
+ * 动机场景失效）；缺 scopeFiles 回退 inputFiles；增量面必须严格小于基线测试集（≥ 时回全
+ * 子集——宁多跑不绕过基线）。
+ */
+export function computeIncrementalFace({ ledger, filesSince, fullFace }) {
+  if (!ledger || !Array.isArray(ledger.failedFiles) || ledger.failedFiles.length === 0 || !ledger.head) return null
+  const since = Array.isArray(filesSince) ? filesSince : []
+  const inc = [...new Set([...since, ...ledger.failedFiles])]
+    .map(f => String(f).replace(/\\/g, '/'))
+    .filter(f => f && !f.startsWith('.sillyspec/'))
+  if (inc.length === 0) return null
+  const baselineScope = Array.isArray(ledger.scopeFiles) && ledger.scopeFiles.length > 0
+    ? ledger.scopeFiles
+    : (ledger.inputFiles || fullFace || [])
+  if (inc.length >= baselineScope.length) return null
+  return {
+    files: inc,
+    note: `增量重跑面 ${inc.length} 文件（前轮失败批 ${ledger.failedFiles.length} ∪ 基线以来变更 ${since.length}；基线实测测试集 ${baselineScope.length} 文件，未触碰绿面复用不重跑）`,
+  }
+}
+
+/**
+ * TAP 结构化判账（2026-09-28-tap-judge，P2 一期）：node --test 双报告器（spec→stderr 人读、
+ * tap→stdout 机读）批次按 `not ok` 行用例粒度判账——自由文本正则误计（fixture 预期错误文案、
+ * 控制台噪声）对 TAP 路径物理消失。豁免匹配复用 buildExemptPats/matchExemptLine 单点
+ * （锚定式/裸子串/泛用停用语义与 partitionFailures 完全一致）。
+ * @returns {null | {status:'passed'|'failed', reason, exemptedCount, remainingLines, exemptedLines, exemptedBy, tap:{total,failed}}}
+ *   null=输出非 TAP（旧 node/异构命令）——调用方回退 legacy judgeWithKnownFailures。
+ */
+export function judgeTapOutput(exitCode, output, baseReason, knownFailures) {
+  const text = String(output || '')
+  if (!/^TAP version \d+/m.test(text.split('\n')[0] || '')) return null
+  const allLines = text.split(/\r?\n/)
+  const okCount = allLines.filter(l => /^ok\s+\d+/.test(l)).length
+  const notOkLines = allLines.filter(l => /^not ok\s+\d+/.test(l))
+  const tap = { total: okCount + notOkLines.length, failed: notOkLines.length }
+  if (exitCode === 0) {
+    return { status: 'passed', reason: `${baseReason || ''}（TAP ${tap.total} 用例 0 失败）`.trim(), exemptedCount: 0, remainingLines: [], exemptedLines: [], exemptedBy: [], tap }
+  }
+  if (!knownFailures || knownFailures.length === 0) {
+    return { status: 'failed', reason: baseReason, exemptedCount: 0, remainingLines: notOkLines, exemptedLines: [], exemptedBy: [], tap }
+  }
+  const pats = buildExemptPats(knownFailures)
+  const exempted = []
+  const remaining = []
+  const exemptedBy = []
+  for (const l of notOkLines) {
+    const hit = matchExemptLine(l, pats, knownFailures)
+    if (hit) { exempted.push(l); exemptedBy.push(hit) } else remaining.push(l)
+  }
+  if (remaining.length === 0 && notOkLines.length > 0) {
+    const anchoredHits = exemptedBy.filter(x => x && x.anchored).length
+    const formNote = exempted.length - anchoredHits > 0 ? `；其中裸子串命中 ${exempted.length - anchoredHits} 行（建议锚定式）` : '（全部锚定式命中）'
+    return { status: 'passed', reason: `TAP ${notOkLines.length} 个失败用例全部命中 known_failures 已豁免${formNote} — 请人工复核`, exemptedCount: exempted.length, remainingLines: [], exemptedLines: exempted, exemptedBy, tap }
+  }
+  const sample = remaining.slice(0, 5).map(l => String(l).trim().slice(0, 120))
+  return { status: 'failed', reason: `${baseReason || ''}（TAP ${tap.total} 用例 ${notOkLines.length} 失败，未豁免 ${remaining.length}）：${sample.join(' | ')}`.trim(), exemptedCount: exempted.length, remainingLines: remaining, exemptedLines: exempted, exemptedBy, tap }
+}
+
 /**
  * 跑单个模块的 test 命令（串行调用方逐个调用）。
  * @returns {{name, status:'passed'|'failed', command, exitCode, durationMs, outputTail, reason}}
  */
-function runOneModule(name, testCommand, cwd, knownFailures = []) {
+function runOneModule(name, testCommand, cwd, knownFailures = [], opts = {}) {
   const startedAt = Date.now()
   let exitCode = 0
   let output = ''
   let reason = null
   warnPortRaceBeforeRun(testCommand)
+  // 嵌套测试环境清洗（2026-09-28-tap-judge 实证发现）：父级 node:test 进程带 NODE_TEST_CONTEXT
+  // env，本模块 execSync 全量继承——门在测试进程内被调用时（e2e 用例 spawn 内层 CLI 跑门），
+  // 内层 node --test 误入 child 模式 stdout 全空（⑮ 门内必挂/单独跑必过的根因家族）。
+  // 剥离该键：门内测试进程与普通进程行为一致。
+  const runEnv = stripNestedTestEnv()
   try {
     output = decodeShellOutput(execSync(testCommand, {
       cwd,
@@ -1284,6 +1539,7 @@ function runOneModule(name, testCommand, cwd, knownFailures = []) {
       maxBuffer: 32 * 1024 * 1024,
       stdio: ['ignore', 'pipe', 'pipe'],
       windowsHide: true,
+      env: runEnv,
     }))
   } catch (e) {
     exitCode = typeof e.status === 'number' ? e.status : 1
@@ -1298,7 +1554,10 @@ function runOneModule(name, testCommand, cwd, knownFailures = []) {
   }
   const durationMs = Date.now() - startedAt
   const outputTail = output.length > OUTPUT_TAIL_CHARS ? '…' + output.slice(-OUTPUT_TAIL_CHARS) : output
-  const judged = judgeWithKnownFailures(exitCode, output, reason, knownFailures)
+  // TAP 优先判账（2026-09-28-tap-judge）：tap 批次 stdout 为纯 TAP——用例粒度结构化判账；
+  // 输出非 TAP（旧 node/异常形态）自动回退 legacy 正则判账，零行为断裂。
+  const judged = (opts.tap ? judgeTapOutput(exitCode, output, reason, knownFailures) : null)
+    || judgeWithKnownFailures(exitCode, output, reason, knownFailures)
   // 环境缺件降档（坑 quick-test-gate-frontend-lint-tempdir-no-nodemodules，2026-09-23 实证）：
   // 模块命令在缺失二进制处中止——CNF 是环境信号非代码失败，降档 skipped（aggregateStatus
   // 认识 skipped 单元）。护栏：判账行集全为 wrapper 噪声才降（真失败行在场维持硬拦）。
@@ -1328,6 +1587,9 @@ function runOneModule(name, testCommand, cwd, knownFailures = []) {
     exitCode,
     durationMs,
     outputTail,
+    // 全量输出（内存态，不落盘）：增量重跑的失败文件归因源（TAP 顶层 Subtest 段 / pytest
+    // FAILED 行）——outputTail 截断后归因面残缺（2026-10-07-test-incremental-rerun）
+    outputFull: output,
     reason: judged.reason,
     exemptedCount: judged.exemptedCount,
     failureRemaining: judged.remainingLines,
@@ -1335,6 +1597,44 @@ function runOneModule(name, testCommand, cwd, knownFailures = []) {
   }
 }
 
+/**
+ * 失败批 → 失败测试文件归因（2026-10-07-test-incremental-rerun）：node --test 文件作参数时
+ * TAP 顶层条目名是测试标题非文件名，但每个 `not ok` 块的 YAML 诊断（location/stack）带绝对
+ * 路径——按块内路径归一后 includes 匹配批内相对路径；非 TAP 输出（pytest 等）回退
+ * FAILED/ERROR 行带路径匹配；归因不出保守全记批文件（增量退化不误报）。
+ */
+function attributeFailedFiles(result) {
+  const files = result.files || []
+  if (files.length === 0) return []
+  const text = String(result.outputFull || result.outputTail || '')
+  if (!text) return files
+  const norm = (p) => String(p).replace(/\\/g, '/')
+  // 按 TAP 顶层行切 not ok 块（块体 = 该行到下一顶层行之间的缩进诊断）
+  const blocks = []
+  const lines = text.split(/\r?\n/)
+  let cur = null
+  for (const line of lines) {
+    if (/^not ok \d+/.test(line)) { cur = [line]; blocks.push(cur); continue }
+    if (/^(?:ok \d+|not ok \d+|#\s|1\.\.\d+|TAP version)/.test(line)) { cur = null; continue }
+    if (cur) cur.push(line)
+  }
+  const failing = new Set()
+  for (const block of blocks) {
+    const seg = norm(block.join('\n'))
+    for (const f of files) {
+      if (seg.includes(norm(f))) failing.add(f)
+    }
+  }
+  let hits = files.filter(f => failing.has(f))
+  if (hits.length === 0 && /FAILED|ERROR/.test(text)) {
+    hits = files.filter(f => {
+      const esc = norm(f).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      return new RegExp(`(?:FAILED|ERROR)[^\\n]{0,200}${esc}`).test(text)
+    })
+  }
+  return hits.length > 0 ? hits : files
+}
+
 // refSpec 来源 meta.json（agent 可写），仅放行 git ref/range 安全字符（含 HEAD~1..HEAD 类区间），
 // 防经 shell 的命令/参数注入。剥空白与引号/分号/反引号/$ 等 shell 元字符。
 // 注：允许 ".."/"../.."（相对路径 ref 语法上合法）不影响安全——execFileSync 数组形式下它只是
@@ -1705,13 +2005,27 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
   const yamlText = existsSync(localYamlPath) ? readFileSync(localYamlPath, 'utf8') : null
 
   const rawStrategy = extractTestStrategy(yamlText)
-  const knownFailures = extractKnownFailures(yamlText)
+  // 分层豁免清单（2026-09-28-known-failures-hardening，P5）：入库的 .sillyspec/known-failures.yaml
+  // 承载工具债类模式（先例 redlines.yaml——跨机器可审计）；local.yaml 留机器特有类。两源同用
+  // extractKnownFailures 解析（同一 known_failures: 键），合并去重，入库文件在前（溯源优先）。
+  const versionedKfPath = join(specBase, 'known-failures.yaml')
+  const versionedKfText = existsSync(versionedKfPath) ? readFileSync(versionedKfPath, 'utf8') : null
+  const knownFailures = [...new Set([
+    ...extractKnownFailures(versionedKfText),
+    ...extractKnownFailures(yamlText),
+  ])]
   if (knownFailures.length > 0) {
     // 豁免清单加载可见性（坑 verify-known-failures-block-fragile-chain 的观测面）：条数即时报出
     // ——清单被块内残迹截断/误删段时「N 条」与预期不符一眼可见，不必等假红再反推。
     // 走 stderr（console.warn）：本模块运行期叙述统一不碰 stdout（machine-interface 调用时
     // stdout 留给机器可读输出）
-    console.warn(`📋 known_failures 豁免清单已加载：${knownFailures.length} 条模式（local.yaml）`)
+    const vCount = extractKnownFailures(versionedKfText).length
+    console.warn(`📋 known_failures 豁免清单已加载：${knownFailures.length} 条模式（入库 known-failures.yaml ${vCount} 条 + local.yaml ${knownFailures.length - vCount} 条）`)
+    // 泛用裸模式停用可见性（M1）：停用是静默安全行为，但要让维护者知道清单里有死条目
+    const refused = knownFailures.filter(p => !/^[^]*[$]$/.test(String(p)) && !(String(p).startsWith('^') || String(p).endsWith('$')) && GENERIC_BARE_PATTERN_RE.test(String(p).replace(ANSI_RE, '').trim()))
+    if (refused.length > 0) {
+      console.warn(`⚠️ ${refused.length} 条泛用裸模式已停用（整条即失败词——须改锚定式 ^…）：${refused.slice(0, 3).map(p => `"${p}"`).join('、')}${refused.length > 3 ? ' 等' : ''}`)
+    }
   }
 
   // ── local.yaml 测试配置退役（2026-09-26-dynamic-test-inference）──
@@ -1847,9 +2161,46 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
     // —— 动态子集（2026-09-26-dynamic-test-inference 缺省路径）——
     // 三源并集：本变更测试 ∪ FR 关联回归 ∪ import 依赖；runner 自项目结构推断；
     // 全量语义留 CI / 显式 test_strategy: full。
+    // 增量重跑（2026-10-07-test-incremental-rerun）：前轮失败 + 本轮有修复 delta → 输入面
+    // 收窄为「失败批文件 ∪ 基线以来变更」，未触碰绿面复用——返工轮不再整轮全跑。
+    let subsetInput = lastChangedFiles
+    let incremental = null
+    if (readTestRerunConfig(specBase) === 'incremental') {
+      const ledger = readTestRerunLedger({ specBase, changeName })
+      if (ledger) {
+        const filesSince = listFilesSince({ cwd, sinceHead: ledger.head })
+        incremental = computeIncrementalFace({ ledger, filesSince, fullFace: lastChangedFiles })
+      }
+    }
     const frCount = frPre && frPre.files.length ? frPre.files.length : 0
-    console.log(`ℹ️ 动态测试子集（缺省）：本变更测试 ∪ FR 关联回归 ∪ import 依赖 = ${scopeFiles.length} 个（deps ${depsAutoFiles.length}${frCount ? ` + FR 绑定 ${frCount}` : ''}）；runner 自项目结构推断。显式 test_strategy: full 恢复全量`)
-    mainResult = runModuleSubset({ cwd, specBase, changeName, hits: [], knownFailures, changedFiles: lastChangedFiles, frPre })
+    if (incremental) {
+      subsetInput = incremental.files
+      console.log(`⚡ ${incremental.note}`)
+      console.log(`ℹ️ 动态测试子集（增量重跑档）：修复面三源重算（本变更测试 ∪ FR 关联回归 ∪ import 依赖），runner 自项目结构推断。恒全子集：local.yaml verify: test_rerun: full`)
+      mainResult = runModuleSubset({ cwd, specBase, changeName, hits: [], knownFailures, changedFiles: subsetInput, frPre: null })
+      if (mainResult && typeof mainResult === 'object') {
+        mainResult.mode = 'incremental-rerun'
+        mainResult.reason = mainResult.reason
+          ? `${mainResult.reason}（增量重跑：${incremental.note}）`
+          : `增量重跑通过：${incremental.note}`
+      }
+    } else {
+      console.log(`ℹ️ 动态测试子集（缺省）：本变更测试 ∪ FR 关联回归 ∪ import 依赖 = ${scopeFiles.length} 个（并集去重后的总数；分量 deps ${depsAutoFiles.length}${frCount ? ` + FR 绑定 ${frCount}` : ''}，重叠只计一次）；runner 自项目结构推断。显式 test_strategy: full 恢复全量`)
+      mainResult = runModuleSubset({ cwd, specBase, changeName, hits: [], knownFailures, changedFiles: lastChangedFiles, frPre })
+    }
+    // ledger 记账（无论增/全）：head=当前 HEAD（git 失败 null → 下轮自动回全子集）；失败批文件
+    // 落账供下轮增量；passed 后 failedFiles 清空 → 下轮自然回全子集基线
+    try {
+      writeTestRerunLedger({
+        specBase, changeName,
+        head: currentGitHead(cwd),
+        inputFiles: subsetInput,
+        failedFiles: (mainResult && Array.isArray(mainResult.failedFiles)) ? mainResult.failedFiles : [],
+        scopeFiles: (mainResult && Array.isArray(mainResult.scopeFiles)) ? mainResult.scopeFiles : [],
+        mode: incremental ? 'incremental-rerun' : 'dynamic-subset',
+        status: mainResult && mainResult.status,
+      })
+    } catch { /* 记账失败不阻断（下轮退化全子集） */ }
   } else {
     // —— dynamic-empty：变更与测试面零关系——
     // 无自身测试、无 import 依赖测试、无 FR 关联绑定 → 不硬跑全量（防超时/预存失败面，
@@ -2072,6 +2423,7 @@ function runCrossRepoFullTest(entry) {
       maxBuffer: 32 * 1024 * 1024,
       stdio: ['ignore', 'pipe', 'pipe'],
       windowsHide: true,
+        env: stripNestedTestEnv(),
     })
   } catch (e) {
     exitCode = typeof e.status === 'number' ? e.status : 1
@@ -2253,6 +2605,7 @@ function runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fa
       maxBuffer: 32 * 1024 * 1024,
       stdio: ['ignore', 'pipe', 'pipe'],
       windowsHide: true,
+       env: stripNestedTestEnv(),
     }))
   } catch (e) {
     exitCode = typeof e.status === 'number' ? e.status : 1
@@ -2406,6 +2759,11 @@ function inferFullTestCommand(projectRoot) {
  * 修法：按扩展名分组（.py 一组 / 其余 node --test 一组），组内「本次变更的测试文件优先」排序，
  * 每组按比例分 30 帽（保底 5）；.py 组运行器从命中模块命令推断（含 pytest 的命令取其 pytest
  * 前缀——如 `cd backend && uv run pytest` 的 `uv run pytest`；无命中模块兜底 python -m pytest）。
+ * 优先面豁免帽（2026-10-06-fr-regress-cap-drop，flow-status-title 收口实测缺陷）：变更自身
+ * 测试 ∪ priorityFiles（FR 钦定回归）是本变更验收面本体——旧 slice(0, cap) 只保证优先面
+ * 「先入序」，优先面自身超帽时照样被字母序挤出（实测 63 绑定文件实跑 30、静默弃 33 含最
+ * 相关回归）。组卷改配额制：每组优先面整跑，普通 import 依赖只填剩余席位（可为 0）——帽
+ * 只界普通依赖尾。批尺寸上界护栏由 TEST_TIMEOUT_MS 兜底（超时=失败 fail-closed 不变）。
  */
 function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, priorityFiles = [] }) {
   const norm = (p2) => String(p2).replace(/\\/g, '/')
@@ -2418,8 +2776,18 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
   const CAP = 30
   const pyCap = py.length === 0 ? 0 : js.length === 0 ? CAP : Math.max(5, Math.min(CAP - 5, Math.round(CAP * py.length / (py.length + js.length))))
   const jsCap = CAP - pyCap
-  const pyRun = py.slice(0, pyCap)
-  const jsRun = js.slice(0, jsCap)
+  // 配额制组卷（2026-10-06-fr-regress-cap-drop）：优先面整跑豁免帽，普通依赖填剩余席位；
+  // dropped 只计普通依赖弃置（优先面零弃置是构造保证），组内序保持「优先前缀+字母序」。
+  const quotaFill = (group, quota) => {
+    const prioInGroup = group.filter(f => prio(f) === 0)
+    const ordinary = group.filter(f => prio(f) !== 0)
+    const ordinaryRun = ordinary.slice(0, Math.max(0, quota - prioInGroup.length))
+    return { run: [...prioInGroup, ...ordinaryRun], prioCount: prioInGroup.length, dropped: ordinary.length - ordinaryRun.length, prioDropped: 0 }
+  }
+  const pyQ = quotaFill(py, pyCap)
+  const jsQ = quotaFill(js, jsCap)
+  const pyRun = pyQ.run
+  const jsRun = jsQ.run
   // .py 运行器推断双源（2026-09-26-dynamic-test-inference）：① 命中模块命令串（旧路径，兼容期）；
   // ② 无命中命令时自项目结构——首个 .py 文件最近 pyproject/uv.lock 祖先（uv 优先）。
   // cd 前缀保留（2026-09-25-deps-cwd-prefix，R15/R16 实证）：剥前缀后从 worktree 根跑 uv，根上无
@@ -2462,22 +2830,33 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
   const jsNative = jsRun.filter(
     (f) => !NEEDS_PROJECT_RE.test(_norm(f)) && !needsProjectByContent(f),
   )
+  // 端到端目录过滤（坑 dynamic-deps-e2e-vitest-exclude-false-red，2026-09-30 multi-agent-platform
+  // 实证，用户授权修复）：项目运行器（vitest/jest）收集面普遍 exclude e2e/**、cypress/**
+  // （Playwright/Cypress 用例不归单测运行器收）——显式点名传入必「No test files found」
+  // exit 1 恒假红（且无失败行，known_failures 豁免救不了）。与运行器收集面取交集：端到端
+  // 目录文件不进项目运行器批（jsNative 批照旧——node 原生可跑的形态不受影响）。
+  const E2E_DIR_RE = /(^|\/)(e2e|cypress)\//
+  const jsProjectRun = jsProject.filter(f => !E2E_DIR_RE.test(_norm(f)))
+  const e2eDroppedFiles = jsProject.filter(f => E2E_DIR_RE.test(_norm(f)))
   let jsxRunner = null
   for (const h of hits || []) {
     const cmd = String(h.test || '')
     const m = /^((?:cd\s+[^&|;]+&&\s*)*[^&|;]*?(?:vitest|jest))(?=\s|$)/.exec(cmd) || /(?:^|&&|;|\|\|)\s*([^&|;]*(?:vitest|jest)(?:\s|$))/.exec(cmd)
     if (m) { jsxRunner = m[1].trim(); break }
   }
-  if (!jsxRunner && cwd && jsProject.length > 0) {
-    const inferred = inferJsxRunner(cwd, jsProject[0])
+  if (!jsxRunner && cwd && jsProjectRun.length > 0) {
+    const inferred = inferJsxRunner(cwd, jsProjectRun[0])
     if (inferred) { jsxRunner = inferred.command }
   }
   const cdDir = /(?:^|\s)cd\s+(\S+)\s*&&/.exec(pyRunner)?.[1]
   const rebase = (f) => (cdDir && f.startsWith(cdDir + '/')) ? f.slice(cdDir.length + 1) : f
   const batches = []
-  if (pyRun.length > 0) batches.push({ name: 'deps(auto-py)', short: 'py', command: `${pyRunner} ${pyRun.map(rebase).join(' ')}`, count: pyRun.length, dropped: py.length - pyRun.length })
-  if (jsNative.length > 0) batches.push({ name: 'deps(auto-js)', short: 'js', command: `node --test ${jsNative.join(' ')}`, count: jsNative.length, dropped: js.length - jsRun.length })
-  if (jsProject.length > 0) {
+  // 批计数分列（2026-10-06-fr-regress-cap-drop）：count=实跑总数、prioCount=实跑中优先面数、
+  // dropped 只计普通依赖弃置、prioDropped=防御路径计数（构造上恒 0——quotaFill 保证优先面零弃置，
+  // >0 即组卷逻辑被破坏，消费面 loud 披露）。js 批经 jsNative/jsProject 内容分流后计数随分流面。
+  if (pyRun.length > 0) batches.push({ name: 'deps(auto-py)', short: 'py', command: `${pyRunner} ${pyRun.map(rebase).join(' ')}`, count: pyRun.length, prioCount: pyQ.prioCount, dropped: pyQ.dropped, prioDropped: pyQ.prioDropped, files: pyRun })
+  if (jsNative.length > 0) batches.push({ name: 'deps(auto-js)', short: 'js', command: `node --test --test-reporter=spec --test-reporter-destination=stderr --test-reporter=tap --test-reporter-destination=stdout ${jsNative.join(' ')}`, count: jsNative.length, prioCount: jsNative.filter(f => prio(f) === 0).length, dropped: js.length - jsRun.length, prioDropped: jsQ.prioDropped, tap: true, files: jsNative })
+  if (jsProjectRun.length > 0) {
     if (jsxRunner) {
       const isVitest = /vitest/.test(jsxRunner)
       // jsx 批的 cd 重定基（评审 MEDIUM 清偿）：cdDir 只源 pyRunner——jsxRunner 自带 cd 前缀
@@ -2488,15 +2867,34 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
       // 括号/方括号/空格的路径（src/app/(dashboard)/workspaces/[id]/...）不加引号会以
       // 「此时不应有 <。」语法错误炸整批——文件参数含特殊字符时逐个 wrap 双引号。
       const quoteWinPath = (f) => (/[()\[\]\s&^%,;!]/.test(f) ? `"${f}"` : f)
-      batches.push({ name: 'deps(auto-jsx)', short: 'jsx', command: `${jsxRunner} ${isVitest ? 'run ' : ''}${jsProject.map(rebaseJsx).map(quoteWinPath).join(' ')}`, count: jsProject.length, dropped: 0 })
+      batches.push({ name: 'deps(auto-jsx)', short: 'jsx', command: `${jsxRunner} ${isVitest ? 'run ' : ''}${jsProjectRun.map(rebaseJsx).map(quoteWinPath).join(' ')}`, count: jsProjectRun.length, dropped: 0, files: jsProjectRun })
     } else {
-      batches.push({ name: 'deps(auto-jsx-skip)', short: 'jsx-skip', command: null, count: jsProject.length, dropped: 0, skip: true, files: jsProject, reason: `JSX 测试文件（tsx/jsx，${jsProject.length} 个）node 原生不可跑且项目结构无 vitest/jest 运行器可推断——转项目运行器执行并如实披露，不制造恒败段（R18-SF-full 残差段 11 连败的坑）` })
+      batches.push({ name: 'deps(auto-jsx-skip)', short: 'jsx-skip', command: null, count: jsProjectRun.length, dropped: 0, skip: true, files: jsProjectRun, reason: `JSX 测试文件（tsx/jsx，${jsProjectRun.length} 个）node 原生不可跑且项目结构无 vitest/jest 运行器可推断——转项目运行器执行并如实披露，不制造恒败段（R18-SF-full 残差段 11 连败的坑）` })
     }
   }
+  if (e2eDroppedFiles.length > 0) {
+    // 交集为空也要留痕（skip 批不拦门、点名可见）：端到端用例该走 playwright/cypress
+    // 运行器（test:e2e 类脚本），不归单测依赖批。
+    batches.push({ name: 'deps(auto-jsx-e2e-skip)', short: 'jsx-e2e-skip', command: null, count: e2eDroppedFiles.length, dropped: 0, skip: true, files: e2eDroppedFiles, reason: `端到端目录（e2e/cypress）测试 ${e2eDroppedFiles.length} 个不进项目运行器批——vitest/jest 收集面普遍 exclude 这些目录，点名传入必「No test files found」exit 1 假红（2026-09-30 multi-agent-platform 实证）；如需执行请走对应端到端运行器（playwright/cypress，如 pnpm test:e2e）` })
+  }
   return batches
 }
 
-export { buildDepsBatches }
+/**
+ * deps 批披露行（2026-10-06-fr-regress-cap-drop）：runModuleSubset 批日志的单源格式化——
+ * 计数分列（实跑总数 / 优先面豁免计数 / 普通依赖弃置），「超帽弃」只对普通依赖成立。
+ * 抽为纯函数供直测钉格式（runModuleSubset 需真跑测试，不宜为格式断言起进程）。
+ */
+function formatDepsBatchLine(b) {
+  const runnerNote = b.name === 'deps(auto-py)'
+    ? 'pytest 运行器按最近 pyproject/uv 祖先推断'
+    : b.short === 'jsx' ? 'vitest/jest 按最近 package.json 推断' : 'node --test'
+  const prio = Number(b.prioCount) > 0 ? `（优先面 ${b.prioCount}：变更/FR 回归豁免帽）` : ''
+  const drop = Number(b.dropped) > 0 ? `（超帽弃 ${b.dropped} 普通依赖）` : ''
+  return `ℹ️ 动态子集批 ${b.name}：${b.count} 个${prio}${drop}（${runnerNote}——治 node 跑 .py 伪败与字母序偏科）`
+}
+
+export { buildDepsBatches, formatDepsBatchLine }
 
 // ── trace residual adapter（2026-09-24-fr-test-readside，fr-test-binding §3.3/§3.6 读侧）──
 // 锚点集=本变更 task 卡 requirement_ids 并集；残差=trace active 行 tests 并集按保守差集
@@ -2561,7 +2959,7 @@ function runTraceResidualInner({ cwd, files, hits, knownFailures }) {
       }
       const isPy = b.short === 'py'
       const segFiles = chunk.filter((f) => (norm(f).endsWith('.py') === isPy))
-      const r = runOneModule(b.name, b.command, cwd, knownFailures)
+      const r = runOneModule(b.name, b.command, cwd, knownFailures, { tap: b.tap })
       segments.push({ runner: b.command, runnerKind: isPy ? 'pytest' : (b.short === 'jsx' ? 'vitest/jest' : 'node --test'), files: segFiles, status: r.status, reason: r.reason || null, durationMs: r.durationMs ?? null, outputTail: r.outputTail || null })
     }
   }
@@ -2631,7 +3029,12 @@ export function applyTraceResidual({ mainResult, action, cwd, specBase, changeNa
   }
 }
 
-function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [], changedFiles = [], frPre = null }) {
+/**
+ * 动态子集执行（module 命令 + deps 批 + FR 关联回归）。2026-10-06-fr-priority-overlap 起
+ * export 供直测（buildDepsBatches 同款先例——fixture 需真跑测试文件，不宜经
+ * runVerifyTestCheck 全链只为断言组卷接线）。
+ */
+export function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [], changedFiles = [], frPre = null }) {
   const subsetStartedAt = Date.now()
   const perModule = hits.map(h => runOneModule(h.name, h.test, cwd, knownFailures))
   // 依赖测试伪模块（module-test-face-rot，2026-09-16 本会话实证）：硬编码模块测试清单不含
@@ -2648,6 +3051,11 @@ function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [],
   if (!fr) {
     try { fr = collectFrLinkedTests({ specBase, changeName, changedFiles: changedFiles || [], projectRoot: cwd }) } catch { fr = null }
   }
+  // 优先面全量口径（2026-10-06-fr-priority-overlap）：frLinked 只含与 deps 无重叠的「新增」
+  // 绑定文件——重叠者此前拿不到优先权，仍按普通依赖受帽字母序弃置（resume-title 收口实测
+  // 64 绑定弃 14）。绑定面钦定即优先，不论与 import 依赖面是否重叠；fr 缺席回退空数组
+  // （与现状一致）。frLinked 另有职责：并集去重的增量面 + frReport.addedCount 披露口径，保留不动。
+  const frAll = fr && Array.isArray(fr.files) ? fr.files : []
   if (fr) {
     if (fr.files.length > 0) {
       const added = fr.files.filter(f => !deps.includes(f))
@@ -2662,7 +3070,7 @@ function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [],
   const depsAll = [...new Set([...deps, ...frLinked])].sort()
   let depsBatches = []
   if (depsAll.length > 0) {
-    depsBatches = buildDepsBatches({ deps: depsAll, changedFiles, hits, cwd, priorityFiles: frLinked })
+    depsBatches = buildDepsBatches({ deps: depsAll, changedFiles, hits, cwd, priorityFiles: frAll })
     for (const b of depsBatches) {
       if (b.skip) {
         // JSX 无项目运行器批（residual-runner-parity）：skip 不跑不拦，reason 点名让漏测可见
@@ -2670,8 +3078,12 @@ function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [],
         perModule.push({ name: b.name, status: 'skipped', reason: b.reason || '转项目运行器', command: null, exitCode: null, durationMs: null, outputTail: null })
         continue
       }
-      perModule.push(runOneModule(b.name, b.command, cwd, knownFailures))
-      console.log(`ℹ️ 动态子集批 ${b.name}：${b.count} 个${b.dropped > 0 ? `（超帽弃 ${b.dropped}）` : ''}（${b.name === 'deps(auto-py)' ? 'pytest 运行器按最近 pyproject/uv 祖先推断' : b.short === 'jsx' ? 'vitest/jest 按最近 package.json 推断' : 'node --test'}——治 node 跑 .py 伪败与字母序偏科）`)
+      perModule.push(runOneModule(b.name, b.command, cwd, knownFailures, { tap: b.tap }))
+      perModule[perModule.length - 1].files = b.files || [] // 增量重跑面组成（task-B failedFiles 聚合源）
+      console.log(formatDepsBatchLine(b))
+      // 防御披露（2026-10-06-fr-regress-cap-drop）：quotaFill 构造保证优先面零弃置——此计数
+      // >0 说明组卷逻辑被后续改动破坏（钦定回归被弃），loud 披露不静默。
+      if (Number(b.prioDropped) > 0) console.warn(`⚠️ ${b.name}：优先面 ${b.prioDropped} 个被弃（组卷构造上不应发生——工具缺陷，请上报）`)
     }
   }
   const status = aggregateStatus(perModule)
@@ -2710,6 +3122,20 @@ function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [],
     mode: 'dynamic-subset',
     fallbackReason: null,
     exemptedCount: perModule.reduce((n, r) => n + (r.exemptedCount || 0), 0),
+    // 失败批测试文件集聚合（2026-10-07-test-incremental-rerun）：增量重跑面的组成之一——
+    // 前轮失败批的文件下轮必入面（无论修复是否触碰它们）。归因粒度：node --test TAP 顶层
+    // not ok 以测试文件为套件名（not ok N - test/b.test.mjs），用判账行集匹配批内文件名把
+    // 「批失败」收窄到「文件失败」；归因不出（非 TAP/行集缺文件名）保守全记批文件。
+    failedFiles: (() => {
+      const out = new Set()
+      for (const r of perModule.filter(x => x.status === 'failed')) {
+        for (const f of attributeFailedFiles(r)) out.add(f)
+      }
+      return [...out].sort()
+    })(),
+    // 基线实测的测试文件全集（评审 P2 清偿配套）：增量守卫的对比基线——输入面（变更 src）与
+    // 实测面（测试文件）是两个集合，级联失败时后者远大于前者
+    scopeFiles: [...new Set(perModule.flatMap(r => r.files || []))].sort(),
     // 判账行集聚合（坑 verify-test-reconcile-tail-blindspot）：合并 tail 会二次截断，行集不截——
     // 每模块台账另见 extra.modules[].failure_remaining（带模块归属）
     failureRemaining: perModule.flatMap(r => r.failureRemaining || []),
@@ -2740,6 +3166,50 @@ function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [],
   return result
 }
 
+/**
+ * lint 结果持久化（坑 flowdone-lint-fail-no-output，2026-10-03 实证：runVerifyLintCheck
+ * 全程静默、tally 只记一句话退出码——lint 门红时 agent 拿不到失败原因只能盲猜）。
+ * 优先并入 test 的 test-result.json（modules 并列一节 `lint` 字段，读改写）；test 无
+ * 结果文件（skipped/未跑）而 lint 实跑时，用 writeRunResult 形状独立落一份（kind: 'lint'
+ * 标识）。返回落盘路径，失败返回 null（best-effort，不阻断门禁）。
+ */
+export function persistLintResult({ specBase, changeName, testResultPath, lint }) {
+  if (!lint || (lint.status !== 'passed' && lint.status !== 'failed')) return null
+  if (testResultPath && existsSync(testResultPath)) {
+    try {
+      const j = JSON.parse(readFileSync(testResultPath, 'utf8'))
+      // 并入节自带 resultPath（收编评审 P3：调用方在 persistLintResult 返回后才给 lint.resultPath
+      // 赋值——只变异对象不重写盘，并入节会永远缺 resultPath。这里预先补齐，调用方赋同值幂等）
+      lint.resultPath = testResultPath
+      j.lint = lint
+      writeFileSync(testResultPath, JSON.stringify(j, null, 2) + '\n')
+      return testResultPath
+    } catch { /* 结果文件损坏 → 退独立落盘 */ }
+  }
+  const holder = { resultPath: null }
+  try {
+    const ts = new Date().toISOString().slice(0, 19).replace(/[-T:]/g, '')
+    const runDir = join(specBase, '.runtime', 'verify-runs', ts)
+    mkdirSync(runDir, { recursive: true })
+    holder.resultPath = join(runDir, 'test-result.json')
+    writeFileSync(holder.resultPath, JSON.stringify({
+      change: changeName || null,
+      kind: 'lint',
+      command: lint.command,
+      exit_code: lint.exitCode,
+      status: lint.status,
+      duration_ms: lint.durationMs,
+      output_tail: lint.outputTail,
+      reason: lint.reason || null,
+      ran_at: new Date().toISOString(),
+    }, null, 2) + '\n')
+    return holder.resultPath
+  } catch (e) {
+    console.warn(`⚠️  lint 结果落盘失败: ${e.message}`)
+    return null
+  }
+}
+
 /**
  * 结果落盘到 .runtime/verify-runs/<ts>/test-result.json（供追溯与 SillyHub 消费）。
  * 多模块时 extra.modules 描述各模块明细。export 供 test 验证台账落盘形状。
@@ -3517,7 +3987,9 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
       // 锚定变更分支/审计 tag（非 blanket 20 提交——base 提交文件不得误救）
       const rescueRef = (typeof branchHash === 'string' && branchHash.trim()) ? branch : (gitQuiet(cwd, ['rev-parse', '--verify', '--quiet', auditTag + '^{commit}'], { timeout: 30 * 1000 }) ? auditTag : null)
       if (!rescueRef) throw new Error('no-rescue-ref')
-      const recent = gitQuiet(cwd, ['log', '20', '--name-only', '--format=%h', rescueRef], { timeout: 30 * 1000, trim: false })
+      // -n 形态计数（2026-10-04-log-window-arity：裸 '20' 在 git ≥2.4x 是 ambiguous argument
+      // fatal——fail-open 静默吞后救赎 note 路径从未生效，plan-target-files D7 在纯 HEAD 稳定红）
+      const recent = gitQuiet(cwd, ['log', '-n', '20', '--name-only', '--format=%h', rescueRef], { timeout: 30 * 1000, trim: false })
       if (typeof recent === 'string' && recent.trim()) {
         const files = recent.split('\n').map(l => l.trim()).filter(l => l && !/^[0-9a-f]{7,40}$/.test(l))
         if (files.length > 0) {