sillyspec 3.29.4 → 3.30.0

package/src/verify-postcheck.js

@@ -28,7 +28,9 @@ import { IR_STRICT_SINCE } from './constants.js'
 import { gitQuiet } from './git-helper.js'
 import { resolveRuntimeRoot } from './run/shared.js'
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs'
-import { join } from 'path'
+import { join, resolve } from 'path'
+import { readChangeTrace, testAnchorFile } from './test-bindings.js'
+import { collectFrLinkedTests } from './fr-index.js'
 import { verifyApiParity, _readWorktreeMeta } from './contract-matrix.js'
 import { reconcileCrossRepoDeclarations } from './cross-repo-reconcile.js'
 import { parseFileChangeListDetailed, pathMatches } from './change-list.js'
@@ -56,6 +58,19 @@ import { parseEvidenceSlots, classifyVerifiedFile } from './verify-facts-schema.
 
 // 测试命令最长执行时间；超时视为失败（防止 CLI 被挂起的测试卡死）
 const TEST_TIMEOUT_MS = Number(process.env.SILLYSPEC_TEST_TIMEOUT_MS) || 10 * 60 * 1000
+
+/**
+ * 测试超时配置链（R9 实证 2026-09-23）：local.yaml commands.test_timeout_sec > env
+ * SILLYSPEC_TEST_TIMEOUT_MS > 缺省 600s。全量套件实测可达 27min（change-events-r9 后端
+ * 8181 例 27:03），固定帽必杀——慢仓在 commands: 块配 test_timeout_sec。纯函数 export 供
+ * 测试与 runFullCommand 共用（yamlText 传调用侧同源文本）。
+ */
+export function resolveTestTimeoutMs(yamlText, env = process.env) {
+  const m = String(yamlText || '').match(/^\s*test_timeout_sec:\s*([0-9]+)\s*(?:#.*)?$/m)
+  if (m && Number(m[1]) > 0) return Number(m[1]) * 1000
+  const e = Number(env.SILLYSPEC_TEST_TIMEOUT_MS)
+  return Number.isFinite(e) && e > 0 ? e * 1000 : TEST_TIMEOUT_MS
+}
 const OUTPUT_TAIL_CHARS = 4000
 // 判账失败行台账上限（坑 verify-test-reconcile-tail-blindspot）：对账按完整输出判、tail 只存
 // 末 4000 字符 → 失败行落在盲区时只剩 reason 里 5 行×120 字符采样，归因必须全量复跑。修法是
@@ -64,6 +79,30 @@ const OUTPUT_TAIL_CHARS = 4000
 const FAILURE_LEDGER_MAX_LINES = 200
 const FAILURE_LEDGER_MAX_CHARS = 300
 
+// ── 子进程输出解码（坑 quick-test-gate-frontend-lint-tempdir-no-nodemodules，2026-09-23）──
+// zh-Windows 的 cmd 报错（'X' 不是内部或外部命令…）按控制台代码页（GBK/CP936）输出，
+// execSync encoding:'utf8' 直接解出乱码——CNF 签名匹配失效 + 门禁失败输出不可读（坑文档
+// 原话「乱码一行难归因」）。修法：buffer 捕获 + 本函数智能解码——utf8 无损（零 U+FFFD）
+// 优先原样返回；含替换符时试 GBK 解码取更优（Node full-icu 内置，无则维持 utf8 口径）。
+// ASCII/合法 UTF-8（vitest/pytest 等）输出与旧口径逐字节一致，零行为变化。
+let _gbkDecoder = null
+export function decodeShellOutput(buf) {
+  if (buf == null) return ''
+  if (typeof buf === 'string') return buf
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf)
+  if (b.length === 0) return ''
+  const utf8 = b.toString('utf8')
+  const utf8Bad = (utf8.match(/\ufffd/g) || []).length
+  if (utf8Bad === 0) return utf8
+  try {
+    if (!_gbkDecoder) _gbkDecoder = new TextDecoder('gbk')
+    const gbk = _gbkDecoder.decode(b)
+    const gbkBad = (gbk.match(/\ufffd/g) || []).length
+    if (gbkBad < utf8Bad) return gbk
+  } catch { /* 无 full-icu（小体积构建）→ 维持 utf8 口径，CNF 兜底签名接手 */ }
+  return utf8
+}
+
 /** 失败行台账截断（落盘/展示用；判账本身不受影响）。export 供 test 验证截断语义 */
 export function capFailureLedger(lines) {
   if (!Array.isArray(lines) || lines.length === 0) return []
@@ -135,6 +174,44 @@ function extractLintCommand(yamlText) {
   return null
 }
 
+/**
+ * lint 失败输出中提及的文件路径提取（lint 归属鉴定·R4-S-F 实证：verify 侧 lint 硬门 7 轮
+ * 全是 HEAD 存量债——快照含基线债文件时恒败，逼 agent 范围外清偿或逃生口）。
+ * 口径：按空白切 token，剥引号/行号尾缀（ruff/eslint 的 path:line:col 形态），保留带路径
+ * 分隔符且以代码扩展名结尾的 token（不带分隔符的普通单词不收，防误报）。去重保序。
+ */
+export function extractLintFailureFiles(output) {
+  if (!output || typeof output !== 'string') return []
+  const LINT_FILE_EXT_RE = /\.(?:js|mjs|cjs|ts|tsx|jsx|vue|svelte|py|pyw|go|rs|java|kt|kts|rb|php|cs|c|h|cpp|cc|hpp|swift|scala|css|scss)$/
+  const seen = new Set()
+  for (const raw of output.split(/\s+/)) {
+    let t = raw.replace(/^["'`(\[]+/, '').replace(/["'`),;]+$/, '')
+    t = t.replace(/:(?:\d+)(?::\d+)*$/, '') // 剥 :line / :line:col
+    if (!LINT_FILE_EXT_RE.test(t)) continue
+    if (!/[\\/]/.test(t)) continue
+    const norm = t.replace(/\\/g, '/').replace(/^\.\//, '')
+    if (norm.length > 1) seen.add(norm)
+  }
+  return [...seen]
+}
+
+/**
+ * lint 失败归属判定（纯函数）：失败输出提及的文件 × 本变更文件集。
+ * - owned：有交集 → 失败可能由本变更引入 → 维持硬拦（保守）。
+ * - pre-existing：零交集 → 全是 HEAD 存量债 → 调用方降档 advisory（债不是本变更的错）。
+ * - unattributable：失败文件提取为空（输出无可识别路径，如纯配置错误）→ 维持硬拦（无法
+ *   排除本变更责任，宁可拦不可漏）。
+ * 匹配宽松双向 endsWith（输出可能是绝对路径/仓相对路径，两侧口径不一定同源）。
+ */
+export function triageLintOwnership({ failureFiles = [], changeFiles = [] } = {}) {
+  const norm = (p) => String(p).replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase()
+  const ffs = (Array.isArray(failureFiles) ? failureFiles : []).map(norm).filter(Boolean)
+  if (ffs.length === 0) return { verdict: 'unattributable', overlap: [] }
+  const cfs = (Array.isArray(changeFiles) ? changeFiles : []).map(norm).filter(Boolean)
+  const overlap = ffs.filter(f => cfs.some(c => c === f || c.endsWith('/' + f) || f.endsWith('/' + c)))
+  return overlap.length > 0 ? { verdict: 'owned', overlap } : { verdict: 'pre-existing', overlap: [] }
+}
+
 /**
  * lint advisory 观察期计数（刀③，2026-09-08）：advisory 失败不阻断，但「观察期后升级硬门」
  * 需要失败率数据支撑（更硬 vs 更吵的决策依据——硬门误伤纯文档/跨平台路径会制造新噪音）。
@@ -191,32 +268,53 @@ export function runVerifyLintCheck({ cwd, specBase, timeoutMs } = {}) {
   }
 
   // timeoutMs（2026-09-12 驾驭第十七批 dogfood）：门禁快照内 node_modules 经 junction I/O 较慢，
-  // 3min 默认预算实测被超时杀（180.1s 假败）——快照路径显式传 5min；优先级 显式参 > env > 默认
-  const LINT_TIMEOUT_MS = timeoutMs || Number(process.env.SILLYSPEC_LINT_TIMEOUT_MS) || 3 * 60 * 1000
+  // 3min 默认预算实测被超时杀（180.1s 假败）——快照路径显式传 5min；优先级 显式参 >
+  // local.yaml lint_timeout_sec（R9 后补，2026-09-23）> env > 默认
+  const yamlLintTimeoutMs = (() => {
+    const m = String(yamlText || '').match(/^\s*lint_timeout_sec:\s*([0-9]+)\s*(?:#.*)?$/m)
+    return m && Number(m[1]) > 0 ? Number(m[1]) * 1000 : 0
+  })()
+  const LINT_TIMEOUT_MS = timeoutMs || yamlLintTimeoutMs || Number(process.env.SILLYSPEC_LINT_TIMEOUT_MS) || 3 * 60 * 1000
   const startedAt = Date.now()
   let exitCode = 0
   let output = ''
   let reason = null
   try {
-    output = execSync(command, {
+    output = decodeShellOutput(execSync(command, {
       cwd,
-      encoding: 'utf8',
+      encoding: 'buffer',
       timeout: LINT_TIMEOUT_MS,
       maxBuffer: 32 * 1024 * 1024,
       stdio: ['ignore', 'pipe', 'pipe'],
-    })
+      windowsHide: true,
+    }))
   } catch (e) {
     exitCode = typeof e.status === 'number' ? e.status : 1
-    output = [e.stdout, e.stderr].filter(Boolean).join('\n') || e.message
+    output = [decodeShellOutput(e.stdout), decodeShellOutput(e.stderr)].filter(Boolean).join('\n') || e.message
     reason = e.signal === 'SIGTERM' && Date.now() - startedAt >= LINT_TIMEOUT_MS
       ? `lint 命令超时（>${LINT_TIMEOUT_MS / 1000}s）`
       : `lint 命令退出码 ${exitCode}`
   }
   const durationMs = Date.now() - startedAt
   const outputTail = output.length > OUTPUT_TAIL_CHARS ? '…' + output.slice(-OUTPUT_TAIL_CHARS) : output
-  const status = exitCode === 0 ? 'passed' : 'failed'
-  const finalReason = exitCode === 0 ? null : reason
-  const tally = recordVerifyLintTally({ specBase, result: { status, reason: finalReason } })
+  let status = exitCode === 0 ? 'passed' : 'failed'
+  let finalReason = exitCode === 0 ? null : reason
+  // 环境缺件降档（坑 quick-test-gate-frontend-lint-tempdir-no-nodemodules，2026-09-23 实证）：
+  // 链式 lint 在缺失二进制处中止（&& 语义保证其前段全绿），CNF 是环境信号非代码失败——硬拦
+  // 只会逼 SILLYSPEC_*_GATE=skip 逃生口，降档 skipped 带修复指引。护栏：失败输出无可归属
+  // 文件路径才降（真实 lint 债恒带 path——extractLintFailureFiles 非空维持硬拦，CNF 噪音
+  // 不得掩盖真债）；降档不进 tally（环境跳过非质量信号，不稀释硬门失败率）。
+  let envDowngraded = false
+  if (status === 'failed') {
+    const cnf = detectCommandMissingFailure(output)
+    if (cnf.matched && extractLintFailureFiles(output).length === 0) {
+      status = 'skipped'
+      finalReason = `环境缺件：${cnf.binary ? `二进制「${cnf.binary}」` : '命令二进制'}不存在（${cnf.evidence}）——非代码失败不拦门；在对应包目录补装依赖（pnpm/npm install、uv sync 等）后 lint 恢复实测`
+      envDowngraded = true
+      console.warn(`⚠️ lint 实测环境缺件降档为跳过：${cnf.evidence}——命令链在缺失二进制处中止（&& 链其前段全绿）；修复环境（安装依赖）而非改代码；疑沙箱环境差异可设 SILLYSPEC_QUICK_GATE_SNAPSHOT_OFF=1 对照主仓口径`)
+    }
+  }
+  const tally = envDowngraded ? null : recordVerifyLintTally({ specBase, result: { status, reason: finalReason } })
 
   return {
     status,
@@ -226,6 +324,7 @@ export function runVerifyLintCheck({ cwd, specBase, timeoutMs } = {}) {
     outputTail,
     reason: finalReason,
     tally, // { failedRuns, totalRuns } | null——观察期失败率，升级硬门的决策依据
+    failureFiles: status === 'failed' ? extractLintFailureFiles(output) : [], // 归属鉴定输入（全文口径，outputTail 有截断盲区）
   }
 }
 
@@ -266,7 +365,7 @@ export function printVerifyLintCheck(result) {
     console.error(`\n⚠️  Verify lint 实测失败（advisory 档，不阻断本次完成）：\`${result.command}\` — ${result.reason}`)
     console.error('   agent 的 lint 自报告与实测不符时以实测为准；请修复后重跑，避免格式债推迟到 commit 被 pre-commit hook 拦截。')
     if (result.tally) {
-      console.error(`   📊 lint advisory 失败累计 ${result.tally.failedRuns}/${result.tally.totalRuns} 次（数据落 .runtime/verify-lint-tally.json）。`)
+      console.error(`   📊 lint advisory 观察期：实测 ${result.tally.totalRuns} 次中失败 ${result.tally.failedRuns} 次（数据落 .runtime/verify-lint-tally.json）。`)
     }
   }
   if (result.outputTail) {
@@ -579,7 +678,29 @@ export function extractModules(yamlText) {
     }
     const name = entry[2]
     const rest = (entry[3] || '').trim()
-    if (rest === '' || rest.startsWith('#')) continue // 子块展开式（本实现只支持 inline flow）
+    if (rest === '' || rest.startsWith('#')) {
+      // 子块展开式（2026-09-24 R10/R11 双实证修复：块状 path:/test: 缩进子行——此前只支持
+      // inline flow，块状被静默跳过 → modulesPresent=false 回退全量；两轮受试分别撞 25min
+      // 全量与文案矛盾）。向前看本条目的子行（缩进 > 条目行缩进）取 path/test 标量。
+      let pathVal = null
+      let testVal = null
+      for (let j = i + 1; j < lines.length; j++) {
+        const sub = lines[j]
+        if (sub.trim() === '' || sub.trim().startsWith('#')) continue
+        const subM = sub.match(/^([ 	]+)([A-Za-z0-9_.\-]+):\s*(.*)$/)
+        if (!subM || subM[1].length <= entry[1].length) break // 子行缩进必须更深
+        const key = subM[2]
+        const val = (subM[3] || '').trim().replace(/^["']|["']$/g, '')
+        if (key === 'path' && val) pathVal = val
+        if (key === 'test' && val) testVal = val
+        if (pathVal && testVal) break
+      }
+      if (pathVal && testVal) {
+        modules[name] = { path: pathVal, test: testVal }
+        continue
+      }
+      continue
+    }
     // 解析 inline flow mapping: { path: "...", test: "..." }
     const pathVal = parseFlowValue(rest, 'path')
     const testVal = parseFlowValue(rest, 'test')
@@ -629,27 +750,65 @@ function parseFlowValue(flowText, key) {
  * @param {{cwd: string, changedFiles: string[], coveredCommands?: string[]}} args
  * @returns {string[]} 相对 cwd 的测试文件路径（posix 形态，已排序；无可发现 → []）
  */
+/**
+ * 测试文件判定（polyglot，2026-09-24 deps-auto 泛化）：JS/TS 测试（*.test/spec.[cm]js/ts）
+ * + Python 测试（test_*.py / *_test.py），任意目录深度（tests?/ 目录或散置均可）。
+ */
+function isTestFilePath(p) {
+  return /\.(test|spec)\.[cm]?(js|ts)$/.test(p) || /(^|\/)test_[^\/]+\.py$/.test(p) || /(^|\/)[^\/]+_test\.py$/.test(p)
+}
+
+/** 递归收集测试文件（跳过 node_modules/.venv/.git/dist/build/.runtime/.sillyspec，深度帽 6 层防野目录）。 */
+function collectTestFiles(rootDir, base = '', depth = 0, acc = []) {
+  if (depth > 6) return acc
+  let entries = []
+  try { entries = readdirSync(rootDir, { withFileTypes: true }) } catch { return acc }
+  for (const e of entries) {
+    if (['node_modules', '.venv', 'venv', '.git', 'dist', 'build', '.runtime', '.sillyspec', '.claude', '.worktrees'].includes(e.name)) continue
+    const rel = base ? `${base}/${e.name}` : e.name
+    if (e.isDirectory()) collectTestFiles(join(rootDir, e.name), rel, depth + 1, acc)
+    else if (isTestFilePath(rel)) acc.push(rel)
+  }
+  return acc
+}
+
+/** 变更 .py → 候选导入串（点串后缀族：完整模块及其各级包后缀——匹配 from X import / import X）。 */
+function pythonImportCandidates(changedPy) {
+  const parts = changedPy.replace(/\.py$/, '').split('/')
+  const out = new Set()
+  for (let take = 2; take <= parts.length; take++) {
+    out.add(parts.slice(parts.length - take).join('.'))
+  }
+  return [...out]
+}
+
 export function discoverModuleDependentTests({ cwd, changedFiles, coveredCommands = [] }) {
   if (!Array.isArray(changedFiles) || changedFiles.length === 0) return []
   const norm = (p) => String(p).replace(/\\/g, '/')
-  const changedSrc = [...new Set(changedFiles.map(norm))]
-    .filter(p => p.startsWith('src/') && /\.(js|mjs|cjs|ts)$/.test(p))
-  const changedTests = [...new Set(changedFiles.map(norm))]
-    .filter(p => /^test\//.test(p) && /\.test\.[cm]?js$/.test(p))
+  const changedAll = [...new Set(changedFiles.map(norm))]
+  // 代码面：非测试文件本身（JS/TS + Python 源——deps-auto 泛化，不再限定 src/ 前缀与自家目录形态）
+  const changedSrc = changedAll.filter(p => !isTestFilePath(p) && /\.(js|mjs|cjs|ts|tsx|py)$/.test(p))
+  const changedTests = changedAll.filter(p => isTestFilePath(p))
   if (changedSrc.length === 0 && changedTests.length === 0) return []
   const covered = coveredCommands.filter(Boolean).join(' ')
   const found = new Set()
-  const testDir = join(cwd, 'test')
-  let entries = []
-  try { entries = readdirSync(testDir) } catch { entries = [] }
-  for (const f of entries) {
-    if (!/\.test\.[cm]?js$/.test(f)) continue
-    if (covered.includes(f)) continue
+
+  const pyCandidates = new Set()
+  for (const src of changedSrc.filter(p => p.endsWith('.py'))) {
+    for (const d of pythonImportCandidates(src)) pyCandidates.add(d)
+  }
+  const jsSrc = changedSrc.filter(p => /\.(js|mjs|cjs|ts|tsx)$/.test(p))
+
+  for (const tf of collectTestFiles(cwd)) {
+    const fname = tf.split('/').pop()
+    if (covered.includes(fname) || covered.includes(tf)) continue
     let content = ''
-    try { content = readFileSync(join(testDir, f), 'utf8') } catch { continue }
-    for (const src of changedSrc) {
-      if (content.includes(`../${src}`)) { found.add(`test/${f}`); break }
+    try { content = readFileSync(join(cwd, tf), 'utf8') } catch { continue }
+    let hit = jsSrc.some(src => content.includes(src))
+    if (!hit) {
+      hit = [...pyCandidates].some(d => content.includes(`from ${d}`) || content.includes(`import ${d}`))
     }
+    if (hit) found.add(tf)
   }
   for (const t of changedTests) {
     const fname = t.split('/').pop()
@@ -703,15 +862,18 @@ export function pickHitModules(changedFiles, modules) {
  * 聚合多个模块测试结果为单一 status。
  * - 全 passed → 'passed'
  * - 任一 failed → 'failed'
+ * - 无 failed 且非全 passed → 'skipped'（环境缺件跳过单元族，2026-09-23 CNF 降档引入：
+ *   跑过的模块全绿、缺件的在二进制处中止——调用方按跳过族口径呈现，不硬拦）
  * - 空 → null（调用方按 fallback 处理）
  *
- * @param {Array<{status:'passed'|'failed'}>} results
- * @returns {'passed'|'failed'|null}
+ * @param {Array<{status:'passed'|'failed'|'skipped'}>} results
+ * @returns {'passed'|'failed'|'skipped'|null}
  */
 export function aggregateStatus(results) {
   if (!Array.isArray(results) || results.length === 0) return null
+  if (results.some(r => r && r.status === 'failed')) return 'failed'
   if (results.every(r => r && r.status === 'passed')) return 'passed'
-  return 'failed'
+  return 'skipped'
 }
 
 /**
@@ -965,7 +1127,7 @@ const ARTIFACT_ENV_MISSING_RES = [
   // 条目 H 签名族：pytest-xdist 缺失 → usage error（unrecognized -n/--dist）
   /ERROR:\s*usage:\s*py(?:test|thon)[^\n]*(?:-n\b|--dist|xdist|unrecognized argument)/i,
   /ModuleNotFoundError:\s*No module named\s+'?(?:pytest|pytest_xdist|xdist|_pytest)'?/i,
-  /(?:command not found|not recognized as an internal or external command)[^\n]*(?:pytest|vitest|jest|mocha|ruff|tsc|eslint|python)/i,
+  /(?:command not found|not recognized as an internal or external command|不是内部或外部命令)[^\n]*(?:pytest|vitest|jest|mocha|ruff|tsc|eslint|next|python)|(?:pytest|vitest|jest|mocha|ruff|tsc|eslint|next|python)[^\n]*(?:command not found|not recognized as an internal or external command|不是内部或外部命令)/i,
 ]
 const ARTIFACT_MODULE_IMPORT_RES = [
   // overlay 部分态：改动引用方没改被引用方 → 本地顶层包 import 不到（①已先排除 pytest 家族）
@@ -1018,6 +1180,57 @@ export function classifyTestFailureArtifact(result) {
   return empty
 }
 
+// ══ CNF（command-not-found）环境缺件识别（坑 quick-test-gate-frontend-lint-tempdir-no-nodemodules，
+// 2026-09-23 multi-agent-platform 实证：纯 backend 改动被 frontend 链段 next CNF 拦死 --done）═══
+// 链式 commands.test/lint 在缺失二进制处中止（&& 语义保证其前段全绿）——CNF 是环境信号非
+// 代码失败，处置=降档 skipped 带修复指引（对齐纯超时降档/存量债归属鉴定先例）。只扫输出
+// 尾部窗（wrapper 失败横幅必在链尾；测试 fixture 的预期 CNF 文案在输出中段不进窗——防
+// fixture 噪音触发降档）。注意 2026-09-23 同坑实证反转：沙箱 junction 机制无罪（健康 pnpm
+// node_modules 经 junction 实测 tsc/next 均可解析），CNF 命中时主仓口径大概率同样缺件
+//（半装 node_modules/.bin 缺失族），修复动作是补装环境而非绕沙箱。
+const COMMAND_NOT_FOUND_TAIL_CHARS = 1500
+const COMMAND_NOT_FOUND_RES = [
+  // Windows cmd（zh/en）：二进制名单引号前置于报错短语
+  /'([^']+)'[^'\n]*(?:不是内部或外部命令|is not recognized as an internal or external command)/i,
+  // POSIX bash/zsh：`bash: line 1: next: command not found`
+  /([A-Za-z0-9_@./-]+):\s*command not found/i,
+  // POSIX dash/debian sh：`sh: 1: next: not found`
+  /\bsh(?:\s+\d+)?:\s*\d+:\s*([A-Za-z0-9_@./-]+):\s*not found/i,
+  // pnpm exec/script 包装横幅
+  /Command "([^"]+)" not found/i,
+  // 乱码兜底（decodeShellOutput 不可用面：无 full-icu 构建/e.message 直采）：zh-Windows cmd
+  // 报错经错误代码页解码后短语成乱码，但「单引号 ASCII 二进制名 + 行内 U+FFFD 替换符」
+  // 形态稳定可识别（e.message 回退路径的输出不经 decodeShellOutput）
+  /^'([A-Za-z0-9_@./-]+)'[^\n]*\ufffd/,
+]
+// 判账行集的 wrapper 噪声形态（降档护栏）：remaining 里只允许这些形态，出现真失败行
+// （断言详情/文件行号/✕ 标记族）在场维持硬拦——CNF 噪音不得掩盖真债。runner 汇总族
+//（TAP `# fail N` / node:test spec `ℹ fail N`）计入噪声：链前段通过输出的 `# fail 0`
+// 会进判账行集（PER_TEST_FAIL_RE 命中 fail 词、SUMMARY_LINE_RE 不覆盖该形态），真实
+// 失败场景另有 not ok/断言行在场挡降档，不受此放宽影响。
+const CNF_NOISE_LINE_RE = /(?:^\s*$)|(?:ELIFECYCLE)|(?:ERR_PNPM_)|(?:不是内部或外部命令)|(?:is not recognized as an internal or external command)|(?:command not found)|(?:Command failed with exit code)|(?:^undefined$)|(?:^[#ℹ]\s*(?:pass|fail|tests|suites|cancelled|skipped|todo)\b)/i
+
+/**
+ * 检测命令输出的二进制缺失（CNF）失败签名（纯函数，尾部窗扫描）。
+ * @param {string} output 命令完整输出（stdout+stderr 合并形态）
+ * @returns {{ matched: boolean, binary: string|null, evidence: string }} matched=尾部窗命中；binary=缺失二进制名（签名可捕获时，否则 null）；evidence=命中行（trim 后 ≤120 字，供 reason/日志引用）
+ */
+export function detectCommandMissingFailure(output) {
+  const empty = { matched: false, binary: null, evidence: '' }
+  if (!output || typeof output !== 'string') return empty
+  const tail = output.replace(ANSI_RE, '').slice(-COMMAND_NOT_FOUND_TAIL_CHARS)
+  for (const line of tail.split(/\r?\n/)) {
+    for (const re of COMMAND_NOT_FOUND_RES) {
+      const m = line.match(re)
+      if (m) {
+        const t = line.trim()
+        return { matched: true, binary: (m[1] || '').trim() || null, evidence: t.length > 120 ? t.slice(0, 120) + '…' : t }
+      }
+    }
+  }
+  return empty
+}
+
 /**
  * 决定 verify 实测的执行动作（纯函数，便于测试；坑 verify-worktree-... 修复方向 3）。
  *   - skip               → 'skip'（真跳过，D-005@v2——不落 full 兜底；evidence-auto 经
@@ -1027,14 +1240,30 @@ export function classifyTestFailureArtifact(result) {
  *   - 其余（full / module 无块 / module git 不可用 hitCount=-1）→ 'full'
  * @returns {'skip'|'module-subset'|'module-zero-hit-skip'|'full'}
  */
-export function decideVerifyTestAction({ strategy, modulesPresent, hitCount }) {
+/**
+ * 纯超时失败判定（R4 门禁价值考古 2026-09-21：227 跑 106 败里 36 次（34%）是 600s 帽杀的
+ * 纯超时假拦——超时=未完成非测试失败，硬拦只是浪费一轮门禁）。所有失败单元的 reason 都
+ * 含「超时」→ true（调用方降档 advisory）；任一失败单元是真实退出码/挂测 → false（维持硬拦）。
+ * 单元来源：module 模式读 result.modules（失败单元过滤），full 模式整体 reason。跨仓合并结果
+ * 语义同 full（整体 reason 聚合）。
+ */
+export function isTimeoutOnlyTestFailure(testCheck) {
+  if (!testCheck || testCheck.status !== 'failed') return false
+  const units = Array.isArray(testCheck.modules) && testCheck.modules.length > 0
+    ? testCheck.modules.filter(u => u && u.status === 'failed')
+    : [testCheck]
+  if (units.length === 0) return false
+  return units.every(u => /超时/.test(String(u.reason || '')))
+}
+
+export function decideVerifyTestAction({ strategy, scopeCount = 0, gitUnavailable = false }) {
   if (strategy === 'skip') return 'skip'
-  if (strategy === 'module' && modulesPresent) {
-    if (hitCount > 0) return 'module-subset'
-    if (hitCount === 0) return 'module-zero-hit-skip'
-    return 'full' // hitCount === -1（git 不可用）→ 落全量兜底
-  }
-  return 'full'
+  if (strategy === 'full') return 'full'
+  // 动态子集（2026-09-26-dynamic-test-inference 起缺省）：git 不可用无法算文件面 → 全量兜底；
+  // 三源（本变更测试/FR 关联回归/import 依赖）并集空 → dynamic-empty（不硬跑全量，防超时/
+  // 预存失败面）；非空 → dynamic-subset 实测。
+  if (gitUnavailable) return 'full'
+  return scopeCount > 0 ? 'dynamic-subset' : 'dynamic-empty-skip'
 }
 
 /**
@@ -1048,16 +1277,17 @@ function runOneModule(name, testCommand, cwd, knownFailures = []) {
   let reason = null
   warnPortRaceBeforeRun(testCommand)
   try {
-    output = execSync(testCommand, {
+    output = decodeShellOutput(execSync(testCommand, {
       cwd,
-      encoding: 'utf8',
+      encoding: 'buffer',
       timeout: TEST_TIMEOUT_MS,
       maxBuffer: 32 * 1024 * 1024,
       stdio: ['ignore', 'pipe', 'pipe'],
-    })
+      windowsHide: true,
+    }))
   } catch (e) {
     exitCode = typeof e.status === 'number' ? e.status : 1
-    output = [e.stdout, e.stderr].filter(Boolean).join('\n') || e.message
+    output = [decodeShellOutput(e.stdout), decodeShellOutput(e.stderr)].filter(Boolean).join('\n') || e.message
     reason = e.signal === 'SIGTERM' && Date.now() - startedAt >= TEST_TIMEOUT_MS
       ? `模块 ${name} 测试超时（>${TEST_TIMEOUT_MS / 1000}s）`
       : `模块 ${name} 测试退出码 ${exitCode}`
@@ -1069,6 +1299,28 @@ 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)
+  // 环境缺件降档（坑 quick-test-gate-frontend-lint-tempdir-no-nodemodules，2026-09-23 实证）：
+  // 模块命令在缺失二进制处中止——CNF 是环境信号非代码失败，降档 skipped（aggregateStatus
+  // 认识 skipped 单元）。护栏：判账行集全为 wrapper 噪声才降（真失败行在场维持硬拦）。
+  if (judged.status === 'failed') {
+    const cnf = detectCommandMissingFailure(output)
+    if (cnf.matched && judged.remainingLines.every(l => CNF_NOISE_LINE_RE.test(String(l)))) {
+      const skipReason = `模块 ${name} 环境缺件跳过：${cnf.binary ? `二进制「${cnf.binary}」` : '命令二进制'}不存在（${cnf.evidence}）——非代码失败；补装依赖后恢复实测`
+      console.warn(`⚠️ test 实测${skipReason}`)
+      return {
+        name,
+        status: 'skipped',
+        command: testCommand,
+        exitCode,
+        durationMs,
+        outputTail,
+        reason: skipReason,
+        exemptedCount: judged.exemptedCount,
+        failureRemaining: judged.remainingLines,
+        failureExempted: judged.exemptedLines,
+      }
+    }
+  }
   return {
     name,
     status: judged.status,
@@ -1439,7 +1691,11 @@ function resolveMainChangedFiles(cwd, changeName, specBase = null) {
  *   resultPath: string|null,
  * }}
  */
-export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = null }) {
+export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = null, restrictFiles = null, faceOverride = null }) {
+  // restrictFiles（坑 quick-gate-并行全流程变更脏文件误伤，2026-09-21 实证）：本会话声明
+  // 文件集（quick gate 传 allowedFiles）——提供时 module 子集的变更文件面收窄到
+  // 「实际变更 ∩ restrictFiles」，窗口内未声明的并行全流程变更 WIP 文件不再进模块选择
+  // 与 deps(auto)（保留在 git diff 审计记录里，不进快照实测面）。null = 旧行为零变化。
   // 信任边界声明（体检 SEC-02 核实）：本函数三处 execSync(command) 的命令只来源于
   // ① 主仓 specBase（resolveSpecDir → 主仓 .sillyspec/local.yaml）② 跨仓仓根
   // <repo>/.sillyspec/local.yaml——均为仓库自有配置（与 `npm test` 同信任级：跑测试
@@ -1458,56 +1714,87 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
     console.warn(`📋 known_failures 豁免清单已加载：${knownFailures.length} 条模式（local.yaml）`)
   }
 
-  // —— 缺省收窄（ql-20260920-010 修复一 c，对撞三轮 68 分钟单步构成之一=缺省全量）——
-  // modules: 已配置且未显式 test_strategy → 缺省按 module 子集实测。未配置 modules: 的仓
-  // 保持缺省 full 零打扰；显式 test_strategy: full 是用户有意跑全量，不受影响。
-  let defaultedToModule = false
-  if (rawStrategy === null && extractModules(yamlText)) {
-    defaultedToModule = true
-    console.warn('ℹ️ test_strategy 未配置但 modules: 已配置——缺省按 module 子集实测（v3.29.3 起收窄；显式写 test_strategy: full 恢复全量）')
+  // ── local.yaml 测试配置退役（2026-09-26-dynamic-test-inference）──
+  // modules.*.test 不再消费：静态配置写死单方向测试面、无法按变更收窄、并行变更须互改共享
+  // 配置（平台仓三形态路径混杂 + R22 裸 fallback 600s×8 实证）。测试面缺省动态推断：
+  // 本变更测试 ∪ FR 关联回归（active FR 覆盖面∩触碰文件→绑定 tests）∪ import 依赖测试；
+  // runner 自项目结构推断（pyproject/uv.lock/package.json 就近祖先）。commands.test 降格为
+  // 显式 test_strategy: full 的全量逃生阀；known_failures/test_strategy 照常生效。
+  if (extractModules(yamlText)) {
+    console.warn('ℹ️ local.yaml modules.*.test 已退役（2026-09-26-dynamic-test-inference）：测试面缺省按变更动态推断、runner 自项目结构推断——modules 块可删')
   }
 
-  // —— evidence-auto 生效策略解析（D-005@v2 / task-11）——
-  // 按变更目录 module-impact.md 影响面取生效策略（行为→module、纯文档/门禁→skip、
-  // 缺失/不可解析→降级 module 并注记）再进既有链路；full/module/skip/缺省四路径
-  // 不经此分支（消费语义逐字不变）。
-  let strategy = defaultedToModule ? 'module' : rawStrategy
+  // 策略折算：full/skip 显式语义保留；module / evidence-auto(解析 module) / 缺省统一进动态子集
+  // （module 的按模块收窄语义被动态子集超集覆盖：按变更文件面收窄且带 FR 关联回归）。
+  // evidence-auto 生效策略解析（D-005@v2 / task-11）照旧：按变更目录 module-impact.md 影响面
+  // 取生效策略（行为→实测、纯文档/门禁→skip、缺失/不可解析→降级实测并注记）。
+  let strategy = rawStrategy
   let evidenceAuto = null
+  let eaNote = ''
   if (rawStrategy === 'evidence-auto') {
     const changeDir = changeName ? join(specBase, 'changes', changeName) : null
     const resolution = resolveTestStrategy({ yamlText, changeDir })
     strategy = resolution.strategy
     evidenceAuto = resolution.evidence_auto_recommendation
+    eaNote = '（生效策略来自 test_strategy: evidence-auto 推荐）'
   }
-  // evidence-auto 解析为 module 后的 hint/reason 追加注记（full/module 路径为空串，输出逐字不变）
-  const eaNote = rawStrategy === 'evidence-auto' ? '（生效策略来自 test_strategy: evidence-auto 推荐）' : ''
-
-  // —— 模块子集路径（test_strategy: module）：算 modulesPresent / hitCount / hits ——
-  // resolveVerifyChangedFiles 返回 null 表示 git 不可用 → hitCount=-1（与 0 命中区分）。
-  // 注：module 子集策略只用主仓 diff（跨仓仓不参与 module 子集，design §6 + §5.4），
-  //     故此处不传 ctx（避免跨仓路径误命中主仓 module 映射）。
-  let modulesPresent = false
-  let hitCount = 0
-  let hits = []
-  let lastChangedFiles = [] // 0 命中诊断用（diff 文件样例可见性，坑 module-path-layout-mismatch）
   if (strategy === 'module') {
-    const modules = extractModules(yamlText)
-    if (modules) {
-      modulesPresent = true
-      // includeWorkingTree（坑 module-subset-zero-hit-uncommitted）：子代理不 commit 的改动
-      // 也参与 module 命中判定，0 命中跳过不再误伤 worktree 未提交的真实变更
-      const changedFiles = resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase })
-      lastChangedFiles = Array.isArray(changedFiles) ? changedFiles : []
-      if (changedFiles === null) {
-        hitCount = -1 // git 不可用 / 非仓库
+    console.warn('ℹ️ test_strategy: module 已退役——module 语义被动态子集覆盖（变更文件面收窄 + FR 关联回归 + import 依赖），本次按动态子集执行')
+    strategy = 'dynamic'
+  }
+  if (strategy === null) strategy = 'dynamic'
+
+  // 变更文件面（动态子集命中源）。faceOverride 在场=调用方权威面（R23-thin 实证盲区修复：
+  // 快照锚 HEAD + thin「先提交再收口」⇒ 快照内 diff 只剩真未提交文件，与权威面相交后动态子集
+  // 假空跳过——权威面由 flow done 在主仓 cwd 按 baseline..HEAD+status 算好传入；快照只隔离
+  // 执行，不再重推文件面）。缺省走快照/仓内推导（includeWorkingTree ∩ restrictFiles，
+  // 坑 module-subset-zero-hit-uncommitted / 并行变更脏文件误伤；thin 先提交后收口 diff 恒空
+  // 时回退调用方清单）。跨仓仓不参与动态子集（design §6 + §5.4），故不传 ctx。
+  let lastChangedFiles = []
+  let gitUnavailable = false
+  if (strategy === 'dynamic') {
+    if (Array.isArray(faceOverride) && faceOverride.length > 0) {
+      const norm = (f) => String(f).replace(/\\/g, '/').replace(/^\.\//, '')
+      lastChangedFiles = [...new Set(faceOverride.map(norm))]
+      console.log(`ℹ️ 文件面=调用方权威面 ${lastChangedFiles.length} 个文件（含已提交交付——快照只隔离执行不重推文件面）`)
+    } else {
+      let cf = resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase })
+      if (cf === null) {
+        gitUnavailable = true
       } else {
-        hits = pickHitModules(changedFiles, modules)
-        hitCount = hits.length
+        if (Array.isArray(restrictFiles) && restrictFiles.length > 0) {
+          const norm = (f) => String(f).replace(/\\/g, '/').replace(/^\.\//, '')
+          const restrictSet = new Set(restrictFiles.map(norm))
+          const before = cf.length
+          cf = cf.filter(f => restrictSet.has(norm(f)))
+          const dropped = before - cf.length
+          if (dropped > 0) {
+            console.log(`ℹ️ 文件面已收窄到本会话声明的 ${cf.length}/${before} 个变更文件（${dropped} 个未声明脏文件不进实测面——并行变更 WIP 留在审计记录）`)
+          }
+        }
+        if (Array.isArray(cf) && cf.length === 0 && Array.isArray(restrictFiles) && restrictFiles.length > 0) {
+          cf = restrictFiles.map((f) => String(f).replace(/\\/g, '/').replace(/^\.\//, ''))
+          console.log(`ℹ️ diff 命中源为空（先提交后收口的 thin 常态）——回退调用方清单 ${cf.length} 个文件作命中源（与快照 overlay 同源）`)
+        }
+        lastChangedFiles = cf
       }
     }
   }
 
-  const action = decideVerifyTestAction({ strategy, modulesPresent, hitCount })
+  // 动态子集三源预计算（决策与 runModuleSubset 共用，免二次扫描）：
+  // ① 本变更测试 ∪ ③ import 依赖（discoverModuleDependentTests）；② FR 关联回归（fail-open）。
+  let depsAutoFiles = []
+  let frPre = null
+  if (strategy === 'dynamic' && !gitUnavailable) {
+    try {
+      depsAutoFiles = discoverModuleDependentTests({ cwd, changedFiles: lastChangedFiles, coveredCommands: [] })
+    } catch { depsAutoFiles = [] }
+    try {
+      frPre = collectFrLinkedTests({ specBase, changeName, changedFiles: lastChangedFiles, projectRoot: cwd })
+    } catch { frPre = null }
+  }
+  const scopeFiles = frPre ? [...new Set([...depsAutoFiles, ...frPre.files])] : [...new Set(depsAutoFiles)]
+  const action = decideVerifyTestAction({ strategy, scopeCount: scopeFiles.length, gitUnavailable })
   let mainResult
   if (action === 'skip') {
     // —— skip 真跳过（D-005@v2 / R-07）——
@@ -1516,7 +1803,7 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
     // evidence-auto→skip：测试不在推荐组合内（module-impact.md 无行为类影响），
     // reason 附推荐依据与否决路径。
     const reason = rawStrategy === 'skip'
-      ? '测试已按 test_strategy=skip 配置跳过（D-005@v2 兑现声明语义：不回退全量 commands.test）。⚠️ 行为变化提示（R-07）：此前配置 skip 实际仍跑全量，本版本起真跳过——本次 verify 结论不含测试客观核验；如需恢复实测，把 local.yaml 的 test_strategy 改回 full/module。'
+      ? '测试已按 test_strategy=skip 配置跳过（D-005@v2 兑现声明语义：不回退全量 commands.test）。⚠️ 行为变化提示（R-07）：此前配置 skip 实际仍跑全量，本版本起真跳过——本次 verify 结论不含测试客观核验；如需恢复实测，把 local.yaml 的 test_strategy 改回 full。'
       : `测试已按 test_strategy=evidence-auto 推荐跳过：${evidenceAuto && evidenceAuto.summary ? evidenceAuto.summary : 'module-impact.md 判定无行为类影响'}。本次 verify 结论不含测试客观核验。`
     mainResult = {
       status: 'skipped',
@@ -1546,53 +1833,39 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
         } : {}),
       },
     })
-  } else if (action === 'module-subset') {
-    mainResult = runModuleSubset({ cwd, specBase, changeName, hits, knownFailures, changedFiles: lastChangedFiles })
-  } else if (action === 'module-zero-hit-skip') {
-    // module 模式 0 命中：不静默回退注定超时/含预存失败的全量（坑 verify-worktree-... 修复方向 3）。
-    // 据 verify-result.md 自报告判定；想跑全量请显式设 test_strategy: full。
-    // 诊断可见性（坑 module-path-layout-mismatch，2026-08-22 实证：0 命中「靠第一次跑过的
-    // 记录兜底」——为何没命中完全黑箱）：落 modules 配置 path vs diff 文件样例，配置前缀
-    // 对不上（如 packages/frontend vs frontend/）一眼可见
-    const modules_ = extractModules(yamlText) || {}
-    const diagLines = [
-      `已配置 modules（${Object.keys(modules_).length} 个）: ${Object.entries(modules_).map(([k, m]) => `${k}→${m.path}`).join('、') || '（无）'}`,
-      `本次 diff（${lastChangedFiles.length} 个文件，前 5）: ${lastChangedFiles.slice(0, 5).join(', ') || '（空）'}`,
-    ]
-    console.warn(`⚠️ 模块 0 命中诊断（对照 path 前缀与 diff 布局是否一致，如 packages/<name> vs <name>/）：`)
-    for (const l of diagLines) console.warn(`   ${l}`)
-    // 变更测试兜底（ql-20260919-007，2026-09-19 实测踩：test-only 变更 0 模块命中时裸 skip，
-    // quick --done 的 test 门禁沦为「据自报告判定」虚设）：diff 含测试文件时按 deps(auto)
-    // 同款口径（discoverModuleDependentTests）直接跑「变更的测试文件」——范围仍限本次变更
-    // 不回退全量（0 命中防超时/预存失败的初衷不变）；无测试文件维持裸 skip（docs-only 等
-    // 变更无测试面）。hits 传空数组：runModuleSubset 内部同样经 deps(auto) 执行并落台账。
-    const zeroHitDeps = discoverModuleDependentTests({ cwd, changedFiles: lastChangedFiles, coveredCommands: [] })
-    if (zeroHitDeps.length > 0) {
-      console.log(`ℹ️ 模块 0 命中但 diff 含 ${zeroHitDeps.length} 个测试文件——按变更测试子集实测（不回退全量、不再裸 skip）`)
-      mainResult = runModuleSubset({ cwd, specBase, changeName, hits: [], knownFailures, changedFiles: lastChangedFiles })
-    } else {
-      mainResult = {
-        status: 'skipped',
-        command: null,
-        exitCode: null,
-        durationMs: null,
-        outputTail: null,
-        reason: 'test_strategy: module 但本次变更未命中任何已配置 modules（0 命中）。为避免回退到注定超时/含预存失败的全量 commands.test，CLI 未自动跑全量——据 verify-result.md 自报告判定测试。若需全量覆盖，显式设 test_strategy: full。' +
-          ` 诊断：${diagLines.join('；')}` + eaNote
-          + (defaultedToModule ? '（注：module 为缺省收窄——local.yaml 未显式配置 test_strategy；常跑全量请显式写 test_strategy: full）' : ''),
-        resultPath: null,
-        mode: 'module-zero-hit',
-        fallbackReason: null,
-      }
-    }
-  } else {
-    // —— 全量路径（full / module 无块 / module git 不可用）——
-    // fallbackReason 非 null 表示本次全量是"非显式"的（缺省/配置不全/未命中），需明示。
-    // evidence-auto 解析为 module 后落全量兜底时追加推荐来源注记（eaNote；其余路径空串零变化）。
-    let fallbackReason = computeFullFallbackReason({ strategy, modulesPresent, hitCount })
-    if (fallbackReason && eaNote) fallbackReason = fallbackReason + eaNote
-    if (fallbackReason && defaultedToModule) fallbackReason = fallbackReason + '（注：module 为缺省收窄——local.yaml 未显式配置 test_strategy）'
+  } else if (action === 'full') {
+    // —— 全量路径（显式 test_strategy: full / evidence-auto 解析 full / git 不可用兜底）——
+    // commands.test 在场仍生效（全量逃生阀）；否则自项目结构推断全量命令（package.json
+    // scripts.test / pytest 发现）——不再「未配置即 skipped」（R22 实证缺配置裸 skip/裸跑之痛）。
+    const fallbackReason = rawStrategy === 'full'
+      ? null
+      : gitUnavailable
+        ? 'git 不可用，动态子集文件面不可解析——全量兜底'
+        : 'evidence-auto 解析为 full' + eaNote
     mainResult = runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fallbackReason, knownFailures })
+  } else if (action === 'dynamic-subset') {
+    // —— 动态子集（2026-09-26-dynamic-test-inference 缺省路径）——
+    // 三源并集：本变更测试 ∪ FR 关联回归 ∪ import 依赖；runner 自项目结构推断；
+    // 全量语义留 CI / 显式 test_strategy: full。
+    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 })
+  } else {
+    // —— dynamic-empty：变更与测试面零关系——
+    // 无自身测试、无 import 依赖测试、无 FR 关联绑定 → 不硬跑全量（防超时/预存失败面，
+    // 同旧 module 0 命中防误伤初衷）；全量覆盖请显式 test_strategy: full。
+    mainResult = {
+      status: 'skipped',
+      command: null,
+      exitCode: null,
+      durationMs: null,
+      outputTail: null,
+      reason: `变更与测试面零关系（${lastChangedFiles.length} 个变更文件无自身测试、无 import 依赖测试、无 FR 关联绑定）——动态子集空，不硬跑全量（防超时/预存失败面）。全量覆盖请显式 test_strategy: full。` + eaNote,
+      resultPath: null,
+      mode: 'dynamic-empty',
+      fallbackReason: null,
+    }
+    writeRunResult({ specBase, changeName, result: mainResult, extra: { strategy: rawStrategy, scope: 'dynamic-empty', changed_files: lastChangedFiles.slice(0, 20) } })
   }
 
   // —— 跨仓仓 per-repo cwd 跑 full npm test（task-06 / D-004 / design §5.4 + §6 A6）——
@@ -1603,6 +1876,9 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
   // 主仓 skipped（test_strategy: skip / evidence-auto 推荐跳过 / module 0 命中）→ 进短路档：
   // 未自配 commands.test 的跨仓不再 fallback npm test 假败（task-05 / FR-07，见
   // runCrossRepoTestUnderMainSkip 逐仓三态）。
+  // ── trace residual 并入（读侧）：悬空 fail-fast / 空残差直通 / 保守差集 / 残差段加法 ──
+  // 可证覆盖集=动态子集实际跑的三源并集（scopeFiles）；命令型动作（full/skip）照旧全补。
+  mainResult = applyTraceResidual({ mainResult, action, cwd, specBase, changeName, depsAutoFiles: scopeFiles, hits: [], knownFailures })
   return mergeCrossRepoResults(mainResult, ctx)
 }
 
@@ -1795,6 +2071,7 @@ function runCrossRepoFullTest(entry) {
       timeout: TEST_TIMEOUT_MS,
       maxBuffer: 32 * 1024 * 1024,
       stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
     })
   } catch (e) {
     exitCode = typeof e.status === 'number' ? e.status : 1
@@ -1805,6 +2082,21 @@ function runCrossRepoFullTest(entry) {
   }
   const durationMs = Date.now() - startedAt
   const outputTail = output.length > OUTPUT_TAIL_CHARS ? '…' + output.slice(-OUTPUT_TAIL_CHARS) : output
+  // node:test TAP 摘要级判定（坑 verify-gate-worktree-crossrepo-three-defects 缺陷三，
+  // 2026-09-21 实证：跨仓 npm test 自身 EXIT=0 全绿，但外层命令链（管道/包装脚本）退出码
+  // 丢失变非 0 → 行级 PER_TEST_FAIL_RE 把通过用例的预期错误文案（❌/AssertionError 等
+  // fixture 噪音）全计入未豁免失败行阻断 verify）。node:test 输出自带权威摘要行 `ℹ fail N`
+  // ——摘要存在且 fail=0 且 pass≥1 时，非 0 退出码判为包装层丢失，按摘要覆盖为通过
+  //（摘要 fail>0 维持失败由行级台账归因，无摘要输出不适用零变化）。
+  if (exitCode !== 0) {
+    const tapFail = output.match(/^ℹ fail (\d+)$/m)
+    const tapPass = output.match(/^ℹ pass (\d+)$/m)
+    if (tapFail && Number(tapFail[1]) === 0 && tapPass && Number(tapPass[1]) > 0) {
+      console.warn(`⚠️ 跨仓 repo "${entry.repoKey}" 退出码 ${exitCode} 但 node:test 摘要 ℹ pass ${tapPass[1]} / ℹ fail 0——判定包装命令退出码丢失（管道/脚本链），按 TAP 摘要覆盖为通过`)
+      exitCode = 0
+      reason = `跨仓 repo "${entry.repoKey}" node:test 摘要 ℹ pass ${tapPass[1]} / ℹ fail 0（外层退出码丢失已按摘要覆盖）`
+    }
+  }
   const judged = judgeWithKnownFailures(exitCode, output, reason, crossKnownFailures)
 
   return {
@@ -1895,7 +2187,7 @@ function isPortOccupiedSync(port) {
   try {
     const r = spawnSync(process.execPath, ['-e',
       `const n=require('node:net');const s=n.connect(${port},'127.0.0.1',()=>{console.log('Y');s.end()});s.on('error',()=>console.log('N'));setTimeout(()=>{console.log('N');process.exit(0)},1500)`],
-      { encoding: 'utf8', timeout: 4000 })
+      { encoding: 'utf8', timeout: 4000, windowsHide: true })
     return (r.stdout || '').trim().endsWith('Y')
   } catch { return false }
 }
@@ -1918,42 +2210,59 @@ function warnPortRaceBeforeRun(command) {
 }
 
 function runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fallbackReason = null, knownFailures = [] }) {
-  const command = extractTestCommand(yamlText)
-
+  let command = extractTestCommand(yamlText)
+  let inferredNote = null
   if (!command) {
-    return {
-      status: 'skipped',
-      command: null,
-      exitCode: null,
-      durationMs: null,
-      outputTail: null,
-      reason: yamlText
-        ? 'local.yaml 未配置 commands.test（或标记 unavailable）'
-        : `local.yaml 不存在（${localYamlPath}）`,
-      resultPath: null,
-      mode: 'full',
-      fallbackReason,
+    // 全量命令结构推断（2026-09-26-dynamic-test-inference）：无 commands.test 不再直接
+    // skipped——package.json scripts.test / 根 pytest 清单可推断即跑（R22 实证缺配置裸 skip
+    // 之痛）。commands.test 现仅作显式 test_strategy: full 的全量逃生阀（缺省路径已是动态
+    // 子集，不再依赖此配置）。
+    const inferred = inferFullTestCommand(cwd)
+    if (inferred) {
+      command = inferred.command
+      inferredNote = `（全量命令自项目结构推断：${inferred.source}）`
+      console.log(`ℹ️ local.yaml 未配置 commands.test——全量命令按项目结构推断：${command} ${inferredNote}`)
+    } else {
+      return {
+        status: 'skipped',
+        command: null,
+        exitCode: null,
+        durationMs: null,
+        outputTail: null,
+        reason: yamlText
+          ? 'local.yaml 未配置 commands.test 且项目结构无可推断全量命令（package.json scripts.test / pyproject pytest 均无）——全量无执行面。缺省路径无需此配置（动态子集实测）；确要全量请补 package.json scripts.test 或临时 commands.test'
+          : `local.yaml 不存在（${localYamlPath}）且项目结构无可推断全量命令——全量无执行面。缺省路径无需此配置（动态子集实测）；确要全量请先 sillyspec init`,
+        resultPath: null,
+        mode: 'full',
+        fallbackReason,
+      }
     }
   }
 
   const startedAt = Date.now()
+  const timeoutMs = resolveTestTimeoutMs(yamlText)
   let exitCode = 0
   let output = ''
   let reason = null
   warnPortRaceBeforeRun(command)
   try {
-    output = execSync(command, {
+    output = decodeShellOutput(execSync(command, {
       cwd,
-      encoding: 'utf8',
-      timeout: TEST_TIMEOUT_MS,
+      encoding: 'buffer',
+      timeout: timeoutMs,
       maxBuffer: 32 * 1024 * 1024,
       stdio: ['ignore', 'pipe', 'pipe'],
-    })
+      windowsHide: true,
+    }))
   } catch (e) {
     exitCode = typeof e.status === 'number' ? e.status : 1
-    output = [e.stdout, e.stderr].filter(Boolean).join('\n') || e.message
-    reason = e.signal === 'SIGTERM' && Date.now() - startedAt >= TEST_TIMEOUT_MS
-      ? `测试命令超时（>${TEST_TIMEOUT_MS / 1000}s）`
+    output = [decodeShellOutput(e.stdout), decodeShellOutput(e.stderr)].filter(Boolean).join('\n') || e.message
+    // 冻结鉴别（R9 实证 2026-09-23）：超时且 stdout/stderr 双空 = 进程零产出（真慢套件有
+    // 持续输出）——快照 junction/沙箱环境冻结特征，给主仓口径复跑的可行动指引
+    const frozen = e.signal === 'SIGTERM' && Date.now() - startedAt >= timeoutMs
+      && ![e.stdout, e.stderr].filter(Boolean).join('').trim()
+    reason = e.signal === 'SIGTERM' && Date.now() - startedAt >= timeoutMs
+      ? `测试命令超时（>${timeoutMs / 1000}s）${frozen ? '且零输出——疑似环境冻结（快照 junction/沙箱），建议主仓口径复跑（quick 门禁会自动回退；gate 场景带 SILLYSPEC_QUICK_GATE_SNAPSHOT_OFF=1）' : '——超时≠测试挂：配 commands.test_timeout_sec 提帽或 test_strategy: module 收窄'}`
       : `测试命令退出码 ${exitCode}`
     // 资源竞争鉴别提示（坑 verify-devserver-port-race）：EADDRINUSE/端口占用类失败极可能是
     // 自留 dev server 竞争而非代码问题——输出里明示鉴别路径，防误报 FAIL
@@ -1965,6 +2274,32 @@ function runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fa
   const outputTail = output.length > OUTPUT_TAIL_CHARS ? '…' + output.slice(-OUTPUT_TAIL_CHARS) : output
 
   const judged = judgeWithKnownFailures(exitCode, output, reason, knownFailures)
+  // 环境缺件降档（坑 quick-test-gate-frontend-lint-tempdir-no-nodemodules，2026-09-23 实证，
+  // 与 runOneModule/runVerifyLintCheck 同口径）：全量测试命令在缺失二进制处中止（&& 链其前
+  // 段全绿）——CNF 环境信号非代码失败，降档 skipped 带修复指引。护栏同 runOneModule：
+  // 判账行集全为 wrapper 噪声才降。
+  if (judged.status === 'failed') {
+    const cnf = detectCommandMissingFailure(output)
+    if (cnf.matched && judged.remainingLines.every(l => CNF_NOISE_LINE_RE.test(String(l)))) {
+      const result = {
+        status: 'skipped',
+        command,
+        exitCode,
+        durationMs,
+        outputTail,
+        reason: `环境缺件：${cnf.binary ? `二进制「${cnf.binary}」` : '命令二进制'}不存在（${cnf.evidence}）——非代码失败不拦门；在对应包目录补装依赖（pnpm/npm install、uv sync 等）后恢复实测`,
+        resultPath: null,
+        mode: 'full',
+        fallbackReason,
+        exemptedCount: judged.exemptedCount,
+        failureRemaining: judged.remainingLines,
+        failureExempted: judged.exemptedLines,
+      }
+      console.warn(`⚠️ test 实测环境缺件降档为跳过：${cnf.evidence}——命令链在缺失二进制处中止（&& 链其前段全绿）；修复环境（安装依赖）而非改代码`)
+      writeRunResult({ specBase, changeName, result, extra: fallbackReason ? { fallback_reason: fallbackReason } : {} })
+      return result
+    }
+  }
   const result = {
     status: judged.status,
     command,
@@ -1988,21 +2323,362 @@ function runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fa
  * 串行跑命中的模块子集，聚合结果。
  * 返回 shape 与 runFullCommand 一致（status/command/exitCode/durationMs/outputTail/reason/resultPath）。
  */
-function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [], changedFiles = [] }) {
+
+// ── runner 结构推断（2026-09-26-dynamic-test-inference）────────────────────────────
+// local.yaml 测试命令退役后的执行层：从项目文件（pyproject.toml/uv.lock/package.json/锁文件）
+// 推断「怎么跑」。就近原则：测试文件最近的清单祖先是它的运行环境（monorepo 子项目各自独立）。
+
+/** .py 运行环境：自文件目录向上找最近 pyproject.toml/uv.lock 祖先（uv.lock 优先——uv 系环境
+ * 用 `uv run pytest` 防解析到错误解释器，deps-cwd-prefix 实证 aiobotocore 假红家族）。 */
+function inferPyRunner(projectRoot, pyFile) {
+  let dir = String(pyFile || '').replace(/\\/g, '/')
+  const i = dir.lastIndexOf('/')
+  dir = i === -1 ? '' : dir.slice(0, i)
+  for (;;) {
+    if (existsSync(join(projectRoot, dir, 'uv.lock'))) {
+      return { command: dir ? `cd ${dir} && uv run pytest` : 'uv run pytest', dir: dir || null }
+    }
+    if (existsSync(join(projectRoot, dir, 'pyproject.toml'))) {
+      return { command: dir ? `cd ${dir} && python -m pytest` : 'python -m pytest', dir: dir || null }
+    }
+    if (dir === '' || dir === '.') return { command: 'python -m pytest', dir: null }
+    const j = dir.lastIndexOf('/')
+    dir = j === -1 ? '' : dir.slice(0, j)
+  }
+}
+
+/** node 包管理器（最近 package.json 目录的锁文件）：pnpm-lock→pnpm / yarn.lock→yarn / 其余 npm */
+function inferPm(pkgDir) {
+  if (existsSync(join(pkgDir, 'pnpm-lock.yaml'))) return 'pnpm'
+  if (existsSync(join(pkgDir, 'yarn.lock'))) return 'yarn'
+  return 'npm'
+}
+
+/** .tsx/.jsx 运行环境：最近 package.json 祖先含 vitest/jest 依赖（或 scripts.test 提及）→
+ * `cd <dir> && <pm> exec <runner>`；找不到 → null（调用方整批 skip 转项目运行器，不造恒败段）。 */
+function inferJsxRunner(projectRoot, jsxFile) {
+  let dir = String(jsxFile || '').replace(/\\/g, '/')
+  const i = dir.lastIndexOf('/')
+  dir = i === -1 ? '' : dir.slice(0, i)
+  for (;;) {
+    const pkgPath = join(projectRoot, dir, 'package.json')
+    if (existsSync(pkgPath)) {
+      let pkg = null
+      try { pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) } catch { pkg = null }
+      if (pkg) {
+        const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) }
+        const scriptsTest = String((pkg.scripts && pkg.scripts.test) || '')
+        let runner = null
+        if (deps.vitest || /\bvitest\b/.test(scriptsTest)) runner = 'vitest'
+        else if (deps.jest || /\bjest\b/.test(scriptsTest)) runner = 'jest'
+        if (runner) {
+          const pm = inferPm(join(projectRoot, dir))
+          return { command: dir ? `cd ${dir} && ${pm} exec ${runner}` : `${pm} exec ${runner}`, dir: dir || null }
+        }
+      }
+    }
+    if (dir === '' || dir === '.') return null
+    const j = dir.lastIndexOf('/')
+    dir = j === -1 ? '' : dir.slice(0, j)
+  }
+}
+
+/** 全量命令结构推断（显式 test_strategy: full 且无 commands.test 的逃生阀）：
+ * 根 package.json scripts.test → `<pm> run test`；否则根 pyproject/uv → pytest 全量；
+ * 均无 → null（调用方 skipped 带指引）。 */
+function inferFullTestCommand(projectRoot) {
+  const pkgPath = join(projectRoot, 'package.json')
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+      if (pkg.scripts && pkg.scripts.test) return { command: `${inferPm(projectRoot)} run test`, source: 'package.json scripts.test' }
+    } catch { /* 损坏 package.json 落 python 侧/无 */ }
+  }
+  if (existsSync(join(projectRoot, 'uv.lock'))) return { command: 'uv run pytest', source: 'uv.lock' }
+  if (existsSync(join(projectRoot, 'pyproject.toml'))) return { command: 'python -m pytest', source: 'pyproject.toml' }
+  return null
+}
+
+/**
+ * deps(auto) 运行器推断 + 公平组卷（2026-09-24 R10 实证修复）：
+ * - R10 缺陷①：deps 一律 `node --test` 执行——.py 依赖测试全 SyntaxError 伪败（只能靠豁免放行）。
+ * - R10 缺陷②：字母序 slice(0,30) 截断——前端 .tsx 依赖测试恒被后端 .py 挤出跑面。
+ * 修法：按扩展名分组（.py 一组 / 其余 node --test 一组），组内「本次变更的测试文件优先」排序，
+ * 每组按比例分 30 帽（保底 5）；.py 组运行器从命中模块命令推断（含 pytest 的命令取其 pytest
+ * 前缀——如 `cd backend && uv run pytest` 的 `uv run pytest`；无命中模块兜底 python -m pytest）。
+ */
+function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, priorityFiles = [] }) {
+  const norm = (p2) => String(p2).replace(/\\/g, '/')
+  const changedSet = new Set((changedFiles || []).map(norm))
+  // priorityFiles（FR 关联回归面）：与变更自身测试同级优先——绑定面钦定的回归不该被字母序挤出跑面
+  const prioritySet = new Set((priorityFiles || []).map(norm))
+  const prio = (f) => (changedSet.has(norm(f)) || prioritySet.has(norm(f))) ? 0 : 1 // 变更/FR 回归测试文件优先
+  const py = deps.filter(f => f.endsWith('.py')).sort((a, b) => (prio(a) > prio(b) ? 1 : prio(a) < prio(b) ? -1 : a.localeCompare(b)))
+  const js = deps.filter(f => !f.endsWith('.py')).sort((a, b) => (prio(a) > prio(b) ? 1 : prio(a) < prio(b) ? -1 : a.localeCompare(b)))
+  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)
+  // .py 运行器推断双源（2026-09-26-dynamic-test-inference）：① 命中模块命令串（旧路径，兼容期）；
+  // ② 无命中命令时自项目结构——首个 .py 文件最近 pyproject/uv.lock 祖先（uv 优先）。
+  // cd 前缀保留（2026-09-25-deps-cwd-prefix，R15/R16 实证）：剥前缀后从 worktree 根跑 uv，根上无
+  // pyproject.toml → uv 解析到无 dev extras 的错环境 → aiobotocore 假红（两轮 known_failures 顶着）。
+  // 前缀在则批次文件路径按该 dir 重定基（模块命令的文件参即 dir 相对口径，如 app/modules/...）。
+  let pyRunner = null
+  for (const h of hits || []) {
+    const cmd = String(h.test || '')
+    const m = /^((?:cd\s+[^&|;]+&&\s*)*[^&|;]*?pytest)/.exec(cmd) || /(?:^|&&|;|\|\|)\s*([^&|;]*pytest)/.exec(cmd)
+    if (m) { pyRunner = m[1].trim(); break }
+  }
+  if (!pyRunner && cwd && pyRun.length > 0) {
+    const inferred = inferPyRunner(cwd, pyRun[0])
+    pyRunner = inferred.command
+  }
+  if (!pyRunner) pyRunner = 'python -m pytest'
+  // JSX 运行器推断（2026-09-26-residual-runner-parity 起 + 结构推断源）：.tsx/.jsx 是 node
+  // 原生 type stripping 跑不了的（node --test 直跑恒败——R18 verify 段 ~11 次尝试的坑），
+  // ① 命中命令串提取 vitest/jest（旧路径）② 无命中命令时最近含 vitest/jest 的 package.json；
+  // 双源均提不出则整批 skip 转项目运行器（不制造恒败段）。.ts/.js 照旧 node --test（原生可跑）。
+  // R19（2026-09-27-core-pages-visual-redesign verify 实证，用户授权修复）：import 项目测试
+  // 框架（vitest/@playwright/jest/bun:test）的 .ts 文件与 .tsx 同病——node --test 直跑 import
+  // 解析/协议全不符恒败（frontend/src/styles/themes.test.ts + e2e/auth.spec.ts 两轮假红）。
+  // 按文件内容分流：内容命中框架 import 的 .ts/.js 归 jsProject（项目运行器），node:test/
+  // 纯 node 协议照旧 jsNative；文件读不到按 jsNative（保守，与旧口径一致）。
+  const _norm = (p2) => String(p2).replace(/\\/g, '/')
+  const PROJECT_FRAMEWORK_IMPORT_RE =
+    /^\s*import[\s{][^;"']*}?\s*from\s*["'](vitest|@vitest\/|@playwright\/test|jest|bun:test)["']/m
+  const needsProjectByContent = (f) => {
+    try {
+      return PROJECT_FRAMEWORK_IMPORT_RE.test(readFileSync(join(cwd ?? '.', f), 'utf8'))
+    } catch {
+      return false
+    }
+  }
+  const NEEDS_PROJECT_RE = /\.(tsx|jsx)$/
+  const jsProject = jsRun.filter(
+    (f) => NEEDS_PROJECT_RE.test(_norm(f)) || needsProjectByContent(f),
+  )
+  const jsNative = jsRun.filter(
+    (f) => !NEEDS_PROJECT_RE.test(_norm(f)) && !needsProjectByContent(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 (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) {
+    if (jsxRunner) {
+      const isVitest = /vitest/.test(jsxRunner)
+      // jsx 批的 cd 重定基（评审 MEDIUM 清偿）：cdDir 只源 pyRunner——jsxRunner 自带 cd 前缀
+      // （cd frontend && pnpm exec vitest）时文件未重定基产双前缀错路径；独立提取 jsxDir。
+      const jsxDir = /(?:^|\s)cd\s+(\S+)\s*&&/.exec(jsxRunner)?.[1]
+      const rebaseJsx = (f) => (jsxDir && f.startsWith(jsxDir + '/')) ? f.slice(jsxDir.length + 1) : f
+      // R20（2026-09-27-thin-display-fix 实证，用户授权修复）：Windows cmd 执行器对含
+      // 括号/方括号/空格的路径（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 })
+    } 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 连败的坑）` })
+    }
+  }
+  return batches
+}
+
+export { buildDepsBatches }
+
+// ── trace residual adapter（2026-09-24-fr-test-readside，fr-test-binding §3.3/§3.6 读侧）──
+// 锚点集=本变更 task 卡 requirement_ids 并集；残差=trace active 行 tests 并集按保守差集
+// （仅 deps-auto-subset 文件集可证覆盖，命令型动作一律全补——禁解析命令串猜覆盖面）。
+// 现选测（decideVerifyTestAction 及各执行分支）逐字保留，残差只在结果层加法（D-002@v1）。
+
+/** 锚点集：tasks/*.md frontmatter requirement_ids 局部号并集（无 tasks 目录 → 空，fail-open） */
+export function resolveVerifyAnchorSet({ specBase, changeName }) {
+  const ids = new Set()
+  try {
+    const tasksDir = join(specBase, 'changes', changeName, 'tasks')
+    if (existsSync(tasksDir)) {
+      for (const f of readdirSync(tasksDir).filter(x => /^task-[\d.]+\.md$/.test(x))) {
+        const m = readFileSync(join(tasksDir, f), 'utf8').match(/^requirement_ids:\s*\[([^\]]*)\]/m)
+        if (m) for (const x of m[1].split(',')) { const t = x.trim().replace(/['"]/g, ''); if (t) ids.add(t) }
+      }
+    }
+  } catch { /* fail-open：锚点集空 → 残差空 → 完全沿用现选测 */ }
+  return [...ids]
+}
+
+/** 残差解析：active·非 superseded·锚命中的 trace 行 → { anchors, rows, files, dangling } */
+export function resolveTraceResidual({ specBase, changeName, cwd }) {
+  const anchors = resolveVerifyAnchorSet({ specBase, changeName })
+  if (anchors.length === 0) return { anchors, rows: [], files: [], dangling: [] }
+  const rows = readChangeTrace(join(specBase, 'changes', changeName))
+    .filter(r => anchors.includes(r.anchor) && r.state === 'active' && r.status !== 'superseded')
+  // tests 条目可携带用例锚（2026-09-26-binding-anchor-fidelity）——文件面/悬空判定走剥锚
+  const files = [...new Set(rows.flatMap(r => (r.tests || []).map(testAnchorFile)))].sort()
+  const dangling = files.filter(f => !existsSync(resolve(cwd, f)))
+  return { anchors, rows, files, dangling }
+}
+
+/** 残差执行段：按 buildDepsBatches 同口径组卷（扩展名分语言/pytest 前缀自模块命令推断），
+ * 30/块分卷破 deps 面的帽（残差是绑定面钦定必须跑的，不适用发现面防膨胀帽）。 */
+function runTraceResidual({ cwd, files, hits, knownFailures = [] }) {
+  // 嵌套 test-runner 防污染：孙代 node --test 会误连外层 reporter（NODE_TEST_* 环境变量，
+  // 单测实测：嵌套下挂测被误判 passed）——spawn 前剥除、跑完还原（同步窗口安全；真实门禁
+  // 进程无此变量，零影响）。
+  const savedEnv = { ...process.env }
+  const strippedKeys = []
+  for (const k of Object.keys(process.env)) { if (k.startsWith('NODE_TEST')) { strippedKeys.push(k); delete process.env[k] } }
+  try {
+    return runTraceResidualInner({ cwd, files, hits, knownFailures })
+  } finally {
+    for (const k of strippedKeys) process.env[k] = savedEnv[k]
+  }
+}
+function runTraceResidualInner({ cwd, files, hits, knownFailures }) {
+  const norm = (p) => String(p).replace(/\\/g, '/')
+  const segments = []
+  for (let i = 0; i < files.length; i += 30) {
+    const chunk = files.slice(i, i + 30)
+    const batches = buildDepsBatches({ deps: chunk, changedFiles: files, hits, cwd })
+    for (const b of batches) {
+      if (b.skip) {
+        // JSX 无项目运行器批（residual-runner-parity）：不跑不拦——残差披露如实记录转办，
+        // 由 agent 用项目运行器执行（verify 段指引已含「命中 warning 复核」面）。
+        segments.push({ runner: b.name, runnerKind: 'project-runner-transfer', files: b.files || [], status: 'skipped', reason: b.reason || '转项目运行器', durationMs: null, outputTail: null })
+        console.warn(`⚠️ ${b.name}：${b.reason}`)
+        continue
+      }
+      const isPy = b.short === 'py'
+      const segFiles = chunk.filter((f) => (norm(f).endsWith('.py') === isPy))
+      const r = runOneModule(b.name, b.command, cwd, knownFailures)
+      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 })
+    }
+  }
+  return segments
+}
+
+/** 披露 sidecar（D-005@v1：JSON 真源+console 一行；覆盖式幂等） */
+export function writeTraceDisclosure({ specBase, changeName, payload }) {
+  const p = join(specBase, 'changes', changeName, 'verify-trace-disclosure.json')
+  writeAtomicSync(p, JSON.stringify({ schemaVersion: 1, change: changeName, ...payload }, null, 2) + '\n')
+  console.log(`📎 trace 披露：锚点 ${payload.anchors.length} 个 / 行 ${(payload.rows || []).length} / 残差 ${(payload.residualFiles || []).length} 文件（可证覆盖来源：${payload.provableSource}）→ ${p}`)
+}
+
+/** 主入口：悬空 fail-fast（D-004@v1）→ 空残差直通（零行为漂移）→ 披露 → 保守差集 → 残差并入 */
+export function applyTraceResidual({ mainResult, action, cwd, specBase, changeName, depsAutoFiles, hits, knownFailures }) {
+  let tr
+  try { tr = resolveTraceResidual({ specBase, changeName, cwd }) } catch { return mainResult }
+  if (tr.dangling.length > 0) {
+    return {
+      status: 'failed', command: null, exitCode: 1, durationMs: 0, outputTail: null,
+      reason: `⛔ 测试绑定悬空：锚点集内 active 行引用的 ${tr.dangling.length} 个文件缺失（${tr.dangling.join('、')}）——悬空行让绑定表成谎言，比没表更糟（方案 §3.4 写时闸同款）。修复：sillyspec tests --unbind --anchor <锚> --row-id <行>，或 --bind 重绑到现存路径`,
+      resultPath: null, mode: 'trace-dangling', fallbackReason: null,
+    }
+  }
+  if (tr.files.length === 0) return mainResult
+  // 可证覆盖集（2026-09-26-dynamic-test-inference 起）：动态子集（旧名 deps-auto-subset 兼容）
+  // 跑的文件面可证覆盖绑定行——残差只补差集；命令型动作（full/显式命令）一律全补。
+  const provable = (action === 'deps-auto-subset' || action === 'dynamic-subset')
+    ? new Set((depsAutoFiles || []).map(f => String(f).replace(/\\/g, '/'))) : new Set()
+  const residualFiles = tr.files.filter(f => !provable.has(f))
+  try {
+    writeTraceDisclosure({
+      specBase, changeName,
+      payload: {
+        anchors: tr.anchors,
+        rows: tr.rows.map(r => ({ anchor: r.anchor, row_id: r.row_id, tests: r.tests })),
+        traceFiles: tr.files,
+        provableSource: (action === 'deps-auto-subset' || action === 'dynamic-subset') ? action : 'none(command-shaped)',
+        residualFiles,
+        action,
+        ranAt: new Date().toISOString(),
+      },
+    })
+  } catch { /* 披露失败不拦门（sidecar 可复跑重写） */ }
+  if (residualFiles.length === 0) return mainResult
+  let segs
+  try {
+    segs = runTraceResidual({ cwd, files: residualFiles, hits, knownFailures })
+  } catch (e) {
+    return { ...mainResult, status: 'failed', reason: `trace 残差段执行异常（fail-closed）：${e && e.message ? e.message : e}` }
+  }
+  const failed = segs.filter(x => x.status === 'failed')
+  const mainSkipped = mainResult && mainResult.status === 'skipped'
+  const status = (mainResult && mainResult.status === 'failed') || failed.length > 0 ? 'failed' : 'passed'
+  const mode = mainSkipped ? 'trace-residual' : `${(mainResult && mainResult.mode) || action}+trace(${residualFiles.length})`
+  return {
+    ...mainResult,
+    status,
+    mode,
+    command: [mainResult && mainResult.command, ...segs.map(x => x.runnerKind + '(' + x.files.length + ')')].filter(Boolean).join(' + '),
+    exitCode: status === 'passed' ? 0 : 1,
+    durationMs: ((mainResult && mainResult.durationMs) || 0) + segs.reduce((n, x) => n + (x.durationMs || 0), 0),
+    outputTail: [mainResult && mainResult.outputTail, ...segs.map(x => `── trace-residual ${x.runnerKind} ${x.files.length} 文件 (${x.status}) ──\n${x.outputTail || ''}`)].filter(Boolean).join('\n'),
+    reason: failed.length > 0
+      ? `trace 残差段失败（${failed.map(x => x.runnerKind).join(', ')}）${mainResult && mainResult.reason ? '；主跑：' + mainResult.reason : ''}`
+      : (mainResult && mainResult.reason) || null,
+  }
+}
+
+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 本会话实证）：硬编码模块测试清单不含
   // 变更 src 文件的直接断言测试 → module 收窄漏全量断言。附加执行「import 变更 src 的测试 ∪
   // 变更的 test 文件」中未被命中模块命令覆盖的部分；无额外文件零行为（不新增失败面）。
   const deps = discoverModuleDependentTests({ cwd, changedFiles, coveredCommands: hits.map(h => h.test) })
-  if (deps.length > 0) {
-    perModule.push(runOneModule('deps(auto)', `node --test ${deps.slice(0, 30).join(' ')}`, cwd, knownFailures))
-    console.log(`ℹ️ module 子集已附加依赖测试伪模块 deps(auto)：${deps.length} 个（import 变更 src/变更的 test 本体，未被模块命令串覆盖——治硬编码清单腐烂）`)
+  // FR 关联回归源（2026-09-26-dynamic-test-inference 三源之二）：active FR 覆盖面（来源变更
+  // patch ∪ 绑定）∩ 本次触碰文件 ≠ ∅ 者，其绑定 tests 解析仓根相对后并入实测面——「需求→
+  // 用例」映射即测试需求。frPre 在场用调用方预计算（runVerifyTestCheck 决策已扫过，免二次
+  // 扫描）；fail-open：索引缺失/损坏零影响（三源其余照跑）。
+  let frLinked = []
+  let frReport = null
+  let fr = frPre
+  if (!fr) {
+    try { fr = collectFrLinkedTests({ specBase, changeName, changedFiles: changedFiles || [], projectRoot: cwd }) } catch { fr = null }
+  }
+  if (fr) {
+    if (fr.files.length > 0) {
+      const added = fr.files.filter(f => !deps.includes(f))
+      frLinked = added
+      frReport = { frCount: fr.frHits.length, fileCount: fr.files.length, addedCount: added.length }
+      console.log(`ℹ️ FR 关联回归：触达 ${fr.frHits.length} 条 active FR（${fr.frHits.slice(0, 3).map(h => h.id).join('、')}${fr.frHits.length > 3 ? ' 等' : ''}）→ 绑定测试 ${fr.files.length} 个${added.length < fr.files.length ? `（新增并入 ${added.length}）` : ''} 进实测面`)
+    }
+    if (fr.unresolved.length > 0) {
+      console.warn(`⚠️ ${fr.unresolved.length} 个 FR 绑定测试路径无法自仓根解析（不入实测面）：${fr.unresolved.slice(0, 3).join('、')}${fr.unresolved.length > 3 ? ' 等' : ''}——sillyspec tests repair-paths 可修`)
+    }
+  }
+  const depsAll = [...new Set([...deps, ...frLinked])].sort()
+  let depsBatches = []
+  if (depsAll.length > 0) {
+    depsBatches = buildDepsBatches({ deps: depsAll, changedFiles, hits, cwd, priorityFiles: frLinked })
+    for (const b of depsBatches) {
+      if (b.skip) {
+        // JSX 无项目运行器批（residual-runner-parity）：skip 不跑不拦，reason 点名让漏测可见
+        console.warn(`⚠️ ${b.name}：${b.reason}`)
+        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 伪败与字母序偏科）`)
+    }
   }
   const status = aggregateStatus(perModule)
 
   let command = `module[${hits.map(h => h.name).join(',')}]`
-  if (deps.length > 0) command += `+deps(${Math.min(deps.length, 30)})`
+  if (depsBatches.length > 0) command += `+deps(${depsBatches.map(b => `${b.short}${b.count}`).join('+')})`
+  if (frReport) command += `+fr(${frReport.fileCount})`
   const exitCode = status === 'passed' ? 0 : 1
   const durationMs = Date.now() - subsetStartedAt
 
@@ -2012,12 +2688,16 @@ function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [],
     .join('\n')
   const reason = status === 'passed'
     ? null
-    : `模块子集测试失败：${perModule.filter(r => r.status === 'failed').map(r => r.name).join(', ')}`
-      // 失败模块的 reason 明细透传（坑 verify-devserver-port-race：EADDRINUSE 资源竞争鉴别
-      // 提示在 runOneModule 的 reason 里，不透传会被顶层 reason 吞掉）
-      + (perModule.filter(r => r.status === 'failed' && r.reason).some(r => /EADDRINUSE|资源竞争/.test(r.reason))
-        ? '。' + perModule.filter(r => r.status === 'failed' && r.reason && /EADDRINUSE|资源竞争/.test(r.reason)).map(r => r.reason).join('；')
-        : '')
+    : status === 'skipped'
+      // 环境缺件跳过聚合（2026-09-23 CNF 降档）：跑过的模块全绿、缺件模块中止——不硬拦，
+      // reason 点名跳过模块让「本次实测没覆盖到它们」可见（防静默漏测）
+      ? `模块子集含环境缺件跳过（已跑模块全绿）：${perModule.filter(r => r.status === 'skipped').map(r => r.name).join('、')}——补装依赖后恢复实测`
+      : `模块子集测试失败：${perModule.filter(r => r.status === 'failed').map(r => r.name).join(', ')}`
+        // 失败模块的 reason 明细透传（坑 verify-devserver-port-race：EADDRINUSE 资源竞争鉴别
+        // 提示在 runOneModule 的 reason 里，不透传会被顶层 reason 吞掉）
+        + (perModule.filter(r => r.status === 'failed' && r.reason).some(r => /EADDRINUSE|资源竞争/.test(r.reason))
+          ? '。' + perModule.filter(r => r.status === 'failed' && r.reason && /EADDRINUSE|资源竞争/.test(r.reason)).map(r => r.reason).join('；')
+          : '')
 
   const result = {
     status,
@@ -2027,13 +2707,16 @@ function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [],
     outputTail: outputTail.length > OUTPUT_TAIL_CHARS ? '…' + outputTail.slice(-OUTPUT_TAIL_CHARS) : outputTail,
     reason,
     resultPath: null,
-    mode: 'module-subset',
+    mode: 'dynamic-subset',
     fallbackReason: null,
     exemptedCount: perModule.reduce((n, r) => n + (r.exemptedCount || 0), 0),
     // 判账行集聚合（坑 verify-test-reconcile-tail-blindspot）：合并 tail 会二次截断，行集不截——
     // 每模块台账另见 extra.modules[].failure_remaining（带模块归属）
     failureRemaining: perModule.flatMap(r => r.failureRemaining || []),
     failureExempted: perModule.flatMap(r => r.failureExempted || []),
+    // 逐模块结论（isTimeoutOnlyTestFailure 的单元口径；writeRunResult extra 之外再随结果
+    // 返回，调用方可精确分单元判超时/真挂，不依赖聚合 reason 文本）
+    modules: perModule.map(r => ({ name: r.name, status: r.status, reason: r.reason, durationMs: r.durationMs })),
   }
 
   writeRunResult({
@@ -2736,6 +3419,7 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
   // 消费方按「planned ∩ excluded ∩ 盘面存在」标「疑似他者已实现」。
   const foreignExcludedFiles = []
   let baseAnchor = null
+  let commitWindowFiles = []
 
   if (form === 'worktree') {
     // —— 形态 A：worktree 存活，整链复用（锚点优先级 baselineCommit>actualBaseHash>baseHash、
@@ -2761,9 +3445,37 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
     const branch = 'sillyspec/' + changeName
     const branchHash = gitQuiet(cwd, ['rev-parse', '--verify', '--quiet', branch + '^{commit}'], { timeout: 30 * 1000 })
     const auditTag = 'sillyspec-audit/' + branch
+    // 第三候选（2026-09-26-reconcile-source-isolation，R18-SF-full 对账死锁实证）：分支名约定
+    // sillyspec/<change> 对非约定命名的分支（实验分支 r18/sf-full 等）落空 → B1 全缺 → agent
+    // 发明「暂存物化」自救又被并行会话裸提交扫走（4 种面重建 matched=0 死循环）。硬化：扫
+    // worktrees meta 的 changeName 键匹配取真实 branch（meta.branch 由 worktree 建立时写入）。
+    let metaBranchRef = null
+    if (!(typeof branchHash === 'string' && branchHash.trim()) && !gitQuiet(cwd, ['rev-parse', '--verify', '--quiet', auditTag + '^{commit}'], { timeout: 30 * 1000 })) {
+      try {
+        const wtBase = join(runtimeRoot || join(sb, '.runtime'), 'worktrees')
+        if (existsSync(wtBase)) {
+          for (const e of readdirSync(wtBase, { withFileTypes: true })) {
+            if (!e.isDirectory()) continue
+            try {
+              const mp = join(wtBase, e.name, 'meta.json')
+              if (!existsSync(mp)) continue
+              const m = JSON.parse(String(readFileSync(mp, 'utf8')).replace(/^\uFEFF/, ''))
+              if (m && m.changeName === changeName && typeof m.branch === 'string' && m.branch.trim()) {
+                if (gitQuiet(cwd, ['rev-parse', '--verify', '--quiet', m.branch.trim() + '^{commit}'], { timeout: 30 * 1000 })) {
+                  metaBranchRef = m.branch.trim()
+                  // 源串在 merge-base 验证成功后 push（评审 P3 清偿：此处早 push 时若 merge-base
+                  // 失败——非 main 主分支名——sources 谎报该源在场且 hint 假阴性）
+                }
+                break
+              }
+            } catch { /* 单 meta 损坏试下一个 */ }
+          }
+        }
+      } catch { /* meta 扫描失败静默省略 */ }
+    }
     const diffRef = (typeof branchHash === 'string' && branchHash.trim())
       ? branch
-      : (gitQuiet(cwd, ['rev-parse', '--verify', '--quiet', auditTag + '^{commit}'], { timeout: 30 * 1000 }) ? auditTag : null)
+      : (gitQuiet(cwd, ['rev-parse', '--verify', '--quiet', auditTag + '^{commit}'], { timeout: 30 * 1000 }) ? auditTag : (metaBranchRef || null))
     if (diffRef) {
       // 形态 B 定义下 meta 已删，baseBranch 无从读 → 缺省 'main'（run/prompt.js:764 同缺省）；
       // 主分支叫 master 等仓库 merge-base 失败 → 与分支不存在同处置（省略该源）
@@ -2774,6 +3486,7 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
         if (files !== null) {
           diffOk = true
           sources.push('main:diff-merge-base')
+          if (diffRef === metaBranchRef) sources.push(`main:diff-merge-base(meta-branch:${metaBranchRef})`) // merge-base 验证成功才记源（评审 P3）
           for (const f of files) union.add(normalizeReconcilePath(f))
         }
       }
@@ -2794,6 +3507,25 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
       }
       for (const f of files) union.add(normalizeReconcilePath(f))
     }
+    // B4 isolation-worktree 提交窗口兜底（2026-09-24 R9/R11 根治：isolated worktree 内
+    // per-task commit 后 porcelain 恒空，B1 分支已删/B2 未提交面零 → declared 13 条全 missing
+    // 四连拦，逼出规则 23 reset 重组。收集 HEAD 近窗提交触及面（--name-only，窗口 20 提交
+    // 与 buildSnapshot commits 同口径；fail-open 静默省略）——**declared-rescue-only**：
+    // 不进全局 union（防其他变更提交文件污染 undeclared 假红），仅供消费方对
+    // 「声明而 missing」的文件做窗口命中救赎。
+    try {
+      // 锚定变更分支/审计 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 })
+      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) {
+          commitWindowFiles = files
+          sources.push(`main:log-20-commit-window(declared-rescue-only:${rescueRef})`)
+        }
+      }
+    } catch { /* 窗口源失败静默省略 */ }
     // B3 apply-pathspec 兜底（存在则并入，读取失败静默忽略——前两源不受影响）
     const pathspecFile = join(runtimeRoot, `apply-pathspec-${changeName}.txt`)
     if (existsSync(pathspecFile)) {
@@ -2812,7 +3544,15 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
   }
 
   const files = [...new Set(filterDeliverableFiles([...union]).filter(Boolean))].sort()
-  return { ok: true, form, files, sources, foreignExcluded, foreignExcludedFiles, degradedReason: null, baseAnchor }
+  // 多会话推进死锁诊断（reconcile-source-isolation，R18-SF-full 实证）：post-apply 形态下
+  // 实际面全空（B1 无 ref + porcelain 无未提交面 + 无 apply-pathspec 兜底）= 典型「主仓被
+  // 并行会话推进」形态（本变更提交/暂存被他人裸提交带走）——历史上 agent 被逼发明「暂存
+  // 物化」自救（touch 文件进共享暂存区），随即又被扫走形成 matched=0 死循环。诊断先行指明
+  // 安全出路，杜绝危险自救；消费方（reconcileTargetFiles/gates）把它带进 notes。
+  const parallelAdvanceHint = (form === 'post-apply' && files.length === 0 && union.size === 0 && !sources.some((s) => s.startsWith('main:diff-merge-base') || s.startsWith('apply-pathspec')))
+    ? '⚠️ actual 源全空（无分支锚点 diff + 主仓无未提交面 + 无 apply-pathspec 兜底）——典型「主仓被并行会话推进」形态（本变更的提交/暂存可能已被他侧裸提交扫走）。切勿用「暂存物化」自救（touch 文件进共享暂存区——会被再次扫走且污染他侧，R18-SF-full 实证 matched=0 死循环）；出路：① 恢复/登记本变更分支（worktree meta.json 的 branch 字段）让锚定 diff 生效后重跑 ② 确属全量已在他侧提交：与该会话按 AGENTS 规则 18 对账后以该提交为锚核销'
+    : null
+  return { ok: true, form, files, sources, foreignExcluded, foreignExcludedFiles, degradedReason: null, baseAnchor, commitWindowFiles, parallelAdvanceHint }
 }
 
 /**
@@ -2959,6 +3699,12 @@ export function reconcileTargetFiles({ cwd, specBase = null, changeName = null,
 
   // —— actual 侧（三源并集，两形态）——
   const actual = resolveReconcileActualFiles({ cwd, specBase: sb, runtimeRoot: rt, changeName })
+  if (actual.parallelAdvanceHint) {
+    // console 直出（评审 P2 清偿）：死锁时刻 agent 先见的是 gates 的 missing_declared 红色
+    // 清单（通用修复指引），hint 只落 notes 会被淹没——诊断必须先于/伴随阻断清单可见。
+    console.warn(actual.parallelAdvanceHint)
+    notes.push(actual.parallelAdvanceHint)
+  }
   if (actual.foreignExcluded > 0) {
     notes.push(`主仓 status 捕入的 ${actual.foreignExcluded} 个并行会话声明文件已剔除（不参与本变更对账）`)
   }
@@ -2984,6 +3730,20 @@ export function reconcileTargetFiles({ cwd, specBase = null, changeName = null,
   const actualKeySet = new Set(actual.files.map(pathKey));
   const declaredPaths = [...new Set(decl.declarations.map(d => d.path))].sort()
   const declaredKeySet = new Set(declaredPaths.map(pathKey))
+  // declared-rescue（2026-09-24 R9/R11 根治接线）：isolated worktree per-task commit 形态下
+  // porcelain 恒空/分支已删，declared 全落②类假红——近窗提交触及面只用于救赎「声明而
+  // missing」的文件（窗口∩declared 才入 actualKeySet，不扩 undeclared 面）。
+  const windowKeySet = new Set((actual.commitWindowFiles || []).map(pathKey))
+  let rescuedCount = 0
+  for (const path of declaredPaths) {
+    if (!actualKeySet.has(pathKey(path)) && windowKeySet.has(pathKey(path))) {
+      actualKeySet.add(pathKey(path))
+      rescuedCount++
+    }
+  }
+  if (rescuedCount > 0) {
+    notes.push(`对账救赎：${rescuedCount} 个声明文件经近窗提交触及面命中（isolated worktree per-task commit 形态，porcelain 恒空——R9/R11 四连拦根治）`)
+  }
   // ①交集（计数进 evidence）：唯一路径口径（多卡声明同文件只计一次）
   for (const path of declaredPaths) {
     if (actualKeySet.has(pathKey(path))) matched.push(path)