sillyspec 3.28.12 → 3.29.0

package/src/verify-postcheck.js

@@ -26,12 +26,22 @@ import { execSync, spawnSync } from 'child_process'
 import { createHash } from 'crypto'
 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 { verifyApiParity, _readWorktreeMeta } from './contract-matrix.js'
 import { reconcileCrossRepoDeclarations } from './cross-repo-reconcile.js'
 import { parseFileChangeListDetailed, pathMatches } from './change-list.js'
 import { filterDeliverableFiles, classifyToolScaffold } from './worktree-apply.js'
+// ceremony 双跑收口（2026-09-18-ceremony-risk-pricing task-04 / FR-03 / D-003）：引擎与账本均为
+// 纯/叶子依赖（ceremony-tier → change-risk-profile；friction-ledger → fs-atomic+quicklog），无环。
+import { resolveChangeRisk } from './change-risk-profile.js'
+import { loadBlastDeclarationsAllProjects } from './blast-surface.js'
+import { loadSpanRiskPatternsAllProjects } from './span-risk-surface.js'
+import { reconcileDualRun, computeCeremonyTier, CEREMONY_TIERS } from './ceremony-tier.js'
+import { mergeFrictionEntry } from './friction-ledger.js'
+import { discoverModuleIndex } from './decision-distill.js'
+import { writeAtomicSync } from './fs-atomic.js'
 // target_files 声明侧解析（Wave 1 已落地）：依赖链已核实无环——plan-postcheck 不反向依赖本模块，
 // 且本模块已经 worktree-apply.js:21 间接依赖 plan-postcheck，此处改直连不引入新环（task-04）
 import { parseTargetFiles, parseRepo } from './stages/plan-postcheck.js'
@@ -1120,8 +1130,22 @@ export function resolveVerifyChangedFiles(cwd, changeName, ctx = null, opts = {}
       // 不到 → 形态 A 并入失效 → ②类假红。_readWorktreeMeta 双候选（specBase 优先 +
       // cwd/.sillyspec 兜底，contract-matrix 既有样板）两形全覆盖。
       const found = changeName ? _readWorktreeMeta(opts.specBase || null, cwd, changeName) : null
-      if (found) {
-        const wtGitDir = found.gitDir
+      // native-worktree 收养态（ql-20260918-010，回放实验实证）：meta 缺席但 cwd 自身就是
+      // linked worktree（git-dir ≠ git-common-dir）——cwd 即工作区，未提交+已提交补齐两段
+      // 照走；否则模块命中面只剩未提交的 CLI 再生文件（回放：4 个 .claude/skills/*.md），
+      // 真实已提交改动全盲 → 0 命中 → integrationRan=not-ran 误触发 PASS 封顶（假 NOTES）。
+      let wtGitDir = found ? found.gitDir : null
+      let nativeWorktree = false
+      if (!wtGitDir) {
+        const gd = gitQuiet(cwd, ['rev-parse', '--git-dir'], { timeout: 15000 })
+        const gcd = gitQuiet(cwd, ['rev-parse', '--git-common-dir'], { timeout: 15000 })
+        const norm = (p) => String(p || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase()
+        if (gd && gcd && norm(gd) !== norm(gcd) && norm(gcd) !== '.git') {
+          wtGitDir = cwd
+          nativeWorktree = true
+        }
+      }
+      if (wtGitDir) {
         const wtStatus = gitQuiet(wtGitDir, ['status', '--porcelain', '--untracked-files=all'], { timeout: 30000, trim: false })
         // P1 修复（2026-09-07）：过滤器改 filterDeliverableFiles 口径（worktree-apply.js 同款）——
         // 此前 `.sillyspec/` 一刀切把 docs 交付物也滤掉，声明了模块文档的 task 在形态 A 下落②类假红
@@ -1135,17 +1159,25 @@ export function resolveVerifyChangedFiles(cwd, changeName, ctx = null, opts = {}
             !p.startsWith('.sillyspec/quicklog/'))
         // 已提交口径补齐（2026-09-10 用户反馈②「先提交则 diff 空」时序两难的 diff 半边）：
         // worktree 内已 commit 的改动对主仓 base..HEAD 与 status --porcelain 双双不可见——
-        // 用 merge-base(主仓 HEAD, worktree HEAD)（= worktree 创建锚点）到 worktree HEAD 的
-        // commit diff 补入，未提交 ∪ 已提交两形态全覆盖。wtGitDir===cwd（in-place 退化）时
-        // 已提交改动已在 mainFiles，跳过防双并。fail-open：git 失败退回 status-only 现状。
+        // diff 基线**优先 meta 锚点（baselineCommit＞actualBaseHash＞baseHash，resolveMainChangedFiles
+        // 同口径）**，三锚全缺才退 merge-base(wtHead, mainHead)。坑 fact-face-checkpoint-pollution
+        // （2026-09-19 five-cuts 实证：45 文件对账面虚增 23 条）：旧口径恒用 merge-base 且注释
+        // 假设其＝「worktree 创建锚点」——但 baseline checkpoint 提交（_createBaselineCheckpoint，
+        // worktree.js:816）落在 worktree 分支上、主仓 HEAD 不动，merge-base 指到 checkpoint 之前，
+        // checkpoint 卷入的并行会话文件整段进窗口。wtGitDir===cwd（in-place 退化）时已提交改动
+        // 已在 mainFiles，跳过防双并。fail-open：git 失败退回 status-only 现状。
         let committedFiles = []
         if (wtGitDir !== cwd) {
           try {
             const mainHead = gitQuiet(cwd, ['rev-parse', 'HEAD'], { timeout: 15000 })
             const wtHead = gitQuiet(wtGitDir, ['rev-parse', 'HEAD'], { timeout: 15000 })
-            const mb = (mainHead && wtHead)
-              ? gitQuiet(wtGitDir, ['merge-base', wtHead, mainHead], { timeout: 15000 })
+            const metaBase = found && found.meta
+              ? (found.meta.baselineCommit || found.meta.actualBaseHash || found.meta.baseHash || null)
               : null
+            const mb = metaBase
+              || ((mainHead && wtHead)
+                ? gitQuiet(wtGitDir, ['merge-base', wtHead, mainHead], { timeout: 15000 })
+                : null)
             if (mb) {
               const diffOut = gitQuiet(wtGitDir, ['diff', '--name-only', mb, wtHead], { timeout: 30000 })
               committedFiles = String(diffOut || '').split('\n')
@@ -1156,6 +1188,30 @@ export function resolveVerifyChangedFiles(cwd, changeName, ctx = null, opts = {}
                   !p.startsWith('.sillyspec/quicklog/'))
             }
           } catch { /* 已提交补齐失败退回 status-only（fail-open，不拖垮未提交并入） */ }
+        } else if (nativeWorktree) {
+          // native 态已提交补齐（ql-20260918-010 根因②）：主锚点必须取主仓检出（common dir）
+          // HEAD——原口径在 cwd 跑 rev-parse HEAD 取到 worktree 自身 HEAD，merge-base(wtHead,
+          // wtHead) 恒自身 → committed diff 恒空。common dir HEAD（主仓当前分支）与 worktree
+          // HEAD 的 merge-base = 分叉锚点，回放场景 = 收养基线。fail-open 同上。
+          try {
+            const gcd = gitQuiet(cwd, ['rev-parse', '--git-common-dir'], { timeout: 15000 })
+            const wtHead = gitQuiet(cwd, ['rev-parse', 'HEAD'], { timeout: 15000 })
+            const mainHead = gcd
+              ? gitQuiet(cwd, ['--git-dir=' + String(gcd).trim(), 'rev-parse', 'HEAD'], { timeout: 15000 })
+              : null
+            const mb = (mainHead && wtHead)
+              ? gitQuiet(cwd, ['merge-base', wtHead, String(mainHead).trim()], { timeout: 15000 })
+              : null
+            if (mb) {
+              const diffOut = gitQuiet(cwd, ['diff', '--name-only', String(mb).trim(), wtHead], { timeout: 30000 })
+              committedFiles = String(diffOut || '').split('\n')
+                .map(p => p.replace(/^"|"$/g, '').replace(/\\/g, '/').trim())
+                .filter(p => p && p !== '.sillyspec' &&
+                  !p.startsWith('.sillyspec/changes/') &&
+                  !p.startsWith('.sillyspec/.runtime/') &&
+                  !p.startsWith('.sillyspec/quicklog/'))
+            }
+          } catch { /* native 已提交补齐失败退回 status-only（fail-open） */ }
         }
         const merged = [...new Set([...(mainFiles || []), ...wtFiles, ...committedFiles])]
         if (wtFiles.length > 0 || committedFiles.length > 0) {
@@ -1166,7 +1222,27 @@ export function resolveVerifyChangedFiles(cwd, changeName, ctx = null, opts = {}
   }
 
   // 无 ctx / ctx 无跨仓 entry → 主仓 diff 即结果（零回归）
-  if (!ctx || typeof ctx.repos !== 'object' || ctx.repos === null) return mainFiles
+  // ql-20260918-012 主仓形态补源：apply 后 meta/diff 链在主仓可双双落空（变更已提交进 HEAD、
+  // meta 已被 execute 收尾清理）→ 文件集退化为 porcelain（被并行会话未提交文件污染，批2 verify
+  // 实证 5 个 .claude 假面+0 命中假 skip）。对齐 resolveReconcileActualFiles 的 B3 兜底：apply-pathspec
+  // 清单存在则并入（读取失败静默；该清单由 worktree apply 落盘，apply 后必在，是主仓形态最可靠的声明面）。
+  if (!ctx || typeof ctx.repos !== 'object' || ctx.repos === null) {
+    try {
+      const rtRoot = resolveRuntimeRoot({ runtimeRoot: opts.runtimeRoot, specDriftAnchor: opts.specDriftAnchor }, opts.specBase || join(cwd, '.sillyspec'))
+      const pathspecFile = join(rtRoot, `apply-pathspec-${changeName}.txt`)
+      if (existsSync(pathspecFile)) {
+        const declared = readFileSync(pathspecFile, 'utf8').split('\n').map(l => l.trim()).filter(Boolean)
+          .map(p => p.replace(/\\/g, '/'))
+          .filter(p => p && !p.startsWith('.sillyspec/changes/') && !p.startsWith('.sillyspec/.runtime/'))
+        if (declared.length > 0) {
+          // mainFiles 为 null（meta/diff 双落空、git 不可用）时声明面直接成为文件集——
+          // 否则 0 命中假 skip 复发（ql-20260918-012 直测实证）；为数组则并集
+          mainFiles = Array.isArray(mainFiles) ? [...new Set([...mainFiles, ...declared])] : declared
+        }
+      }
+    } catch { /* apply-pathspec 补源失败退回原集（fail-open） */ }
+    return mainFiles
+  }
   const crossEntries = []
   for (const entry of ctx.repos.values()) {
     if (entry && entry.isMain === false) crossEntries.push(entry)
@@ -1231,7 +1307,18 @@ function resolveMainChangedFiles(cwd, changeName, specBase = null) {
         // 不损原 worktree 结果。
         if (files !== null && gitDir !== cwd) {
           try {
-            const mainFiles = runGitDiffNameOnly(cwd, `${diffBase}..HEAD`)
+            // 主仓侧窗口锚 fork 点（merge-base(HEAD, diffBase)）——坑 fact-face-checkpoint-pollution
+            // （2026-09-19 five-cuts 实证：事实面 45 文件虚增 23 条）：旧口径 `${diffBase}..HEAD`
+            // 在「主仓 HEAD 未前移、checkpoint 落 worktree 分支」时是反向区间——checkpoint 卷入的
+            // 并行会话文件在主仓侧全显示为删除、--name-only 照样列名，overlay 整段泄漏进并集。
+            // 锚 fork 点后：主仓没动 → 窗口空（零泄漏）；wt-commit 流（提交落主仓 HEAD）→ fork..HEAD
+            // 恰捕获那些提交，语义不变。merge-base 不可得（对象缺失等极端）→ 退旧区间（不放大）。
+            let mainFiles = null
+            const fork = gitQuiet(cwd, ['merge-base', 'HEAD', String(diffBase)], { timeout: 15000 })
+            if (typeof fork === 'string' && fork.trim()) {
+              mainFiles = runGitDiffNameOnly(cwd, `${fork.trim()}..HEAD`)
+            }
+            if (mainFiles === null) mainFiles = runGitDiffNameOnly(cwd, `${diffBase}..HEAD`)
             if (Array.isArray(mainFiles)) {
               const merged = [...new Set([...files, ...mainFiles])]
               const { own, foreign } = splitOwnVsForeignDiffFiles(cwd, changeName, merged, { specBase: sb })
@@ -1399,17 +1486,28 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = nul
     ]
     console.warn(`⚠️ 模块 0 命中诊断（对照 path 前缀与 diff 布局是否一致，如 packages/<name> vs <name>/）：`)
     for (const l of diagLines) console.warn(`   ${l}`)
-    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,
-      resultPath: null,
-      mode: 'module-zero-hit',
-      fallbackReason: null,
+    // 变更测试兜底（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,
+        resultPath: null,
+        mode: 'module-zero-hit',
+        fallbackReason: null,
+      }
     }
   } else {
     // —— 全量路径（full / module 无块 / module git 不可用）——
@@ -2848,6 +2946,263 @@ export function reconcileTargetFiles({ cwd, specBase = null, changeName = null,
   return { status, matched, missing, undeclared, undeclaredScaffold: scaffoldTotal, skipReason: null, notes, form: actual.form, sources: actual.sources, crossRepo }
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// ceremony 双跑收口（2026-09-18-ceremony-risk-pricing task-04 / FR-03 / D-003、
+// 显式降档复核 D-004）：预价信声明、结算信事实——verify --done 与 archive confirm
+// 两出口用实际 diff 重跑 blast+span 得事实档，与 .runtime/ceremony-tier-<change>.json
+// 开跑声明档对账，懒 agent 的低报在收口被硬 flag + 记摩擦账 + 落事实面预价种子
+// （该会话下一 change 的开跑价强制并入事实面）。实际 diff 一律取 resolveReconcileActualFiles
+// 单点（上方 :2549——三源并集 / 并行会话剔除 / git 降级语义全复用，勿另造第二取数口径）。
+// 本函数是两出口的唯一实现宿主（gates.js verify 块的调用接线属 task-03 面；archive 出口
+// 接线在 run/complete-handlers.js handleArchiveConfirmStep）。
+// ─────────────────────────────────────────────────────────────────────────────
+
+// 2026-09-19-ceremony-pricing-five-cuts task-03：readCeremonyFactContent 与内容采集上限三常量
+// 整体删除——事实面零内容扫描（只吃文件名 × 声明面，D-008），常量随之失去消费者。
+
+/** 种子文件名的会话标识清洗（anon@host / agent 名等 → 文件名安全字符，截 80 字符） */
+function sanitizeCeremonySeedSession(session) {
+  return String(session).trim().replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 80) || 'session'
+}
+
+/** 会话标识解析（种子文件口径）：入参显式给足（archive 出口传 resolveSessionIdentity 结果）；
+ *  缺省动态 import progress.js 三级解析（flag > env > anon@host）——动态引是 gates 先例
+ *  （progress.js 闭包含 DB/registry，静态互引有环风险）；解析失败 → null（种子跳过，判定不受影响） */
+async function resolveCeremonyDualRunSession({ session, cwd }) {
+  if (typeof session === 'string' && session.trim()) return session.trim()
+  try {
+    const { resolveSessionIdentity } = await import('./progress.js')
+    return resolveSessionIdentity({ cwd, warn: false }).session
+  } catch { return null }
+}
+
+/**
+ * ceremony 双跑收口对账检查（verify --done / archive confirm 两出口共用；照 runVerifyTestCheck /
+ * reconcileTargetFiles 检查族先例：单结果对象 + 配套 print 导出）。
+ *
+ * 流程：声明档读 `.runtime/ceremony-tier-<change>.json`（task-03 开跑定价产物）的 tier →
+ * 实际 diff 取 resolveReconcileActualFiles 单点 → 事实面 resolveChangeRisk（文件名 × 项目
+ * 声明危险面，零内容扫描——D-008）+ _module-map 索引组装 reconcileDualRun 入参 → 引擎出
+ * 文件与对应内容）+ _module-map 索引组装 reconcileDualRun 入参 → 引擎出 {factTier, mismatch,
+ * severity}（声明档<事实档 → mismatch/error）。mismatch 时本函数亲自落两件收口产物（fail-soft，
+ * 异常降级留痕不阻断）：① 摩擦账 mergeFrictionEntry（counts 记 gate_rollback——现有三枚举中
+ * 唯一双语义契合项：verify 出口低报即 gate 回滚、且 gate_rollback 是 escalateByFriction 消费键
+ * 可供次单升档；扩展第四类型须动 friction-ledger/tally 枚举，不在本卡 allowed_paths）；② 事实面
+ * 预价种子 `.runtime/ceremony-fact-seed-<session>.json`（session 取 resolveSessionIdentity
+ * 同一口径，同 session 幂等覆盖不叠加；字段 declaredTier/factTier/mismatch + 事实面输入 factFiles
+ * 等供次单开跑价直用）。
+ *
+ * 跳过面（fail-soft 不误红，存量变更零回归）：quick 无 changeName / 档位文件缺失（task-03 未
+ * 落地前的在途变更）/ git 全不可用（actual 降级）。档位文件在场但 tier 非法 → 不跳过，按引擎
+ * reconcileDualRun 的 declaredTier 非法口径对账（fail-safe 宁严勿松，notes 留痕）。
+ *
+ * 显式降档复核（D-004）：档位文件 explicitDowngradeAccepted 标记（或 reasons 含该标记）的变更，
+ * 事实面支持（无 mismatch）→ 放行并在 warning 披露；不支持 → 按低报同款 mismatch。
+ *
+ * mismatch 的阻断语义由接线方兑现：verify 出口 errors 硬 flag（阻断回滚，strictViolation / ②类
+ * 先例）；archive 出口阻断级警告（只警告不回滚归档，D-006 archive=终态铁律）。violation 载荷
+ * （code/message 含命中明细）随结果透传，接线方零拼装。
+ *
+ * @param {object} opts
+ * @param {string} opts.cwd - 主仓根（git 调用根）
+ * @param {string|null} [opts.specBase] - .sillyspec 根（缺省 join(cwd,'.sillyspec')；平台模式传 specRoot）
+ * @param {string|null} [opts.changeName] - 变更名（quick 等无关联场景缺省 → skipped）
+ * @param {string|null} [opts.runtimeRoot] - 运行时根（缺省 join(specBase,'.runtime')）
+ * @param {string|null} [opts.session] - 会话标识（种子文件口径；缺省内部三级解析）
+ * @returns {Promise<{
+ *   status: 'ok'|'mismatch'|'skipped'|'degraded',
+ *   change: string|null, declaredTier: string|null, factTier: string|null,
+ *   mismatch: boolean, severity: 'error'|'none'|null,
+ *   explicitDowngradeAccepted: boolean, downgradeRecheckPassed: boolean|null,
+ *   skipReason: string|null, notes: string[], factReasons: string[], factFiles: string[],
+ *   form: 'worktree'|'post-apply'|null, sources: string[],
+ *   violation?: {code: string, message: string},
+ *   ledger?: {ok: boolean, skipped?: boolean}, seed?: {written: boolean, path?: string, reason?: string},
+ *   at: string,
+ * }>}
+ */
+export async function runCeremonyDualRunCheck({ cwd, specBase = null, changeName = null, runtimeRoot = null, session = null } = {}) {
+  const notes = []
+  const at = new Date().toISOString()
+  const skippedResult = (reason) => ({ status: 'skipped', change: changeName, declaredTier: null, factTier: null,
+    mismatch: false, severity: null, explicitDowngradeAccepted: false, downgradeRecheckPassed: null,
+    skipReason: reason, notes, factReasons: [], factFiles: [], form: null, sources: [], at })
+
+  if (!changeName) {
+    return skippedResult('无 changeName（quick 等无关联变更场景），ceremony 双跑对账跳过')
+  }
+  const sb = specBase || join(cwd, '.sillyspec')
+  const rt = runtimeRoot || join(sb, '.runtime')
+
+  // —— 声明侧：开跑定价落档（task-03 产物，tier/components/reasons/transitions）——
+  const tierPath = join(rt, `ceremony-tier-${changeName}.json`)
+  let tierFile = null
+  try { tierFile = JSON.parse(readFileSync(tierPath, 'utf8')) } catch { /* 缺失/坏 JSON → 下方跳过 */ }
+  if (tierFile == null || typeof tierFile !== 'object' || Array.isArray(tierFile)) {
+    // 存量零红门禁：档位文件缺失 = 变更先于定价系统起跑（task-03 未覆盖的在途面），跳过不误红。
+    // 与「文件在场但 tier 非法」不同处置：后者走引擎 fail-safe 对账（无法证明声明到位 → 视为低报）。
+    return skippedResult(`档位文件缺失或不可解析（${tierPath}——开跑定价产物，task-03 阶段门落盘），ceremony 双跑跳过（存量变更零红门禁）`)
+  }
+  const declaredTier = typeof tierFile.tier === 'string' ? tierFile.tier : null
+  if (!CEREMONY_TIERS.includes(declaredTier)) {
+    notes.push(`声明档 tier 非法（${JSON.stringify(tierFile.tier)}）——按引擎 fail-safe 口径以最低档对账（宁严勿松）`)
+  }
+
+  // —— 事实侧：实际 diff 单点取数（三源并集 / 并行会话剔除 / git 降级语义全复用）——
+  const actual = resolveReconcileActualFiles({ cwd, specBase: sb, runtimeRoot: rt, changeName })
+  if (actual.foreignExcluded > 0) {
+    notes.push(`主仓 status 捕入的 ${actual.foreignExcluded} 个并行会话声明文件已剔除（不参与事实面计价）`)
+  }
+  if (!actual.ok) {
+    return { status: 'degraded', change: changeName, declaredTier, factTier: null,
+      mismatch: false, severity: null, explicitDowngradeAccepted: false, downgradeRecheckPassed: null,
+      skipReason: `git 全部不可用，actual 不可得，双跑对账降级跳过——${actual.degradedReason}`,
+      notes, factReasons: [], factFiles: [], form: actual.form, sources: actual.sources, at }
+  }
+
+  // —— 事实面重跑（2026-09-19-ceremony-pricing-five-cuts task-03：零内容扫描）——
+  // blast ＝ actual.files × 项目声明危险面（loadBlastDeclarationsAllProjects——runCeremonyDualRunCheck
+  // 无 project 语境，扫 specBase/docs/*/modules/_module-map.yaml 取并集，多项目仓保守正确）；
+  // 旧口径（读实际 diff 文件全文喂 detectChangeRisk 词表）整类删除——事实面只吃文件名 × 声明面
+  // （自指陷阱消失：门禁引擎源码里的关键词不再是判级输入，D-008）。
+  const blastDeclarations = loadBlastDeclarationsAllProjects(sb)
+  // span 轴同款声明面（2026-09-19-span-risk-pattern-migration task-03）：map 顶层 span_risk 段
+  // AllProjects 并集，一次装载双点共用（reconcileDualRun factSpanRiskPatterns + factDetail 披露）；
+  // 无声明项目 → 空表（span 模式维关闭，禁回退内置表，D-003）
+  const factSpanRiskPatterns = loadSpanRiskPatternsAllProjects(sb)
+  const factRisk = resolveChangeRisk({ files: actual.files, blastDeclarations })
+  let factModuleIndex = null
+  try { factModuleIndex = discoverModuleIndex(join(sb, 'knowledge')) } catch { /* 缺 map → span 跨模块维跳过 */ }
+
+  // —— 引擎对账（mismatch 判定单点）+ 命中明细（同入参跑 computeCeremonyTier 取 reasons，供披露）——
+  const verdict = reconcileDualRun({ declaredTier, factBlastTier: factRisk.tier, factFiles: actual.files, factModuleIndex, factSpanRiskPatterns })
+  const factDetail = computeCeremonyTier({
+    blastTier: factRisk.tier, declaredFiles: actual.files, moduleIndex: factModuleIndex, spanRiskPatterns: factSpanRiskPatterns, frictionCounts: {},
+  })
+  if (verdict.severity === 'warn') {
+    notes.push(`[advisory] 高报记账（D-005）：声明档 ${String(declaredTier)} > 事实档 ${verdict.factTier}——只记账不阻断不记摩擦（高报代价是更重仪式，自罚机制在场）`)
+  }
+
+  // —— 显式降档复核（D-004）：档位文件标记（字段或 reasons 痕迹双口径容错——computeCeremonyTier
+  //    的 reasons 含 explicitDowngradeAccepted=true 字样，task-03 落盘形态两者至少其一在场）——
+  const explicitDowngradeAccepted = tierFile.explicitDowngradeAccepted === true
+    || (Array.isArray(tierFile.reasons) && tierFile.reasons.some((r) => /explicitDowngradeAccepted/.test(String(r))))
+  let downgradeRecheckPassed = null
+  if (explicitDowngradeAccepted) {
+    if (verdict.mismatch) {
+      notes.push('显式降级未获事实面支持（design risk_level 降级声明与实际改动矛盾，D-004）——按低报处理')
+    } else {
+      downgradeRecheckPassed = true
+      notes.push(`显式降级经事实面复核通过（声明档 ${declaredTier} ≥ 事实档 ${verdict.factTier}，D-004 放行留痕）`)
+    }
+  }
+
+  const result = {
+    status: verdict.mismatch ? 'mismatch' : 'ok',
+    change: changeName, declaredTier, factTier: verdict.factTier,
+    mismatch: verdict.mismatch, severity: verdict.severity,
+    explicitDowngradeAccepted, downgradeRecheckPassed,
+    skipReason: null, notes, factReasons: factDetail.reasons, factFiles: actual.files,
+    form: actual.form, sources: actual.sources, at,
+  }
+  if (!verdict.mismatch) return result
+
+  // —— mismatch 收口产物（fail-soft：账本 API 自身不抛；种子落盘异常降级留痕，均不阻断判定）——
+  result.violation = {
+    code: 'ceremony_dual_run_mismatch',
+    message: `ceremony 双跑对账：声明档 ${String(declaredTier)} < 事实档 ${verdict.factTier}（低报）——${factDetail.reasons.join('；')}`,
+  }
+  // ── 双跑低报自动追赶重定价（坑 ceremony-cascade-deadlock，ql-013 postmortem）────
+  // 声明追赶检查点（escalateCeremonyTierAtGate）位于完成级联末位，双跑 error 在 verify
+  // postcheck 更早拦住 --done——级联走不到末位，追赶永不执行，形成「提示由阶段门重定价
+  // 但阶段门时序不可达」的死锁（five-cuts 实证：3 轮 --done 卡死只能手动改档位文件）。
+  // 修法：mismatch 分支内先按事实面执行一次追赶（applyDeclarationCatchUp 同款语义：
+  // transitions 空→整档换 factTier；非空→max(factTier, 地板)），写回档位文件——本次仍
+  // error（低报惩罚保留：friction 已 +1），但重跑 --done 即对账通过，不需手动改档。
+  // fail-soft：重定价任何异常降级留痕不阻断 error 本身。
+  try {
+    const { applyDeclarationCatchUp } = await import('./ceremony-tier.js')
+    const caught = applyDeclarationCatchUp({
+      currentDoc: tierFile,
+      recomputedTier: verdict.factTier,
+      recomputedComponents: { blast: factRisk.tier, span: (factDetail.components && factDetail.components.span) || 'S0', friction: 'S0' },
+      recomputedReasons: [`双跑低报自动追赶（事实面 tier=${verdict.factTier}，证据面 seed ${actual.files.length} 文件）`],
+      frictionCounts: {},
+    })
+    const tierPathForReprice = join(rt, `ceremony-tier-${changeName}.json`)
+    const { writeAtomicSync } = await import('./fs-atomic.js')
+    writeAtomicSync(tierPathForReprice, JSON.stringify(caught, null, 2) + '\n')
+    result.violation.message += `；档位文件已自动按事实面追赶重定价（${String(declaredTier)} → ${caught.tier}）——修复低报根因后重跑 --done 即对账通过，勿手动改档（ql-013 死锁修复）`
+    notes.push(`低报自动追赶重定价：${String(declaredTier)} → ${caught.tier}（级联死锁修复，applyDeclarationCatchUp 事实面语义）`)
+  } catch (e) {
+    notes.push(`低报自动追赶重定价失败（fail-soft 不阻断 error 本身）：${e && e.message ? e.message : e}`)
+  }
+  result.ledger = await mergeFrictionEntry(rt, { change: changeName, counts: { gate_rollback: 1 } })
+  const sid = await resolveCeremonyDualRunSession({ session, cwd })
+  if (sid) {
+    try {
+      mkdirSync(rt, { recursive: true })
+      const seedPath = join(rt, `ceremony-fact-seed-${sanitizeCeremonySeedSession(sid)}.json`)
+      writeAtomicSync(seedPath, JSON.stringify({
+        change: changeName,
+        declaredTier,
+        factTier: verdict.factTier,
+        mismatch: true,
+        factBlastTier: factRisk.tier,
+        factHitPrefixes: factRisk.hitPrefixes,
+        factFiles: actual.files,
+        at,
+      }, null, 2) + '\n')
+      result.seed = { written: true, path: seedPath, session: sid }
+    } catch (e) {
+      result.seed = { written: false, reason: `种子落盘失败（fail-soft 不阻断）：${e && e.message ? e.message : e}` }
+    }
+  } else {
+    result.seed = { written: false, reason: '会话标识不可得（resolveSessionIdentity 解析失败）——种子跳过，判定不受影响' }
+  }
+  return result
+}
+
+/**
+ * 打印 ceremony 双跑对账结果（两出口共用渲染）。skipped 静默（存量无档位文件是过渡期常态，
+ * printVerifyParityCheck skipped 先例——零噪音）；ok 单行放行（审计可见性：声明面与事实面
+ * 一致）；显式降档复核通过 → warning 披露（D-004 留痕）；mismatch → ⛔ console.error 列声明档/
+ * 事实档/命中明细 + 修复指引 + 记账/种子落点——出口语义差异（verify=errors 硬 flag 阻断回滚 /
+ * archive=阻断级警告不回滚终态，D-006）在文案末行双披露，阻断侧由各出口接线方兑现。
+ */
+export function printCeremonyDualRunCheck(result) {
+  if (!result || typeof result !== 'object') return
+  if (result.status === 'skipped') return
+  if (result.status === 'degraded') {
+    console.warn(`\n⚠️  Ceremony 双跑对账降级跳过：${result.skipReason}`)
+    return
+  }
+  if (result.status === 'ok') {
+    if (result.downgradeRecheckPassed) {
+      console.warn(`\n⚠️  Ceremony 双跑对账：显式降级经事实面复核通过（声明档 ${result.declaredTier} ≥ 事实档 ${result.factTier}，D-004 放行留痕）`)
+      return
+    }
+    console.log(`\n✅ Ceremony 双跑对账通过：声明档 ${result.declaredTier} ≥ 事实档 ${result.factTier}（实际 diff ${result.factFiles.length} 文件重跑 blast+span）`)
+    return
+  }
+  // mismatch（severity=error）
+  console.error(`\n⛔ Ceremony 双跑对账不通过（低报，severity=error）：声明档 ${String(result.declaredTier)} < 事实档 ${result.factTier}`)
+  console.error(`   声明档：${String(result.declaredTier)}（.runtime/ceremony-tier-${result.change}.json 开跑定价）`)
+  console.error(`   事实档：${result.factTier}（实际 diff ${result.factFiles.length} 文件重跑 blast+span，源：${(result.sources || []).join('、') || '-'}）`)
+  const reasons = result.factReasons || []
+  for (const r of reasons.slice(0, 10)) console.error(`   · ${r}`)
+  if (reasons.length > 10) console.error(`   · …还有 ${reasons.length - 10} 条命中明细`)
+  if (result.explicitDowngradeAccepted) console.error('   显式降级未获事实面支持（design risk_level 降级声明与实际改动矛盾，D-004）——按低报处理')
+  if (result.ledger && result.ledger.ok && !result.ledger.skipped) {
+    console.error(`   已记摩擦账：friction-ledger.json（change=${result.change}，gate_rollback +1）`)
+  }
+  if (result.seed && result.seed.written) {
+    console.error(`   已落事实面预价种子：${result.seed.path}（本会话下一 change 的开跑价强制并入事实面）`)
+  }
+  console.error('   修复：按事实档补做对应档位仪式，或修正降级理由后由阶段门重定价，再重跑收口对账。')
+  console.error('   出口语义：verify --done 出口为 errors 硬 flag（阻断回滚，修复后重跑 --done 进度不丢）；archive confirm 出口为阻断级警告（归档继续，D-006 不回滚终态、不 reopen）。')
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // P3b task-02：verify-result.md 探针预填段一致性抽查（D-002@v1 方案A 正文基准 + D-003@v1
 // G2/G8 锚点规格与判别子；接线 gates.js verify 块是 task-03 的 scope）