sillyspec 3.29.4 → 3.29.5

package/src/run/gates.js

@@ -861,6 +861,47 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     } catch { /* advisory 失败不阻断完成（fail-soft，facade 预检先例同款） */ }
   }
 
+  // ── fail-fast 前置：纯文档 blocking 检查先于 test/lint 实测门（R4-S-F 实证，2026-09-21）──
+  // module-impact 死信与预填注清零 error 门只读文档零外部执行，原先排在 9 分钟级 test+lint
+  // 实测门之后——文档未清时每轮 --done 都先白烧一轮门禁再被拦（R4-S-F 166min 的主要形状）。
+  // 前置到实测门之前：秒级失败秒级返工，贵的门只在文档面已清后才跑。
+  if (stageName === 'verify' && changeName) {
+    // module-impact 死信探针（blocking，债单 D-1/D-5）：更新结果表 pending/待办行 → 阻断 verify。
+    // 与 archive 移动前校验（extractPendingDocSyncRows）同一口径，把死信号从 archive 提前到 verify：
+    // agent 在 verify 阶段就须完成文档同步并回填 done/skipped，而非拖到归档被拦。
+    const verifyChangeDir = resolveChangeDir(cwd, progress, platformOpts?.specRoot)
+    if (verifyChangeDir) {
+      const impactPath = join(verifyChangeDir, 'module-impact.md')
+      if (existsSync(impactPath)) {
+        const { extractPendingDocSyncRows } = await import('./complete-handlers.js')
+        const pendingRows = extractPendingDocSyncRows(readFileSync(impactPath, 'utf8'))
+        if (pendingRows.length > 0) {
+          console.error(`\n❌ verify 阶段被阻断：module-impact.md「更新结果」表存在 ${pendingRows.length} 个未清 pending/待办项（死信）`)
+          for (const row of pendingRows) console.error(`   - ${row}`)
+          console.error('   文档同步是 verify 的收尾义务：请完成模块文档同步并回填状态为 done/skipped（说明原因），再重新完成 verify。')
+          return rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
+        }
+      }
+    }
+    // 预填注清零 error 门（归档前最后一道；2026-09-18-artifact-prefill task-03 / FR-03 / D-003@v1
+    // 门禁梯度·error 档）：白名单槽宿主文件（design.md + tasks/task-*.md）仍含未删预填注 →
+    // 阻断 verify 完成。brainstorm/plan --done 的 advisory 在此收口为硬门，注在场=预填未确认。
+    // 检测单点 = runProbe10PrefillNoteClearance（不二算）。已知误报面：散文引用注字面量会命中
+    // ——修法是核对后删注/改写散文措辞，不是绕门。
+    try {
+      const { runProbe10PrefillNoteClearance } = await import('../verify-probes.js')
+      const noteClearance = runProbe10PrefillNoteClearance({ specBase, changeName })
+      if (noteClearance.unclearedFiles.length > 0) {
+        console.error(`\n❌ verify 阶段被阻断：预填注清零校验未过（${noteClearance.unclearedFiles.length} 个文件的白名单槽仍含未删预填注——预填≠结论，注在场=未确认）：`)
+        for (const f of noteClearance.unclearedFiles) console.error(`   - ${f}`)
+        console.error('   修复：逐槽核对预填值后删除行尾「(预填：核对后删本注)」注（删注=确认动作）；散文含注字面量的命中改写该处措辞。清零后重新完成 verify（进度不丢）。')
+        return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
+      }
+    } catch (e) {
+      console.warn(`⚠️ 预填注清零校验异常（降级放行，fail-soft——异常不是未清零，ceremony 双跑同款处置）: ${(e && e.message) || e}`)
+    }
+  }
+
   // verify 产物校验通过 + 结论非 FAIL（否则上面已阻断）。
   // 再由 CLI 亲自执行 local.yaml 的测试命令，与 verify-result.md 的自报告对账：
   // 自报告 PASS 但实测失败 → 阻断（防止"文案通过"绕过验证）。
@@ -937,6 +978,20 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       }
     } catch { /* fail-soft：回填失败不影响门禁 */ }
     if (testCheck.status === 'failed') {
+      // ── 纯超时降档（R4 门禁价值考古 2026-09-21：227 跑 106 败里 36 次 600s 帽杀纯超时假拦
+      //    =失败桶最大单一来源）。超时=未完成非测试挂——所有失败单元 reason 均含超时 → advisory
+      //    放行带处置指引；任一单元真实挂测/退出码 → 维持原硬拦（真拦 12 次的防线不动）。──
+      let timeoutOnly = false
+      try {
+        const { isTimeoutOnlyTestFailure } = await import('../verify-postcheck.js')
+        timeoutOnly = isTimeoutOnlyTestFailure(testCheck)
+      } catch { /* 判定链异常维持硬拦（保守） */ }
+      if (timeoutOnly) {
+        if (verifyGateSnap) { try { verifyGateSnap.cleanup() } catch {} ; verifyGateSnap = null }
+        console.warn('\n⚠️ Verify 实测门未在超时帽内完成（纯超时，无任何挂掉的测试）——降档 advisory 不阻断：')
+        console.warn(`   ${testCheck.reason || ''}`)
+        console.warn('   处置：① local.yaml 配置 modules: 块（name: { path, test }）启用模块子集实测——触碰模块全套测试，时长与超时同步收窄；② 定向复跑触碰模块自证；③ 确需长跑设 SILLYSPEC_TEST_TIMEOUT_MS。')
+      } else {
       if (verifyGateSnap) {
         try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
           printSnapshotFailureHint(verifyGateSnap) } catch { /* 提示失败不影响阻断 */ }
@@ -953,6 +1008,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       } catch { /* 归因提示失败不影响阻断语义 */ }
       console.error('   请修复失败的测试并更新 verify-result.md 后重新完成此步骤。')
       return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-test' })
+      } // else（纯超时降档分支）结束——真实测试失败分支的 rollback 语义不变
     }
     // lint 对账（2026-08-21 审查 CLI-1）：test 侧"自报告 PASS 但实测失败→阻断"已闭环，
     // lint 侧此前纯口头——CLI 亲自执行 commands.lint，advisory 起步（失败打印不阻断，观察期后升级）
@@ -983,6 +1039,22 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     // 逃生 SILLYSPEC_VERIFY_LINT_GATE=advisory）
     const { shouldBlockVerifyLint } = await import('../verify-postcheck.js')
     if (shouldBlockVerifyLint(lintCheck)) {
+      // ── lint 归属鉴定降档（R4-S-F 实证：verify 侧 lint 硬门 7 轮全是 HEAD 存量债——隔离
+      //    快照含基线债文件时恒败，agent 被逼范围外清偿或逃生口）。失败输出提及文件 × 本变更
+      //    文件集零交集 → 存量债 advisory 降档放行（债非本变更引入，硬拦只是制造范围外功）；
+      //    有交集 / 输出无可识别路径（unattributable，纯配置错误类）→ 维持硬拦（保守）。──
+      let lintOwnership = null
+      try {
+        const { triageLintOwnership, resolveVerifyChangedFiles } = await import('../verify-postcheck.js')
+        const lintScopeFiles = (resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase }) || [])
+          .map(f => String(f).replace(/\\/g, '/')).filter(f => !f.startsWith('.sillyspec/'))
+        lintOwnership = triageLintOwnership({ failureFiles: lintCheck.failureFiles || [], changeFiles: lintScopeFiles })
+      } catch { /* 鉴定链异常维持硬拦（保守） */ }
+      if (lintOwnership && lintOwnership.verdict === 'pre-existing') {
+        console.warn('\n⚠️ Verify lint 实测失败，但归属鉴定为 HEAD 存量债（失败提及文件与本变更文件集零交集）——降档 advisory 不阻断 verify 完成：')
+        console.warn(`   存量债文件：${(lintCheck.failureFiles || []).join('、') || '（见上方输出）'}`)
+        console.warn('   处置建议：单独 quick 机械清偿（顺手清债解锁全仓 lint 门），或本变更确认无关时设 SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕）。债随基线存在，与本变更交付无关。')
+      } else {
       console.error('\n❌ verify 阶段被阻断：CLI 亲自实测 lint 失败（agent 的 lint 自报告与实测不符时以实测为准）。')
       if (usedSnapInfo) {
         try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
@@ -1006,6 +1078,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       }
       console.error('   修复后重跑 --done（进度不丢）；确认要跳过实测请设 SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕）。')
       return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-lint' })
+      } // else（pre-existing 降档分支）结束——维持硬拦分支的 rollback 语义不变
     }
     // 契约 parity 对账：扫前端 API 调用 vs execute 提取的 provider endpoint artifact。
     // 接线自 contract-matrix pipeline（verifyApiParity 的 CLI 入口）。
@@ -1076,6 +1149,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     // 放行态），fail-soft 不影响 gate 判定；②类阻断回执同样留档供平台/审计消费
     writeReconcileRunResult({ runtimeRoot: reconcileRuntimeRoot, changeName, envelope: reconcileEnvelope, result: reconcileCheck })
     if (reconcileBlocked) {
+      writeVerifyGatePointer({ runtimeRoot: reconcileRuntimeRoot, changeName, blocked: true, note: 'target_files ②类（missing_declared）阻断' })
       return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
     }
     // ── verify-result.md 探针预填段一致性抽查（task-03 / ir-stage-p3b D-002@v1 方案A）──
@@ -1122,6 +1196,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     // 两检查间耦合；各写各的回执、按文件名订阅更干净。fail-soft 不影响 gate 判定
     writeProbeConsistencyRunResult({ runtimeRoot: reconcileRuntimeRoot, changeName, envelope: probeEnvelope, result: probeCheck })
     if (probeBlocked) {
+      writeVerifyGatePointer({ runtimeRoot: reconcileRuntimeRoot, changeName, blocked: true, note: '探针一致性抽查 error 阻断' })
       return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
     }
     // ── ceremony 双跑收口·第一出口（2026-09-18-ceremony-risk-pricing task-04 / FR-03 / D-003；
@@ -1164,43 +1239,9 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
         }
       }
     } catch { /* 自动重锚失败不影响收尾（docs gate 兜底） */ }
-    // ── module-impact 死信探针（blocking，债单 D-1/D-5）：更新结果表 pending/待办行 → 阻断 verify ──
-    // 与 archive 移动前校验（extractPendingDocSyncRows）同一口径，把死信号从 archive 提前到 verify：
-    // agent 在 verify 阶段就须完成文档同步并回填 done/skipped，而非拖到归档被拦（修复 perf-remediation
-    // 类「verify PASS → archive 才发现 pending」的时序漏洞）。
-    const verifyChangeDir = resolveChangeDir(cwd, progress, platformOpts?.specRoot)
-    if (verifyChangeDir) {
-      const impactPath = join(verifyChangeDir, 'module-impact.md')
-      if (existsSync(impactPath)) {
-        const { extractPendingDocSyncRows } = await import('./complete-handlers.js')
-        const pendingRows = extractPendingDocSyncRows(readFileSync(impactPath, 'utf8'))
-        if (pendingRows.length > 0) {
-          console.error(`\n❌ verify 阶段被阻断：module-impact.md「更新结果」表存在 ${pendingRows.length} 个未清 pending/待办项（死信）`)
-          for (const row of pendingRows) console.error(`   - ${row}`)
-          console.error('   文档同步是 verify 的收尾义务：请完成模块文档同步并回填状态为 done/skipped（说明原因），再重新完成 verify。')
-          return rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
-        }
-      }
-    }
-    // ── 预填注清零 error 门（归档前最后一道；2026-09-18-artifact-prefill task-03 / FR-03 /
-    //    D-003@v1 门禁梯度·error 档）：白名单槽宿主文件（design.md + tasks/task-*.md）仍含
-    //    未删预填注 → 阻断 verify 完成（verify 完成是 archive 前置——「归档前注清零」的落点；
-    //    brainstorm/plan --done 的 advisory 在此收口为硬门，注在场=预填未确认）。检测单点 =
-    //    verify-probes 探针面 runProbe10PrefillNoteClearance（探针 10 --init 预填与本门同一
-    //    实现，不二算）。已知误报面：散文引用注字面量会命中——修法是核对后删注/改写散文
-    //    措辞，不是绕门。──
-    try {
-      const { runProbe10PrefillNoteClearance } = await import('../verify-probes.js')
-      const noteClearance = runProbe10PrefillNoteClearance({ specBase, changeName })
-      if (noteClearance.unclearedFiles.length > 0) {
-        console.error(`\n❌ verify 阶段被阻断：预填注清零校验未过（${noteClearance.unclearedFiles.length} 个文件的白名单槽仍含未删预填注——预填≠结论，注在场=未确认）：`)
-        for (const f of noteClearance.unclearedFiles) console.error(`   - ${f}`)
-        console.error('   修复：逐槽核对预填值后删除行尾「(预填：核对后删本注)」注（删注=确认动作）；散文含注字面量的命中改写该处措辞。清零后重新完成 verify（进度不丢）。')
-        return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-contract' })
-      }
-    } catch (e) {
-      console.warn(`⚠️ 预填注清零校验异常（降级放行，fail-soft——异常不是未清零，ceremony 双跑同款处置）: ${(e && e.message) || e}`)
-    }
+    // ── module-impact 死信探针 + 预填注清零 error 门：已前移至 test/lint 实测门之前 ──
+    // （fail-fast，R4-S-F 实证——纯文档 blocking 检查排在 9 分钟实测门后白烧门禁轮次；
+    //   实现体见上方「fail-fast 前置」块，此处不再重复执行。）
     // ── verify 服务进程回收（坑 verify-service-process-leak；坑 verify-pids-cross-session-kill
     // 见 reapVerifyServices 注释）──
     try {
@@ -1890,6 +1931,42 @@ export function writeReconcileRunResult({ runtimeRoot, changeName, envelope, res
   }
 }
 
+/**
+ * verify --done 阻断明细稳定锚点（quick-D，2026-09-20 报告问题 D）：ts 目录（verify-runs/<ts>/
+ * reconcile-result.json 等）的可发现性依赖 stdout——宿主把长命令转后台截断输出后，逐条打印的
+ * ②类明细实际取不回（实证：target_files 阻断明细靠推断绕 3 轮才定位）。稳定路径指针（每次
+ * 覆盖、不随 ts 变）指向本轮最新 verify-runs 目录，agent 无 stdout 也能直读。fail-soft：
+ * 写失败只留痕不阻断 gate（对齐 writeReconcileRunResult 口径）。
+ * @param {{ runtimeRoot: string, changeName: string|null, blocked?: boolean, note?: string }} opts
+ * @returns {string|null} 成功返回指针路径；失败返回 null
+ */
+export function writeVerifyGatePointer({ runtimeRoot, changeName, blocked = false, note = '' }) {
+  try {
+    const ts = new Date().toISOString().slice(0, 19).replace(/[-T:]/g, '')
+    const runsDir = join(runtimeRoot, 'verify-runs')
+    const pointerPath = join(runsDir, `gate-last-${changeName || 'change'}.json`)
+    mkdirSync(runsDir, { recursive: true })
+    writeFileSync(pointerPath, JSON.stringify({
+      change: changeName,
+      blocked,
+      note,
+      latest_run_dir: join(runsDir, ts),
+      artifacts_hint: [
+        `${ts}/reconcile-result.json（target_files ②类阻断明细在 missing 数组）`,
+        `${ts}/probe-consistency-result.json（探针一致性抽查明细）`,
+      ],
+      written_at: new Date().toISOString(),
+    }, null, 2) + '\n')
+    if (blocked) {
+      console.error(`\n📄 verify 门失败明细稳定锚点（stdout 被截断时直读此文件）: ${pointerPath}\n   逐条明细在指针文件指向的 verify-runs/<ts>/ 目录（reconcile-result.json 的 missing 数组等）`)
+    }
+    return pointerPath
+  } catch (e) {
+    console.error(`⚠️ verify 门稳定锚点写入失败（不影响 gate）: ${e.message}`)
+    return null
+  }
+}
+
 /**
  * 打印 target_files 对账结果（task-05 接线配套的打印层）。
  *

package/src/run/quick-audit.js

@@ -472,8 +472,34 @@ export async function runQuickTestLintGate({ cwd, specBase, changedFiles = [], d
       lint = runVerifyLintCheck({ cwd, specBase })
     }
     const failed = []
-    if (test.status === 'failed') failed.push('test')
-    if (lint.status === 'failed') failed.push('lint')
+    // 纯超时降档（R4 门禁价值考古：36/106 失败是 600s 帽杀纯超时假拦——超时=未完成非测试挂）。
+    // 所有失败单元 reason 均含超时 → advisory 不计入 failed；任一单元真实挂测 → 维持硬拦。
+    if (test.status === 'failed') {
+      const { isTimeoutOnlyTestFailure } = await import('../verify-postcheck.js')
+      if (isTimeoutOnlyTestFailure(test)) {
+        console.warn(`\n⚠️ quick test 实测纯超时（无任何挂掉的测试）——不拦完成：${test.reason || ''}`)
+        console.warn('   处置：定向复跑触碰模块自证；常发超时建议 local.yaml 配 modules: 块启用模块子集实测。')
+      } else {
+        failed.push('test')
+      }
+    }
+    // ── lint 归属鉴定降档（R4-S-F/R4-S-Q 同根因：隔离快照含 HEAD 存量债文件时 lint 恒败，
+    //    agent 被逼范围外清偿才过门）。失败输出提及文件 × 本会话文件集零交集 → 存量债
+    //    advisory 放行不拦完成；有交集 / 输出无可识别路径（unattributable）→ 维持硬拦。──
+    if (lint.status === 'failed') {
+      const { triageLintOwnership } = await import('../verify-postcheck.js')
+      const own = triageLintOwnership({
+        failureFiles: lint.failureFiles || [],
+        changeFiles: files.map(f => String(f).replace(/\\/g, '/')),
+      })
+      if (own.verdict === 'pre-existing') {
+        console.warn(`\n⚠️ quick lint 实测失败，但归属鉴定为 HEAD 存量债（失败提及文件与本会话文件集零交集）——不拦完成`)
+        console.warn(`   存量债文件：${(lint.failureFiles || []).join('、') || '（见上方输出）'}`)
+        console.warn('   处置建议：单独 quick 机械清偿解锁全仓 lint 门（顺手清债）；确与本会话无关可忽略本行。')
+      } else {
+        failed.push('lint')
+      }
+    }
     if (failed.length > 0 && snapshot) {
       try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
         printSnapshotFailureHint({ snapshotRoot: snapshot.snapshotRoot, changeFileCount: snapshot.overlaid, sourceRoot: snapshot.sourceRoot || null }, { offEnv: 'SILLYSPEC_QUICK_GATE_SNAPSHOT_OFF' })

package/src/run/shared.js

@@ -1291,7 +1291,9 @@ async function matchQuickModules(srcChanged, specBase, projectName) {
  * @param {string} projectName 项目名（progress.project）
  * @returns {Promise<object|null>} 模块索引（扁平 { id: {...} }）；不可得 → null
  */
-async function loadQuickModuleIndex(specBase, projectName) {
+// quick 资产尾②（changelog 边车）消费：complete-handlers 动态 import 解构取用——
+// 缺 export 曾致「loadQuickModuleIndex is not a function」fail-open 死路（R4-S-Q 实证）。
+export async function loadQuickModuleIndex(specBase, projectName) {
   if (!specBase || !projectName) return null
   try {
     const mapPath = join(specBase, 'docs', projectName, 'modules', '_module-map.yaml')

package/src/stages/execute.js

@@ -1281,10 +1281,10 @@ ${workdirLines}
     : `- 组内任意两个 task 之间无 provides / expects_from 契约链（契约 task 禁止同批——串行实现会读到半成品，契约 task 由独立子代理并行处理或落在不同 Wave）`
   const roleItem1 = implicit
     ? `1. 为每个任务启动一个子代理（Agent tool），或按上述三条件把多个任务合并为一个 batch 子代理，逐个完成（串行——启动一个、等它完成并审查后再启动下一个，见「调度要求」串行铁律）`
-    : `1. 为每个任务启动一个子代理（Agent tool），或按上述三条件把多个任务合并为一个 batch 子代理，同 Wave 内可并行`
+    : `1. 为每个任务启动一个子代理（Agent tool），或按上述三条件把多个任务合并为一个 batch 子代理，同 Wave 内可并行——但同时在飞子代理 ≤3（见「调度要求」并发帽，超出的 batch 排队错峰）`
   const scheduleItem1 = implicit
     ? `1. **隐式 Wave 串行铁律**：本 Wave 由 plan.md 无显式 Wave 划分时合成——任务一律逐个完成（单子代理串行逐个实现，或逐个启动子代理并等待其完成再启动下一个），**禁止并行启动**（未做过文件正交/契约链核查，并行不安全；需要并行收益请在 plan.md 显式划分 Wave）。`
-    : `1. **同一 Wave 的多个子代理（独立或 batch）必须并行启动，batch 内部串行**（batch 分组仅按文件正交 / 无契约链判定，不改变 Wave 依赖语义——Wave 定义=无依赖可并行；有依赖应在 plan.md 的不同 Wave 中）。`
+    : `1. **同一 Wave 的多个子代理（独立或 batch）并行启动、batch 内部串行，且同时在飞 ≤3**（batch 分组仅按文件正交 / 无契约链判定，不改变 Wave 依赖语义——Wave 定义=无依赖可并行；有依赖应在 plan.md 的不同 Wave 中。并发帽 3：Wave 内子代理超 3 个时分两批错峰——首批完成后回收槽位再派第二批；4 路齐发实证触发平台额度/限流耗尽，整 Wave 中断 17 分钟由用户手动恢复，得不偿失）。`
 
   return `${waveHeader}
 

package/src/stages/plan-postcheck.js

@@ -21,6 +21,7 @@ import { parseFileChangeList, pathMatches } from '../change-list.js'
 import { getRule } from '../stage-contract-spec.js'
 import { TASKCARD_PLACEHOLDERS } from '../taskcard-placeholders.js'
 import { validateScriptCommands } from './cmd-existence.js'
+import { parseTaskFrontmatter } from '../taskcard-frontmatter.js'
 
 // ═══════════════════════════════════════════════════════════════
 // 解析工具（从 plan.js 迁移）
@@ -319,21 +320,20 @@ function hasTddOrVerify(content) {
 
 /**
  * 解析 task-NN.md 的跨任务契约字段 provides / expects_from
- * 用 js-yaml 解析 frontmatter（嵌套结构，正则不可靠）。
- * provides/expects_from 为可选字段；缺失或解析失败时返回空（不阻断）。
+ * 解析归一 taskcard-frontmatter.js 单一源（2026-09-20-taskcard-yaml-hardgate：此前本函数与
+ * verify-probes 各自提取+吞错，坏 YAML 冒充「无契约字段」致 [plan.cross-task-contract] 空真过门）。
+ * provides/expects_from 为可选字段；缺失返回空（不阻断）；frontmatter 非法 YAML 返回空 +
+ * yamlError 显式降级键（不冒充无字段——YAML 合法性由 validatePlanFeasibility 步骤 0b 硬拦，
+ * D-001@v2 单点拦截先例；yamlError 供独立消费方判读）。
  * @param {string} content - task 文件内容
- * @returns {{ provides: Array<{contract, fields}>, expectsFrom: Record<string, Array<{contract, needs}>> }}
+ * @returns {{ provides: Array<{contract, fields}>, expectsFrom: Record<string, Array<{contract, needs}>>,
+ *   yamlError: {message: string, line: number, column: number}|null }}
  */
 export function parseTaskContracts(content) {
-  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/)
-  if (!fmMatch) return { provides: [], expectsFrom: {} }
-  let fm
-  try {
-    fm = jsYaml.load(fmMatch[1]) || {}
-  } catch {
-    // frontmatter 非合法 YAML（老格式/手写不规范）—— 当作无契约字段，不阻断
-    return { provides: [], expectsFrom: {} }
-  }
+  const parsed = parseTaskFrontmatter(content)
+  if (!parsed.hasFrontmatter) return { provides: [], expectsFrom: {}, yamlError: null }
+  if (!parsed.ok) return { provides: [], expectsFrom: {}, yamlError: parsed.error }
+  const fm = parsed.fm
 
   const provides = Array.isArray(fm.provides)
     ? fm.provides.map(p => ({
@@ -355,7 +355,7 @@ export function parseTaskContracts(content) {
     }
   }
 
-  return { provides, expectsFrom }
+  return { provides, expectsFrom, yamlError: null }
 }
 
 // ═══════════════════════════════════════════════════════════════
@@ -1300,6 +1300,21 @@ export function validatePlanFeasibility(changeDir, projectRoot = null) {
       errors.push(`${dupTaskId || file}: frontmatter 顶层键 ${dup.key} 重复出现 ${dup.lines.length} 次（L${dup.lines.join('、L')}）——骨架已自动反填的键（如 depends_on）勿重复手填，保留正确一处删除其余`)
     }
 
+    // 0b. frontmatter YAML 合法性硬校验（2026-09-20-taskcard-yaml-hardgate FR-02 / D-001@v2——
+    // D-004@v1 重复键拦截的同类泛化：jsYaml 抛错族错误只能在 feasibility 入口单点拦截，
+    // 否则下游 4 处 catch 静默降级令 [plan.cross-task-contract] 空真过门。双报豁免（双维度
+    // 同信号须豁免惯例）：message 含 duplicated mapping key 且 dupKeys 非空时跳过——上方 0
+    // 已用键名+行号精确上报；嵌套重复键（detectDuplicateTopKeys 顶格正则够不到）仍由此兜底。
+    const fmParse = parseTaskFrontmatter(content)
+    if (!fmParse.ok) {
+      const isDupReported = dupKeys.length > 0 && /duplicated mapping key/i.test(fmParse.error.message)
+      if (!isDupReported) {
+        errors.push(
+          `${dupTaskId || file}: frontmatter 非法 YAML（${file}:${fmParse.error.line}:${fmParse.error.column} ${fmParse.error.message}）——契约/验收/标量字段全链路不可读，plan 门禁拒绝放行；修复卡片 frontmatter（值含方括号/全角括号时加引号或改块式列表）`
+        )
+      }
+    }
+
     // 1. 必要字段检查
     const taskId = (fm.match(/^id:\s*(.+)/m)?.[1] || '').trim()
     const title = (fm.match(/^title:\s*(.+)/m)?.[1] || '').trim()
@@ -1374,12 +1389,11 @@ export function validatePlanFeasibility(changeDir, projectRoot = null) {
     //    不存在文件一律跳过，且至少读到一个源文件才比对（防全读不到 → 全标识符误报）。
     if (projectRoot && hasAcceptance && allowedPaths.length > 0) {
       let acceptanceText = ''
-      try {
-        const fmObj = jsYaml.load(fm) || {}
-        if (typeof fmObj.acceptance === 'string') acceptanceText = fmObj.acceptance
-        else if (Array.isArray(fmObj.acceptance)) acceptanceText = fmObj.acceptance.join('\n')
-      } catch {
-        // frontmatter 非法 YAML（feasibility 未对 fm 做 YAML 解析，可能字面合法但语义复杂）→ 跳过 best-effort
+      // 复用步骤 0b 的 fmParse（2026-09-20-taskcard-yaml-hardgate）：不再重复 jsYaml.load；
+      // 坏卡已被 0b 阻断，此处 ok=false 仅防御性跳过 best-effort（0 告警不误拦）
+      if (fmParse.ok && fmParse.fm) {
+        if (typeof fmParse.fm.acceptance === 'string') acceptanceText = fmParse.fm.acceptance
+        else if (Array.isArray(fmParse.fm.acceptance)) acceptanceText = fmParse.fm.acceptance.join('\n')
       }
       if (acceptanceText) {
         const IDENT_RE = /(?<![A-Za-z])[a-z]+(?:_[a-z]+)+|(?<![A-Za-z])[a-z]+(?:[A-Z][a-z]+)+/g

package/src/taskcard-frontmatter.js

@@ -0,0 +1,57 @@
+/**
+ * taskcard-frontmatter.js — task 卡 frontmatter 单一解析源（2026-09-20-taskcard-yaml-hardgate）
+ *
+ * 背景：坏 YAML 曾被三个消费点各自静默吞——plan-postcheck.js parseTaskContracts 的 catch 返回
+ * 空对象冒充「无契约字段」→ 契约门禁空真过门；verify-probes.js parseTaskAcceptance 的 catch
+ * 返回空数组 → 探针 7 假防御文案；且两侧 frontmatter 提取口径不一致（一侧 \r 容错一侧不容）。
+ * 本模块把「提取 + jsYaml 解析 + 错误定位（文件行:列）」收敛为一处，plan 与 verify 两侧共同消费。
+ *
+ * 防环铁律：本模块除 js-yaml 外零依赖（不 import 仓内任何模块）——plan-postcheck 与
+ * worktree-apply 存在既有依赖边（knowledge patterns），共享逻辑放新模块两侧 import。
+ */
+import jsYaml from 'js-yaml'
+
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/
+
+/**
+ * 提取 task 卡 frontmatter。界定口径与 verify-probes.js parseTaskAcceptance 原实现同款
+ * （首行 --- 起、闭合 --- 行止，\r\n 容错——Windows 编辑器文本模式写卡不炸提取）。
+ * @param {string} content task 卡全文
+ * @returns {{ has: boolean, yamlText: string|null, yamlStartLine: number }}
+ *   yamlStartLine = YAML 内容在文件中的起始行号（1 基）：首行是 ---，YAML 自第 2 行起，恒为 2
+ */
+export function splitFrontmatter(content) {
+  const m = String(content ?? '').match(FRONTMATTER_RE)
+  if (!m) return { has: false, yamlText: null, yamlStartLine: 2 }
+  return { has: true, yamlText: m[1], yamlStartLine: 2 }
+}
+
+/**
+ * 解析 task 卡 frontmatter（单一真相源）。
+ * @param {string} content task 卡全文
+ * @returns {{ ok: boolean, hasFrontmatter: boolean, fm: object|null,
+ *   error: { message: string, line: number, column: number }|null }}
+ *   - 无 frontmatter：{ ok: true, hasFrontmatter: false, fm: null, error: null }——不是错误，
+ *     「无 frontmatter」由各消费方按自身语义处理（plan-postcheck 结构检查另有拦截）
+ *   - jsYaml 抛错：{ ok: false, hasFrontmatter: true, fm: null, error: {...} }。
+ *     error.line = e.mark.line + yamlStartLine：js-yaml mark.line 是 YAML 文本内 0 基行号，
+ *     +2 后即文件 1 基行号（首行 ---，YAML 第 1 行 = 文件第 2 行）；mark 缺席回退 1。
+ *     error.column = e.mark.column + 1（0 基 → 1 基；mark 缺席回退 1）。
+ *     error.message 取异常首行（js-yaml 原始 message 含多行上下文，单行化便于门禁文案）。
+ *   - 合法：{ ok: true, hasFrontmatter: true, fm, error: null }（空文档回退 {}）
+ */
+export function parseTaskFrontmatter(content) {
+  const { has, yamlText, yamlStartLine } = splitFrontmatter(content)
+  if (!has) return { ok: true, hasFrontmatter: false, fm: null, error: null }
+  let fm
+  try {
+    fm = jsYaml.load(yamlText) || {}
+  } catch (e) {
+    const mark = e && e.mark
+    const line = mark && typeof mark.line === 'number' ? mark.line + yamlStartLine : 1
+    const column = mark && typeof mark.column === 'number' ? mark.column + 1 : 1
+    const message = String((e && e.message) || e).split('\n')[0]
+    return { ok: false, hasFrontmatter: true, fm: null, error: { message, line, column } }
+  }
+  return { ok: true, hasFrontmatter: true, fm, error: null }
+}

package/src/verify-postcheck.js

@@ -135,6 +135,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 更吵的决策依据——硬门误伤纯文档/跨平台路径会制造新噪音）。
@@ -226,6 +264,7 @@ export function runVerifyLintCheck({ cwd, specBase, timeoutMs } = {}) {
     outputTail,
     reason: finalReason,
     tally, // { failedRuns, totalRuns } | null——观察期失败率，升级硬门的决策依据
+    failureFiles: status === 'failed' ? extractLintFailureFiles(output) : [], // 归属鉴定输入（全文口径，outputTail 有截断盲区）
   }
 }
 
@@ -266,7 +305,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) {
@@ -1027,6 +1066,22 @@ export function classifyTestFailureArtifact(result) {
  *   - 其余（full / module 无块 / module git 不可用 hitCount=-1）→ 'full'
  * @returns {'skip'|'module-subset'|'module-zero-hit-skip'|'full'}
  */
+/**
+ * 纯超时失败判定（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, modulesPresent, hitCount }) {
   if (strategy === 'skip') return 'skip'
   if (strategy === 'module' && modulesPresent) {
@@ -2034,6 +2089,9 @@ function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [],
     // 每模块台账另见 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({