sillyspec 3.28.8 → 3.28.10

package/src/scope-audit.js

@@ -15,15 +15,25 @@
  * 行数三档（D-002）：tracked → numstat；untracked 新文件 → wc-l 记全 + 行；binary（numstat
  * 两列 '-'）→ additions/deletions=null。三态（full-flow）：planned / unplanned / untouched。
  *
+ * quick 画像出口（2026-09-14-quick-exit-tiered-gates task-03，FR-04 / D-008）：quick 模式结果
+ * 增量携带 gateProfile（实时态透传 auditQuickCompletion 挂的 review.gateProfile，不重复计算；
+ * 冻结重放态透传 quicklog/patches 记录冻结值，旧记录按 rows 清单重算），表格出口按存在性
+ * 追加 [gate] 画像段、--json 出口随结果对象序列化——画像的独立可重放出口与阈值校准数据源。
+ * 既有三态对账表/归属表/--file 出口与返回字段语义零变化（gateProfile 为增量字段）。
+ *
  * 全 advisory（D-006）：不抛错阻断、不写门禁状态；任何异常 catch 后并入 degradedReason。
  * 纯读：不落盘、不改 guard/进度库。Windows 路径 \\→/ 归一，ESM-only，零新依赖。
  */
 import { existsSync, readFileSync, readdirSync } from 'node:fs'
 import { createHash } from 'node:crypto'
 import { join, dirname } from 'node:path'
-import { locateQuickSessionGuard, auditQuickCompletion, resolveRuntimeRoot, collectOtherQuickSessionDeclarations, ancestorSpecDirs } from './run/shared.js'
+import { locateQuickSessionGuard, auditQuickCompletion, resolveRuntimeRoot, collectOtherQuickSessionDeclarations, ancestorSpecDirs, isQuickMetadata } from './run/shared.js'
+import { computeGateProfile, resolveGateThresholds } from './quick-gate-profile.js'
 import { safeGit } from './git-helper.js'
 import { parseFileChangeListDetailed, pathMatches } from './change-list.js'
+import { classifyToolScaffold } from './worktree-apply.js'
+import { parseRepoRegistry } from './stages/plan-postcheck.js'
+import { _readWorktreeMeta } from './contract-matrix.js'
 
 /** quick 会话 id 形态（与 run/command.js :652 QUICK_SID_RE 同款——crypto.randomUUID 前 8 hex） */
 const QUICK_SID_RE = /^quick-[0-9a-f]{8}$/
@@ -204,10 +214,11 @@ function resolveChangeDir(sb, changeName) {
 function resolveDiffRoot(sb, changeName, form, cwd) {
   if (form === 'worktree') {
     try {
-      const meta = JSON.parse(readFileSync(join(sb, '.runtime', 'worktrees', changeName, 'meta.json'), 'utf8'))
-      if (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) {
-        return meta.worktreePath
-      }
+      // 双根读取（坑 platform-dual-root-form-misjudge）：平台模式 sb=specRoot 时项目侧
+      // .sillyspec 的 meta 读不到 → worktree 根错落 cwd。_readWorktreeMeta 双候选（contract-matrix
+      // 既有样板，gitDir 已含 worktreePath/mode 判定）。
+      const found = _readWorktreeMeta(sb || null, cwd, changeName)
+      if (found) return found.gitDir
     } catch { /* 读失败 → cwd 兜底（advisory） */ }
   }
   return cwd
@@ -266,18 +277,20 @@ function filterPatchForFiles(patchText, filesSet) {
 }
 
 /**
-/** patch 内容 sha256（A-F01 防篡改锚——写入方存 json.patchSha256，读取方校验） */
-function sha256Text(text) {
-  return createHash('sha256').update(text, 'utf8').digest('hex')
+ * patch sha256——换行归一化口径（quick-ec5fc714）：git autocrlf 会在提交/检出时把 patch
+ * 转 CRLF（平台仓实测 mtime 晚落盘一天的假篡改告警）——双侧统一 LF 归一后取 hash。
+ */
+function sha256PatchNormalized(text) {
+  return createHash('sha256').update(String(text).replace(/\r\n/g, '\n'), 'utf8').digest('hex')
 }
 
 /**
- * 冻结 patch 完整性校验（A-F01）：json 记录的 patchSha256 与 patch 实文比对。
+ * 冻结 patch 完整性校验（A-F01）：json 记录的 patchSha256 与 patch 实文比对（LF 归一口径）。
  * @returns {boolean|null} true=一致；false=不匹配（可能被篡改）；null=未记录 hash（旧记录）
  */
 function verifyPatchIntegrity(recordedSha, patchText) {
   if (!recordedSha || typeof recordedSha !== 'string') return null
-  return sha256Text(patchText) === recordedSha
+  return sha256PatchNormalized(patchText) === recordedSha
 }
 
 /**
@@ -344,7 +357,8 @@ function slicePatchForFile(patchText, filePath) {
 
 /**
  * quick 记录态反查（guard 清理后）：扫祖先链各 specBase 的 quicklog/patches/*.json，
- * 按 json 内冗余的 sessionId 匹配。返回记录 + patch 路径（--file 切片源）。
+ * 按 json 内冗余的 sessionId 匹配。返回记录 + patch 路径（--file 切片源）+ specBase
+ * （命中目录——画像重放的 module-map/local.yaml 加载锚，task-03）。
  */
 function findQuickPatchRecord(cwd, sessionId) {
   for (const sb of ancestorSpecDirs(cwd)) {
@@ -355,7 +369,7 @@ function findQuickPatchRecord(cwd, sessionId) {
       try {
         const j = JSON.parse(readFileSync(join(dir, f), 'utf8'))
         if (j && j.sessionId === sessionId && Array.isArray(j.rows)) {
-          return { record: j, patchPath: join(dir, f.replace(/\.json$/, '.patch')), qlId: j.qlId || f.replace(/\.json$/, '') }
+          return { record: j, patchPath: join(dir, f.replace(/\.json$/, '.patch')), qlId: j.qlId || f.replace(/\.json$/, ''), specBase: sb }
         }
       } catch { /* 单文件损坏跳过 */ }
     }
@@ -363,6 +377,183 @@ function findQuickPatchRecord(cwd, sessionId) {
   return null
 }
 
+/** QUICKLOG 条目号形态（ql-20260914-001-abcd：日期-序号-短 hash，短 hash 4 hex） */
+const QL_ID_RE = /^ql-\d{8}-\d{3}-[0-9a-f]{4}$/
+
+/**
+ * 注册仓 key 清单（scope-audit-cross-repo-blindness 改进点 2）：读 <specBase>/local.yaml 的
+ * repos 段（parseRepoRegistry 同源，D-003 不另造解析）——design 清单跨仓子段 / `cross-repo:`
+ * 前缀只认注册 key（fail-closed，防普通路径误判）。local.yaml 缺失/坏 → 空清单（全部按主仓
+ * 解析，行为同改进前）。
+ * @param {string} specBase .sillyspec 根
+ * @returns {string[]} repoKey 清单
+ */
+function loadRegisteredRepoKeys(specBase) {
+  try {
+    const p = join(specBase || '', 'local.yaml')
+    if (!specBase || !existsSync(p)) return []
+    return [...parseRepoRegistry(readFileSync(p, 'utf8')).keys()]
+  } catch { /* 读取/解析失败 → 空清单（主仓口径兜底） */ return [] }
+}
+
+/**
+ * ql-xxx → quick-xxx 反查（用户「为什么不直接用 ql-xxx 查」根治，ql-20260910-014 设计：
+ * 映射只在本机 guard，会话结束即清；patches 记录按 qlId 命名且 json 冗余 sessionId——
+ * 平台可抓的持久映射）。按文件名前缀匹配（qlId=文件名），避免逐文件解析全目录。
+ */
+function findQuickSessionByQlId(cwd, qlId) {
+  const norm = String(qlId || '').trim()
+  if (!QL_ID_RE.test(norm)) return null
+  for (const sb of ancestorSpecDirs(cwd)) {
+    try {
+      const jsonPath = join(sb, 'quicklog', 'patches', `${norm}.json`)
+      if (!existsSync(jsonPath)) continue
+      const j = JSON.parse(readFileSync(jsonPath, 'utf8'))
+      if (j && typeof j.sessionId === 'string' && QUICK_SID_RE.test(j.sessionId)) {
+        return { sessionId: j.sessionId, record: j, patchPath: join(sb, 'quicklog', 'patches', `${norm}.patch`), qlId: norm, specBase: sb }
+      }
+    } catch { /* 单文件损坏跳过 */ }
+  }
+  return null
+}
+
+/**
+ * quick 记录态回放结果构建（共用：guard 清理后 sessionId 反查 + ql-xxx 反查两入口）。
+ * 画像重放（FR-04 / D-008 / task-03）+ 「声明即归属」过滤（quick-ec5fc714）。
+ */
+async function buildQuickRecordResult(rec, requestedName) {
+  let gateProfile = null
+  try {
+    if (rec.record.gateProfile && typeof rec.record.gateProfile === 'object') {
+      gateProfile = rec.record.gateProfile
+    } else {
+      const rowsPaths = rec.record.rows
+        .map(r => (r && typeof r.path === 'string' ? r.path : ''))
+        .filter(Boolean)
+      if (rowsPaths.length > 0) {
+        const thresholds = await resolveReplayGateThresholds(rec.specBase)
+        gateProfile = computeGateProfile(
+          rowsPaths,
+          await loadGateModuleIndex(rec.specBase, rowsPaths),
+          thresholds ? { thresholds } : {},
+        )
+      }
+    }
+  } catch { gateProfile = null }
+  const filteredRows = rec.record.rows.filter(r => r && !isQuickMetadata(r.path || '', []))
+  const filterDropped = rec.record.rows.length - filteredRows.length
+  const viaQl = requestedName !== rec.record.sessionId && QL_ID_RE.test(requestedName)
+  return {
+    mode: 'quick', ok: true, degradedReason: null,
+    baseAnchor: rec.record.baseAnchor || `quick-window:${rec.record.sessionId || requestedName}`,
+    totals: rec.record.totals && typeof rec.record.totals === 'object' && filterDropped === 0
+      ? rec.record.totals
+      : { files: filteredRows.length, ...sumTotals(filteredRows) },
+    rows: filteredRows,
+    excluded: rec.record.excluded && Array.isArray(rec.record.excluded.foreignDeclared)
+      ? rec.record.excluded
+      : { foreignDeclared: [] },
+    frozenPatchPath: rec.patchPath,
+    patchSha256: rec.record.patchSha256 || null,
+    patchStatus: rec.record.patchStatus || null,
+    gateProfile,
+    note: `quick 会话已收尾——记录态（quicklog/patches/${rec.qlId}，${rec.record.savedAt ? String(rec.record.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘' : '--done 时点冻结'}）${viaQl ? `；经 ql-Id 反查（会话 ${rec.record.sessionId}）` : ''}${filterDropped > 0 ? `；回放已剔除 ${filterDropped} 个 quick 元数据/并行变更目录文件（范围视图收紧）` : ''}`,
+  }
+}
+
+/**
+ * quick 审计链 module-map 的项目推导（2026-09-14-quick-exit-tiered-gates task-03）：
+ * loadQuickModuleIndex（run/shared.js，未 export）的加载路径是
+ * <specBase>/docs/<projectName>/modules/_module-map.yaml——scope-audit 侧无 progress 上下文
+ * 拿 projectName，按候选 map 推导：
+ *   - 单候选 → 直取（绝大多数仓单项目）；
+ *   - 多候选 + 样本文件（实时态=guard.allowedFiles 声明面 / 重放态=记录 rows 冻结集）→ 按
+ *     「样本归属得分唯一最高」消歧（computeGateProfile.unmappedFiles 同款归属口径，纯函数
+ *     零 IO 重用——本仓 dashboard+sillyspec 双 map 实证需要）；
+ *   - 零候选 / 无样本 / 得分平分 → null（画像走 degraded 档，fail-open 不猜，兼容策略第 1 条）。
+ * @param {string} specBase
+ * @returns {string[]} 带 _module-map.yaml 的项目名清单
+ */
+function listModuleMapProjects(specBase) {
+  if (!specBase) return []
+  try {
+    const docsDir = join(specBase, 'docs')
+    return readdirSync(docsDir).filter(n => existsSync(join(docsDir, n, 'modules', '_module-map.yaml')))
+  } catch {
+    return []
+  }
+}
+
+/** 单项目 _module-map.yaml 读取（parseModuleMapSimple canonical 解析，与 loadQuickModuleIndex 同款）；不可得/解析空 → null。 */
+async function readModuleMap(specBase, project) {
+  try {
+    const { parseModuleMapSimple } = await import('./modules.js')
+    const idx = parseModuleMapSimple(readFileSync(join(specBase, 'docs', project, 'modules', '_module-map.yaml'), 'utf8'))
+    return idx && Object.keys(idx).length > 0 ? idx : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 项目名推导（口径见 listModuleMapProjects 头注释）：唯一得分（样本非文档文件中归属最少
+ * unmapped 的 map）才采信，平分/无样本/多候选全失败 → null。
+ * @param {string} specBase
+ * @param {string[]} [sampleFiles] 归属得分样本（声明面 / 记录 rows）
+ * @returns {Promise<string|null>}
+ */
+async function pickModuleMapProject(specBase, sampleFiles = []) {
+  const names = listModuleMapProjects(specBase)
+  if (names.length === 1) return names[0]
+  if (names.length === 0 || !Array.isArray(sampleFiles)) return null
+  const files = sampleFiles.map(f => String(f || '')).filter(Boolean)
+  if (files.length === 0) return null
+  let best = null
+  let bestUnmapped = Infinity
+  let tie = false
+  for (const n of names) {
+    const idx = await readModuleMap(specBase, n)
+    if (!idx) continue
+    const unmapped = computeGateProfile(files, idx).unmappedFiles.length
+    if (unmapped < bestUnmapped) { best = n; bestUnmapped = unmapped; tie = false }
+    else if (unmapped === bestUnmapped) tie = true
+  }
+  return tie ? null : best
+}
+
+/**
+ * 画像重放的 moduleIndex 加载（task-03，FR-04）：与 run/shared.js loadQuickModuleIndex 同链路
+ * ——同路径 + parseModuleMapSimple（canonical）解析，项目按记录 rows 样本消歧；不可得 → null
+ * （computeGateProfile 走 degraded 档）。动态 import modules.js 隔离依赖（shared.js 同款）。
+ * @param {string} specBase quicklog/patches 记录命中的 spec 根
+ * @param {string[]} [sampleFiles] 项目消歧样本（记录 rows）
+ * @returns {Promise<object|null>}
+ */
+async function loadGateModuleIndex(specBase, sampleFiles = []) {
+  const project = await pickModuleMapProject(specBase, sampleFiles)
+  return project ? readModuleMap(specBase, project) : null
+}
+
+/**
+ * 画像重放的阈值合并（task-03，D-009）：与 auditQuickCompletion 画像挂载段同链路——
+ * <specBase>/local.yaml（= 实时态 readLocalYamlRaw(sessionRoot) 读的同一文件）+ js-yaml +
+ * resolveGateThresholds；缺失/坏 YAML → null（computeGateProfile 内回 THRESHOLDS 默认）。
+ * @param {string} specBase
+ * @returns {Promise<object|null>}
+ */
+async function resolveReplayGateThresholds(specBase) {
+  try {
+    const p = join(specBase, 'local.yaml')
+    if (!existsSync(p)) return null
+    const mod = await import('js-yaml')
+    const yamlLoad = mod.load || mod.default?.load
+    const cfg = yamlLoad(readFileSync(p, 'utf8'))
+    return cfg && typeof cfg === 'object' ? resolveGateThresholds(cfg) : null
+  } catch {
+    return null
+  }
+}
+
 /** 汇总非 null 行数（binary 与降级 null 不计入，不出伪数据） */
 function sumTotals(rows) {
   let additions = 0
@@ -391,6 +582,16 @@ async function computeQuickAudit({ cwd, platformOpts, sessionId, located, collec
   try {
     const mergedGuard = {
       ...guard,
+      // 画像输入对齐（2026-09-14-quick-exit-tiered-gates task-03，FR-04）：specBase/projectName
+      // 透传——complete-handlers :1050 同款 merge（「--done 收尾同源实时采集」的既有约定）补齐。
+      // guard.json 落盘不含这两键，缺省会让 auditQuickCompletion 挂的 review.gateProfile 恒走
+      // degraded 档（moduleSpan=null），与 --done 时点 review.gateProfile 字段不一致。projectName
+      // 无 progress 上下文，按 module-map 候选推导（声明会话以 allowedFiles 为归属得分样本；
+      // 零候选/无样本/平分 → null → degraded，fail-open）。specBase/projectName 在 audit 内只喂
+      // quicklog 目录解析（与 cwd 推导同一路径）、docSyncHint 模块归属与 gate 画像（computeQuickAudit
+      // 不消费 docSyncHint），不触 status/reasons/归属切分语义。
+      specBase: guardSpecBase,
+      projectName: await pickModuleMapProject(guardSpecBase, guard.allowedFiles),
       otherSessionsDeclared: collectOtherQuickSessionDeclarations(platformOpts, guardSpecBase, sessionId),
     }
     audit = await auditQuickCompletion(sessionRoot, mergedGuard, {})
@@ -419,14 +620,39 @@ async function computeQuickAudit({ cwd, platformOpts, sessionId, located, collec
     return { ...base, ok: false, degradedReason: `quick 窗口审计失败: ${hardFailure}` }
   }
 
-  // 归属切分（消费 auditQuickCompletion 产物，不重算）：attributedFiles（含 sameFileHits）→
-  // declared；undeclaredFiles − softTestFiles → undeclared；softTestFiles → soft。
+  // 归属切分（quick-ec5fc714 平台实测修正）：scope-audit 是**范围视图**不是门禁——按
+  // 「声明即归属」硬切：declared=声明∩窗口；soft=软归属；其余（含 quick 元数据/其他变更
+  // 目录/linkedChanges 文件——audit 侧刻意保留它们供审计行落盘不静默挤走，范围视图则不该
+  // 把别人的活算进来）归为 undeclared 仅 note 交代。窗口文件全在 undeclared（如声明文件
+  // 已提交无 diff）时，undeclared 升格进 rows（范围视图只展示改了的东西）——本 quick
+  // 实测：声明两 pi-rpc 文件已提交 + 他者变更目录 19 文件未声明，行数贡献恰来自后者。
   const attributed = Array.isArray(audit.attributedFiles) ? audit.attributedFiles.map(toPosix) : []
   const undeclared = Array.isArray(audit.undeclaredFiles) ? audit.undeclaredFiles.map(toPosix) : []
   const softSet = new Set((Array.isArray(audit.softTestFiles) ? audit.softTestFiles : []).map(toPosix))
   const attrSet = new Set(attributed)
-
-  const rowFiles = [...new Set([...attributed, ...undeclared])]
+  const linkedChangesArr = Array.isArray(guard.linkedChanges) ? guard.linkedChanges.map(c => String(c).replace(/\\/g, '/')) : []
+  const isLinkedLeftover = (f) => linkedChangesArr.some(lc => f.startsWith(`.sillyspec/changes/${lc}/`) || f.startsWith(`.sillyspec/changes/archive/${lc}/`))
+
+  let rowFiles
+  let dropNote = null
+  if (attributed.length > 0 || softSet.size > 0) {
+    // 有归属文件时：undeclared 全部剔出范围视图——undeclared 即「不属于本 quick」的文件
+    // （他者变更目录/quicklog 产物/无关未提交），audit 侧留它们供审计行追溯，范围视图不该
+    // 展示（平台仓实测：窗口 13 个文件里 11 个是他者变更目录，唯二归属文件已提交）。
+    rowFiles = [...new Set([...attributed, ...softSet])]
+    if (undeclared.length > 0) {
+      dropNote = `${undeclared.length} 个未声明文件不计入范围视图（他者变更目录/quicklog 产物/漏声明——audit 行有追溯）`
+    }
+  } else {
+    // 窗口全 undeclared（如声明文件已提交无 diff）：范围视图仍剔 quick 元数据/变更目录
+    // ——audit 侧留它们供审计行追溯，范围视图不展示他者活（platform quick-ffb92f60 实测：
+    // 19 个 undeclared 中 17 个是他者变更目录/quicklog 产物，唯二声明文件已提交）。真未知的
+    // 源码/业务文件保留进 rows（他者窗口改动或漏声明，note 交代）。
+    rowFiles = [...new Set(undeclared.filter(f => !isQuickMetadata(f, linkedChangesArr) && !isLinkedLeftover(f)))]
+    if (rowFiles.length < undeclared.length) {
+      dropNote = `${undeclared.length - rowFiles.length} 个 quick 元数据/他者变更目录文件不计入范围视图`
+    }
+  }
   const stats = collectNumstatByPath(sessionRoot, rowFiles, { baseRef: 'HEAD' })
 
   const rows = rowFiles.map(f => {
@@ -446,7 +672,7 @@ async function computeQuickAudit({ cwd, platformOpts, sessionId, located, collec
 
   // 「quick 已提交」降级（design 总体方案）：窗口空（changedFiles 空）且 QUICKLOG 已有该会话
   // 条目 → 记录态提示读 QUICKLOG，不以空表冒充实时。
-  let note = null
+  let note = dropNote
   if (rowFiles.length === 0) {
     const qlId = guard.quicklogId || null
     if (quicklogHasEntry(guardSpecBase, qlId)) {
@@ -475,6 +701,11 @@ async function computeQuickAudit({ cwd, platformOpts, sessionId, located, collec
     },
     frozenPatch,
     note,
+    // 画像透传（FR-04 / task-03 gateProfile-json）：auditQuickCompletion 挂的 review.gateProfile
+    // 原样随 review 携带进结果对象——不重复计算（与 --done 时点同源）；fail-open 时为 null
+    // （消费方按存在性读取）。complete-handlers --done 落 quicklog/patches/<qlId>.json 时随
+    // 快照对象冻结，供冻结重放路径透传。
+    gateProfile: audit.gateProfile && typeof audit.gateProfile === 'object' ? audit.gateProfile : null,
   }
 }
 
@@ -493,7 +724,8 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   // 审计 tag）全无 = 尚未进入 execute——实际侧不存在（B2 会吞整个工作区脏文件误归属本变更，
   // 2026-09-11-cross-change-decision-guard 实证 28 个「计划外」全是并行在途）。出计划清单
   // 视图：rows=design 清单 untouched（待实现），工作区改动归属各自会话不进表。
-  const hasWorktreeMeta = existsSync(join(sb, '.runtime', 'worktrees', changeName, 'meta.json'))
+  // 双根（坑 platform-dual-root-form-misjudge）：平台模式 sb=specRoot 时项目侧 meta 单路径读不到
+  const hasWorktreeMeta = !!_readWorktreeMeta(sb || null, cwd, changeName)
   const hasBranch = !!safeGit(cwd, ['rev-parse', '--verify', '--quiet', `sillyspec/${changeName}^{commit}`], { timeout: 15 * 1000 }).value
   const hasAuditTag = !!safeGit(cwd, ['rev-parse', '--verify', '--quiet', `sillyspec-audit/sillyspec/${changeName}^{commit}`], { timeout: 15 * 1000 }).value
   // 审查 C-F02：预执行判定必须排除归档（归档=流程走完，58/77 归档变更三信号全缺被误判
@@ -529,11 +761,12 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
     try {
       prePlanned = parseFileChangeListDetailed(
         join(changeDirInfo ? changeDirInfo.dir : join(sb, 'changes', changeName), 'design.md'),
-        { keepSillyspecDocs: true })
+        { keepSillyspecDocs: true, repoKeys: loadRegisteredRepoKeys(sb) })
     } catch { /* 清单解析失败 → 空清单 + 说明 */ }
     const preRows = prePlanned.map(e => ({
       path: e.path, planned: e.operation || null, additions: 0, deletions: 0,
       kind: 'modified', verdict: 'untouched',
+      ...(e.repo ? { crossRepo: e.repo } : {}),
     }))
     return {
       ...emptyBase,
@@ -551,8 +784,9 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   let planDegraded = null
   try {
     // keepSillyspecDocs=true：与 actual 侧 filterDeliverableFiles 保留 .sillyspec/docs/** 交付物
-    // 的口径对齐（dogfood 模块文档=交付物）
-    plannedEntries = parseFileChangeListDetailed(designMdPath, { keepSillyspecDocs: true })
+    // 的口径对齐（dogfood 模块文档=交付物）；repoKeys=注册仓清单——跨仓子段/`cross-repo:` 前缀
+    // 条目带 repo 字段（改进点 2，标注「跨仓（本表不含）」的数据源）
+    plannedEntries = parseFileChangeListDetailed(designMdPath, { keepSillyspecDocs: true, repoKeys: loadRegisteredRepoKeys(sb) })
   } catch (e) {
     planDegraded = `design.md 清单解析异常: ${e && e.message ? String(e.message).split('\n')[0] : e}`
   }
@@ -562,16 +796,68 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
       : `design.md 不存在（${toPosix(designMdPath)}）——降级实际侧 only 视图（不出三态列）`
   }
 
-  // —— 实际侧（verify-postcheck.js task-02 契约：files + baseAnchor；动态 import 隔离
-  //    并行时序——task-02 未落地时降级说明而非炸）——
+  // —— 实际侧采集 ——
+  // 形态 A（worktree 存活，quick-ec5fc714）：**自采纯 worktree 口径**——锚（meta baselineCommit
+  // 优先）..worktree 工作区 = 本变更真实边界（子代理未提交改动 + 分支已提交）。不沿用
+  // resolveVerifyChangedFiles（其语义是「verify 证据核验面」：主仓∪worktree 并集——对证据核验
+  // 合理，对本变更范围全是噪音：主仓侧 20 并行文件混入，且它们对 worktree 锚 diff miss 后落
+  // wc-l 档记成整文件行数，两放大器叠加出 +11840/22 文件的巨型表）。
+  // 形态 B（post-apply）：继续走 resolveReconcileActualFiles 三源（本变更活已回主仓，语义正确）。
   let actual = null
   let actualFailure = null
   try {
-    const mod = await import('./verify-postcheck.js')
-    if (typeof mod.resolveReconcileActualFiles !== 'function') {
-      throw new Error('resolveReconcileActualFiles 未导出（依赖契约未就绪）')
+    const found = _readWorktreeMeta(sb || null, cwd, changeName)
+    if (found) {
+      const wtRoot = found.gitDir
+      const anchor = found.meta.baselineCommit || found.meta.actualBaseHash || found.meta.baseHash || null
+      if (anchor) {
+        const diffOut = safeGit(wtRoot, ['diff', '--name-only', anchor], { timeout: 30 * 1000 })
+        if (!diffOut.error && typeof diffOut.value === 'string') {
+          // 过滤口径与 resolveVerifyChangedFiles 的 wtFiles 同款（保留 docs 交付物，排运行时/进度面）
+          const wtFilter = (p) => p && p !== '.sillyspec'
+            && !p.startsWith('.sillyspec/changes/')
+            && !p.startsWith('.sillyspec/.runtime/')
+            && !p.startsWith('.sillyspec/quicklog/')
+          const files = diffOut.value.split('\n')
+            .map(p => toPosix(p.replace(/^"|"$/g, '').trim()))
+            .filter(wtFilter)
+          // untracked 新文件不在 diff（git diff 只看 tracked）——status --porcelain 并入
+          // （与旧链路 includeWorkingTree 的 wtFiles 半边同覆盖，行数侧走 wc-l 档）
+          const st = safeGit(wtRoot, ['status', '--porcelain', '--untracked-files=all'], { timeout: 30 * 1000, trim: false })
+          if (!st.error && typeof st.value === 'string') {
+            for (const line of st.value.split('\n')) {
+              if (!line.startsWith('??')) continue
+              const p = toPosix(line.slice(3).trim().replace(/^"|"$/g, '').split(' -> ').pop() || '')
+              if (wtFilter(p) && !files.includes(p)) files.push(p)
+            }
+          }
+          actual = { ok: true, form: 'worktree', files, sources: ['worktree:diff-anchor..worktree', 'worktree:status-untracked'], foreignExcluded: 0, foreignExcludedFiles: [], degradedReason: null, baseAnchor: anchor }
+        } else {
+          actual = { ok: false, form: 'worktree', files: [], sources: [], foreignExcluded: 0, foreignExcludedFiles: [], degradedReason: 'worktree 锚定 diff 失败', baseAnchor: null }
+        }
+      } else {
+        // 无锚 meta（baseHash 等字段缺失）：退 HEAD 未提交窗口口径——文件集=status 全量
+        // （tracked 改动 + untracked），行数侧由主链路 HEAD 兜底（quick-8aa52289 契约不变）
+        const st = safeGit(wtRoot, ['status', '--porcelain', '--untracked-files=all'], { timeout: 30 * 1000, trim: false })
+        const files = []
+        if (!st.error && typeof st.value === 'string') {
+          for (const line of st.value.split('\n')) {
+            const p = toPosix(line.slice(3).trim().replace(/^"|"$/g, '').split(' -> ').pop() || '')
+            if (p && p !== '.sillyspec'
+              && !p.startsWith('.sillyspec/changes/')
+              && !p.startsWith('.sillyspec/.runtime/')
+              && !p.startsWith('.sillyspec/quicklog/')) files.push(p)
+          }
+        }
+        actual = { ok: true, form: 'worktree', files, sources: ['worktree:status-porcelain(HEAD-window)'], foreignExcluded: 0, foreignExcludedFiles: [], degradedReason: null, baseAnchor: null }
+      }
+    } else {
+      const mod = await import('./verify-postcheck.js')
+      if (typeof mod.resolveReconcileActualFiles !== 'function') {
+        throw new Error('resolveReconcileActualFiles 未导出（依赖契约未就绪）')
+      }
+      actual = mod.resolveReconcileActualFiles({ cwd, specBase: sb, runtimeRoot, changeName })
     }
-    actual = mod.resolveReconcileActualFiles({ cwd, specBase: sb, runtimeRoot, changeName })
   } catch (e) {
     actualFailure = e && e.message ? String(e.message).split('\n')[0] : String(e)
   }
@@ -596,6 +882,29 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
     return { ...base, degradedReason: [reason, planDegraded].filter(Boolean).join('；') }
   }
 
+  // —— execute --done 采集·apply-pathspec 归属收窄（quick-ec5fc714）：apply 时点在 .runtime
+  // 落过本变更精确文件清单（worktree-apply.js 产 apply-pathspec-<change>.txt）——execute 采集
+  // 形态（freshActual+collectPatch，仅 printExecuteScopeAudit 组合）下按它收窄 actual.files，
+  // 快照/patch 冻**归属面**而非开放区间（平台仓实测：186KB 快照中 23/44 段为并行会话 docs
+  // 同步等噪音）。查询面不收窄（快照说什么是什么）；pathspec 缺失退开放区间（in-place 等）。
+  let narrowNote = null
+  if (freshActual && collectPatch) {
+    try {
+      const pathspecFile = join(runtimeRoot, `apply-pathspec-${changeName}.txt`)
+      const owned = readFileSync(pathspecFile, 'utf8').split('\n').map(l => toPosix(l.trim())).filter(Boolean)
+      if (owned.length > 0) {
+        const ownedSet = new Set(owned)
+        const before = actual.files.length
+        actual = { ...actual, files: actual.files.filter(f => ownedSet.has(toPosix(f))) }
+        // 收窄掉的并行噪音可见性保留（审计不静默挤走）
+        const dropped = before - actual.files.length
+        if (dropped > 0) {
+          narrowNote = `快照已按 apply-pathspec 收窄至本变更归属文件（剔除开放区间并行文件 ${dropped} 个——它们归属各自会话/变更）`
+        }
+      }
+    } catch { /* pathspec 缺失 → 开放区间（旧行为） */ }
+  }
+
   // —— 已收尾变更·冻结快照优先（真实 > 冻结记录 > 实时开放区间）：归档变更的范围应封闭在
   // apply 时点，不随后续主仓改动漂移（quick-f5acdeeb）；quick-bd84b852 放宽——**post-apply
   // （分支已删 = execute 已 apply 收尾）的活跃变更同样收尾**，此后实时区间只会被并行演进泡大
@@ -669,6 +978,7 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   const degraded = []
   if (planDegraded) degraded.push(planDegraded)
   const notes = []
+  if (narrowNote) notes.push(narrowNote)
   // 已收尾但快照缺失（上方分支置位）：实时开放区间兜底，明示漂移语义——快照机制上线
   // （2026-09-10）前收尾的旧变更冻结记录无法重建，如实告知替代渠道。
   if (noSnapshotDrift) {
@@ -693,10 +1003,20 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
     notes.push('baseAnchor 缺失——行数按 HEAD 未提交窗口采集（不含已提交改动，quick 模式同口径；numstat 采集失败时行列为 —）')
   }
 
-  // 他者声明排除面可见（R-04 同精神）：resolveReconcileActualFiles 只回计数不回名单，退栈的
-  // 计划内文件会误显「计划未动」——note 点破归属重叠可能性，让 ⚠️ 行可解释。
+  // 他者声明排除面可见（R-04 同精神）+ 退栈名单消费（scope-audit-cross-repo-blindness 改进点 3）：
+  // planned 文件被退栈排除但已写盘 → 该行标 suspectedForeignDone「疑似他者已实现·已退栈」，
+  // 与真未动区分（名单来自 resolveReconcileActualFiles 新增的 foreignExcludedFiles）。
+  const foreignExcludedSet = new Set((Array.isArray(actual.foreignExcludedFiles) ? actual.foreignExcludedFiles : []).map(toPosix))
   if (actual.foreignExcluded > 0) {
-    notes.push(`实际侧另有 ${actual.foreignExcluded} 个文件按他者会话声明退栈未进本表——「计划未动」行先怀疑归属重叠（声明即归属，git diff 核实）`)
+    notes.push(`实际侧另有 ${actual.foreignExcluded} 个文件按他者会话声明退栈未进本表——「计划未动」行标注「疑似他者已实现·已退栈」者即此类（声明即归属，git diff 核实）`)
+  }
+
+  // 计划侧跨仓段汇总（改进点 2）：跨仓条目不进本仓对账（actual 只采主仓 git），行级标
+  // crossRepo + note 交代去对应仓对账。
+  const crossRepoKeys = [...new Set(plannedEntries.map(e => e.repo).filter(Boolean))]
+  if (crossRepoKeys.length > 0) {
+    const crossCount = plannedEntries.filter(e => e.repo).length
+    notes.push(`计划侧含 ${crossCount} 个跨仓文件（repo：${crossRepoKeys.join('、')}）——⊘ 行不在本仓对账面（实际侧只采主仓 git），请到对应仓跑 scope-audit 对账`)
   }
 
   // —— 三态判定 ——
@@ -716,6 +1036,12 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
       } else {
         row.planned = null
         row.verdict = 'unplanned'
+        // 工具/平台脚手架（改进点 1 软桶）：CLI/平台自装文件不占「计划外」——硬排档
+        // （.worktrees//.sillyspec-platform*/knowledge/local.yaml）已被 filterDeliverableFiles
+        // 滤出不进 actual；此处打标的是可能正当交付的软档（.claude/skills/、CLAUDE.md、
+        // attachments/），范围视图归入「工具/平台设施」桶。
+        const facility = classifyToolScaffold(path)
+        if (facility) row.facility = facility
       }
     }
     rows.push(row)
@@ -723,7 +1049,16 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   // 计划未动：清单文件无实际改动 → 补行（行数 0/0）；计划侧降级时不产（plannedEntries 为空天然不跑）
   for (const e of plannedEntries) {
     if (matchedPlanned.has(e.path)) continue
-    rows.push({ path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched' })
+    const row = { path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched' }
+    if (e.repo) {
+      // 跨仓条目（改进点 2）：不是「未动」是「本表不含」
+      row.crossRepo = e.repo
+    } else {
+      // 退栈排除 + 盘面已存在 → 他者会话已写盘（改进点 3）；NEW: 前缀剥除后比对（pathMatches 同款口径）
+      const norm = toPosix(e.path).replace(/^NEW:/, '')
+      if (foreignExcludedSet.has(norm) && existsSync(join(numstatRoot, norm))) row.suspectedForeignDone = true
+    }
+    rows.push(row)
   }
 
   // 冻结 patch（collectPatch，execute --done 落盘方消费）：与行数同根同锚（numstatRoot +
@@ -764,9 +1099,18 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
  *   rows: Array<{ path: string, planned?: string|null, declared?: boolean,
  *                 additions: number|null, deletions: number|null,
  *                 kind: 'binary'|'new'|'modified'|'deleted',
- *                 verdict?: 'planned'|'unplanned'|'untouched', attribution?: 'declared'|'soft'|'undeclared' }>,
+ *                 verdict?: 'planned'|'unplanned'|'untouched', attribution?: 'declared'|'soft'|'undeclared',
+ *                 crossRepo?: string, suspectedForeignDone?: boolean, facility?: 'tool'|'platform' }>,
+ *   （crossRepo/suspectedForeignDone/facility 为 scope-audit-cross-repo-blindness 改进点 1/2/3
+ *     增量字段：跨仓条目标 repoKey / 退栈排除但已写盘的 planned 文件 / 计划外行里的工具平台
+ *     脚手架桶——均为按存在性读取，缺省无字段零回归）
  *   excluded: { foreignDeclared: Array<{ file: string, sessions: string[] }> },
- *   note?: string|null }>}
+ *   note?: string|null,
+ *   gateProfile?: object|null }>}
+ *   gateProfile（2026-09-14-quick-exit-tiered-gates task-03 增量字段，消费方按存在性读取）：
+ *   仅 quick 模式携带——实时态透传 auditQuickCompletion 挂的 review.gateProfile（不重复计算）；
+ *   冻结重放态透传 quicklog/patches 记录冻结值（旧记录无 → rows 文件清单现算重放）。full-flow
+ *   全流程变更恒无该字段（零回归契约）。
  */
 export async function computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts, collectPatch, freshActual } = {}) {
   const empty = {
@@ -778,6 +1122,21 @@ export async function computeChangeScopeAudit({ cwd, specBase, changeName, platf
     if (!cwd || !changeName) {
       return { ...empty, degradedReason: '参数缺失：cwd 与 changeName 必填' }
     }
+    // ql-xxx 反查（「为什么不直接用 ql-xxx 查」根治）：patches 记录按 qlId 命名且 json 冗余
+    // sessionId——ql-xxx → quick-xxx 映射在 patches 里持久可查（guard 已清也能出记录态）。
+    // 提升到 quick 判定外层：ql-xxx 不匹配 QUICK_SID_RE，在内部分支永远进不去。
+    if (QL_ID_RE.test(changeName)) {
+      const byQl = findQuickSessionByQlId(cwd, changeName)
+      if (byQl) {
+        const rec = { record: byQl.record, patchPath: byQl.patchPath, qlId: byQl.qlId, specBase: byQl.specBase }
+        return buildQuickRecordResult(rec, changeName)
+      }
+      return {
+        ...empty,
+        mode: 'quick',
+        degradedReason: `quick 条目 ${changeName} 在 quicklog/patches/ 无记录——会话未产生改动、早于记录机制，或 patches 目录已被清理`,
+      }
+    }
     // quick 模式判定（pattern + guard 双条件，与 run/command.js :140/:652 口径一致）
     if (QUICK_SID_RE.test(changeName)) {
       const located = locateQuickSessionGuard(cwd, changeName)
@@ -788,21 +1147,7 @@ export async function computeChangeScopeAudit({ cwd, specBase, changeName, platf
       // 命中出冻结记录（行数为 --done 时点真值），patch 可供 --file 切片
       const rec = findQuickPatchRecord(cwd, changeName)
       if (rec) {
-        return {
-          mode: 'quick', ok: true, degradedReason: null,
-          baseAnchor: rec.record.baseAnchor || `quick-window:${changeName}`,
-          totals: rec.record.totals && typeof rec.record.totals === 'object'
-            ? rec.record.totals
-            : { files: rec.record.rows.length, ...sumTotals(rec.record.rows) },
-          rows: rec.record.rows,
-          excluded: rec.record.excluded && Array.isArray(rec.record.excluded.foreignDeclared)
-            ? rec.record.excluded
-            : { foreignDeclared: [] },
-          frozenPatchPath: rec.patchPath,
-          patchSha256: rec.record.patchSha256 || null,
-          patchStatus: rec.record.patchStatus || null,
-          note: `quick 会话已收尾——记录态（quicklog/patches/${rec.qlId}，${rec.record.savedAt ? String(rec.record.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘' : '--done 时点冻结'}）`,
-        }
+        return buildQuickRecordResult(rec, changeName)
       }
       return {
         ...empty,
@@ -891,7 +1236,7 @@ export async function getFileDiff({ cwd, specBase, changeName, platformOpts, fil
       const located = locateQuickSessionGuard(cwd, changeName)
       if (located) root = dirname(located.specBase)
     } else {
-      const form = existsSync(join(sb, '.runtime', 'worktrees', changeName, 'meta.json')) ? 'worktree' : 'post-apply'
+      const form = _readWorktreeMeta(sb || null, cwd, changeName) ? 'worktree' : 'post-apply'
       root = resolveDiffRoot(sb, changeName, form, cwd)
     }
 
@@ -914,12 +1259,16 @@ export async function getFileDiff({ cwd, specBase, changeName, platformOpts, fil
   }
 }
 
-/** verdict / attribution → 展示标记（人类可读面；BIN 为 binary 行数占位，— 为降级占位） */
+/** verdict / attribution → 展示标记（人类可读面；BIN 为 binary 行数占位，— 为降级占位）。
+ *  行级标注优先（scope-audit-cross-repo-blindness 改进点 1/2/3）：跨仓 > 疑似他者已实现 > 设施桶 */
 const VERDICT_LABEL = {
   planned: '✓ 计划内',
   unplanned: '⚠️ 计划外',
   untouched: '⚠️ 计划未动',
 }
+const CROSS_REPO_LABEL = '⊘ 跨仓（本表不含）'
+const SUSPECTED_FOREIGN_LABEL = '⚠️ 计划未动（疑似他者已实现·已退栈）'
+const FACILITY_LABEL = '⚠️ 计划外（工具/平台设施）'
 const ATTRIBUTION_LABEL = {
   declared: '✓ 已声明',
   soft: '🔍 软归属',
@@ -936,6 +1285,8 @@ function fmtCount(n) {
  *
  * 防御式：result 任意字段缺失/畸形不抛（advisory 展示层）。opts.maxRows 截断 + 指引行
  * （R-03：大表注入场景由调用方传 60，命令直跑缺省全表）。
+ * [gate] 画像段（task-03，gate-table-section）：result.gateProfile 存在时（quick 模式）追加
+ * 级别/跨度/模块/风险命中/缺失检查项段；字段缺失/为 null（full-flow / 重放不可得）→ 零输出零回归。
  *
  * @param {object} result computeChangeScopeAudit 返回值
  * @param {{ maxRows?: number }} [opts] 可选截断（缺省不截）
@@ -980,7 +1331,10 @@ export function renderScopeAuditTable(result, opts = {}) {
     const stat = row.kind === 'binary'
       ? { a: 'BIN', d: 'BIN' }
       : { a: fmtCount(row.additions) ?? '—', d: fmtCount(row.deletions) ?? '—' }
-    const label = VERDICT_LABEL[row.verdict] || ATTRIBUTION_LABEL[row.attribution] || ''
+    const label = row.crossRepo ? CROSS_REPO_LABEL
+      : row.suspectedForeignDone ? SUSPECTED_FOREIGN_LABEL
+      : row.facility ? FACILITY_LABEL
+      : VERDICT_LABEL[row.verdict] || ATTRIBUTION_LABEL[row.attribution] || ''
     lines.push(`   ${row.path || '(未知路径)'}${' '.repeat(Math.max(1, 40 - String(row.path || '').length))}${label}${' '.repeat(Math.max(1, 12 - label.length))}${String(stat.a).padStart(5)} ${String(stat.d).padStart(5)}   ${row.kind || ''}`)
   }
   if (rows.length > shown.length) {
@@ -989,18 +1343,64 @@ export function renderScopeAuditTable(result, opts = {}) {
 
   lines.push(`   合计：${totals.files ?? rows.length} 文件  +${totals.additions ?? 0} / -${totals.deletions ?? 0}`)
 
-  // ⚠️ 出口指引（full-flow 三态面）：计划外补声明、计划未动确认遗漏
-  const unplanned = rows.filter(x => x && x.verdict === 'unplanned').length
-  const untouched = rows.filter(x => x && x.verdict === 'untouched').length
-  if (unplanned > 0 || untouched > 0) {
+  // ⚠️ 出口指引（full-flow 三态面）：计划外补声明、计划未动确认遗漏。
+  // 行级标注三分（scope-audit-cross-repo-blindness 改进点 1/2/3）：跨仓行/疑似他者已实现行/
+  // 工具设施桶各有去向说明，不混入笼统的「计划外/计划未动」计数逼用户排查噪音。
+  const unplanned = rows.filter(x => x && x.verdict === 'unplanned' && !x.facility).length
+  const facility = rows.filter(x => x && x.verdict === 'unplanned' && x.facility).length
+  const untouchedReal = rows.filter(x => x && x.verdict === 'untouched' && !x.suspectedForeignDone && !x.crossRepo).length
+  const suspectedForeign = rows.filter(x => x && x.suspectedForeignDone).length
+  const crossRepo = rows.filter(x => x && x.crossRepo).length
+  if (unplanned > 0 || untouchedReal > 0) {
     const parts = []
     if (unplanned > 0) parts.push(`计划外 ${unplanned} 文件`)
-    if (untouched > 0) parts.push(`计划未动 ${untouched} 文件`)
+    if (untouchedReal > 0) parts.push(`计划未动 ${untouchedReal} 文件`)
     lines.push(`   ⚠️ ${parts.join('、')}——计划外请补 design.md 声明或 --output 注明原因；计划未动请确认是否遗漏`)
   }
+  if (suspectedForeign > 0) {
+    lines.push(`   ℹ️ 疑似他者已实现 ${suspectedForeign} 文件（已写盘但被退栈——他者会话声明归属，本表不计未动；git diff 核实归属）`)
+  }
+  if (facility > 0) {
+    lines.push(`   ℹ️ 工具/平台设施 ${facility} 文件（CLI/平台自装脚手架，非本变更改动，不占计划外）`)
+  }
+  if (crossRepo > 0) {
+    lines.push(`   ℹ️ 跨仓 ${crossRepo} 文件（⊘ 行——本表不含，请到对应仓跑 scope-audit 对账）`)
+  }
   const undeclared = rows.filter(x => x && x.attribution === 'undeclared').length
   if (undeclared > 0) lines.push(`   ⚠️ 未声明 ${undeclared} 文件——超出 allowedFiles 声明面，补 --files 声明或注明原因`)
 
+  // ── [gate] 画像段（2026-09-14-quick-exit-tiered-gates task-03，FR-04 / D-008 gate-table-section）：
+  // quick 会话分级门禁画像的表格出口。按 gateProfile 存在性渲染——full-flow 变更 / 画像为 null
+  // → 零输出零回归；检查项随级别分层（L1：每文件注记+测试增量；L2：模块文档认领+风险命中），
+  // 与 run/quick-audit.js [gate] 打印块同一 review.gateProfile 数据源、同 tier 语义（advisory 展示，
+  // 不构成门禁）。防御式：字段缺失/畸形不抛（degraded 无 span、modules 空集等均有占位）。
+  const gate = r.gateProfile && typeof r.gateProfile === 'object' ? r.gateProfile : null
+  if (gate) {
+    const gateModules = Array.isArray(gate.modules) ? gate.modules.filter(m => m && typeof m === 'object') : []
+    const spanTxt = gate.degraded
+      ? '无 module-map（降级档：span 不参与判级）'
+      : `跨 ${gate.moduleSpan ?? '—'} 模块${gateModules.length > 0 ? `（${gateModules.map(m => String(m.id)).join(' · ')}）` : ''}`
+    lines.push(`   🚦 [gate] ${gate.level ?? '—'} 规模门（${spanTxt} · ${gate.fileCount ?? '—'} 文件：${gate.codeFileCount ?? '—'} 代码 / ${gate.testFileCount ?? '—'} 测试）——advisory 画像不阻断`)
+    if (Array.isArray(gate.unmappedFiles) && gate.unmappedFiles.length > 0) {
+      lines.push(`   ⚠️ ${gate.unmappedFiles.length} 个文件未命中 module-map（${gate.unmappedFiles.slice(0, 5).join(', ')}${gate.unmappedFiles.length > 5 ? ' 等' : ''}）`)
+    }
+    const checks = gate.checks && typeof gate.checks === 'object' ? gate.checks : {}
+    if (gate.level === 'L1') {
+      if (checks.perFileNotes === false) lines.push('   - 每文件注记缺失——补 --file-notes "path1::注 || path2::注"（覆盖变更文件全集）')
+      if (checks.testDelta === 'missing') lines.push(`   - 测试增量缺失——${gate.codeFileCount} 个代码文件改动无测试文件`)
+    } else if (gate.level === 'L2') {
+      if (checks.docClaim === 'missing') lines.push('   - 模块文档认领缺失——触及模块的卡片文件不在改动集（补模块卡/changelog 或 --no-docs 豁免）')
+      if (checks.docClaim === 'exempt-no-docs') lines.push('   - 模块文档认领：--no-docs 显式豁免')
+    }
+    if (Array.isArray(gate.riskHits) && gate.riskHits.length > 0) {
+      lines.push(`   - 风险命中 ${gate.riskHits.length} 处（运行时证据要求——风险路径改动需附运行验证说明）：`)
+      for (const h of gate.riskHits.slice(0, 5)) {
+        if (h && typeof h === 'object') lines.push(`     · [${h.pattern}] ${h.file}`)
+      }
+      if (gate.riskHits.length > 5) lines.push(`     … 共 ${gate.riskHits.length} 处`)
+    }
+  }
+
   // 他者会话声明排除面（R-04：不进 rows，单列可见）
   if (foreignDeclared.length > 0) {
     lines.push(`   他者会话声明（不进上表，归属对应会话审计）：`)