sillyspec 3.28.13 → 3.29.0

package/src/run/prompt.js

@@ -20,6 +20,8 @@
  */
 import { basename, join } from 'node:path'
 import { existsSync, readFileSync, mkdirSync, readdirSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import jsYaml from 'js-yaml'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { stageRegistry } from '../stages/index.js'
 import { resolvePromptIncludes, resolveRuntimeRoot, safeGit, parsePorcelainPath, WAIT_MARKER_RE, QUICK_SID_RE, triggerStepStartSync } from './shared.js'
@@ -34,6 +36,97 @@ import { REVIEW_SCHEMA_VERSION, isValidExecuteRunId } from '../task-review.js'
 // buildKnowledgeInjection docstring）。
 import { matchKnowledge } from '../knowledge-match.js'
 import { appendKnowledgeHit } from '../knowledge-hits.js'
+import { readActiveFrDigest } from '../fr-index.js'
+// 前置失败清单 validator 面（2026-09-18-preflight-slimming task-01）：design-facts /
+// stage-contract-engine 均为 src/ 叶子方向（不反向 import 本模块），静态 import 不引入环。
+import { validateDesignFileList } from '../design-facts.js'
+import { evaluateRules } from '../stage-contract-engine.js'
+// 注入账本锁（2026-09-18-preflight-slimming task-02，R-06）：withFileLock（quicklog.js:40 先例，
+// 防多会话 read-modify-write 丢更新）——quicklog.js 仅 import path/fs/crypto/git-helper/
+// stage-contract-spec，不反向引用本模块，静态 import 不引入环。
+import { withFileLock } from '../quicklog.js'
+
+// ═══════════════════════════════════════════════════════════════
+// ceremony 档位仪式菜单（2026-09-18-ceremony-risk-pricing task-05，D-002/D-005）
+// ═══════════════════════════════════════════════════════════════
+
+/** ceremony 档位序（与 ceremony-tier.js CEREMONY_TIERS 同序；此处仅作消费侧排序/枚举校验，不 reimport） */
+const CEREMONY_TIER_ORDER = ['S0', 'S1', 'S2', 'S3']
+
+/** 档位→仪式菜单（消费侧映射，design「档位→仪式菜单」契约：引擎只定价不映射） */
+const CEREMONY_TIER_MENUS = [
+  ['S0', 'CLI 清单核验（stage-review-checklist 机械项逐条核对，零 token 发散）'],
+  ['S1', 'CLI 清单核验 + 定向探针抽查（机械项全查 + 高风险交叉点定向源码探针，无需独立子代理）'],
+  ['S2', '独立评审×1（独立审查子代理单轮 + review.json）'],
+  ['S3', '两轮独立评审 + Grill 深查（两轮独立子代理交叉 + review.json）'],
+]
+
+/**
+ * 读 local.yaml `ceremony:` 段（best-effort 绝不抛，对齐 readReviewChannelPriority 范式）。
+ * force_tier：S0|S1|S2|S3 枚举逃生阀（非法值 warn 后忽略）；shadow：boolean 缺省 true。
+ * config-schema.js ceremony 节的 prompt 面 reader（影子派发侧消费随 task-06 接线）。
+ */
+export function readCeremonyLocalConfig(cwd) {
+  let raw = null
+  try {
+    const p = join(cwd || process.cwd(), '.sillyspec', 'local.yaml')
+    if (existsSync(p)) raw = jsYaml.load(readFileSync(p, 'utf8'))
+  } catch { raw = null }
+  const c = raw && typeof raw === 'object' && raw.ceremony && typeof raw.ceremony === 'object'
+    ? raw.ceremony
+    : null
+  const forceRaw = c && typeof c.force_tier === 'string' ? c.force_tier.trim() : null
+  const forceTier = CEREMONY_TIER_ORDER.includes(forceRaw) ? forceRaw : null
+  if (forceRaw && !forceTier) {
+    console.warn(`[sillyspec] ceremony.force_tier 未知档位「${forceRaw}」已忽略（可选：${CEREMONY_TIER_ORDER.join(' | ')}）`)
+  }
+  const shadow = c && typeof c.shadow === 'boolean' ? c.shadow : true
+  return { forceTier, shadow }
+}
+
+/**
+ * ceremony 档位菜单渲染（{REVIEW_TIER} 注入值的追加块——追加不替换：tier: self/independent
+ * 语义与 {REVIEW_TIER_REASON} 注入机制原样保留，菜单块按 ceremonyTier 标注当前档）。
+ *
+ * 逃生阀（ceremony.force_tier）只升不降：强制档高于客观定价档 → 菜单当前档随调、注入
+ * tier 值升为 independent（S2/S3）；低于客观档 → 只留注记不降档——防 prompt 面与 gate 侧
+ * classifyReviewTier（未读逃生阀）判定分裂（prompt 说 self 而 gate 等 review.json 的错位阻断）。
+ *
+ * 强制轻仪审计痕（FR-02）：agent 报 plan_level=full 而档位 S0/S1 → 菜单块追加固定审计行
+ * （照「分级异常降级 self」既有降级戳先例：注入文案即留痕），明示勿因「计划写得完整」自行升仪。
+ *
+ * @param {{ ceremonyTier?: string, tierValue?: string, planLevel?: string|null, cwd?: string }} args
+ * @returns {{ tierValue: string, menuMd: string }} menuMd 以 \n 开头（拼在 tier 值后）；无有效档位时为 ''
+ */
+export function renderCeremonyTierInjection({ ceremonyTier, tierValue, planLevel, cwd } = {}) {
+  const baseTierValue = tierValue || 'self'
+  if (!CEREMONY_TIER_ORDER.includes(ceremonyTier)) {
+    return { tierValue: baseTierValue, menuMd: '' }
+  }
+  const { forceTier, shadow } = readCeremonyLocalConfig(cwd)
+  let active = ceremonyTier
+  let forceNote = ''
+  let effectiveTierValue = baseTierValue
+  if (forceTier && forceTier !== ceremonyTier) {
+    if (CEREMONY_TIER_ORDER.indexOf(forceTier) > CEREMONY_TIER_ORDER.indexOf(ceremonyTier)) {
+      active = forceTier
+      forceNote = `——local.yaml ceremony.force_tier=${forceTier} 强制升档（逃生阀，绕过客观定价）`
+      if (active === 'S2' || active === 'S3') effectiveTierValue = 'independent'
+    } else {
+      forceNote = `——local.yaml ceremony.force_tier=${forceTier} 低于客观定价档，不降档（只升不降）`
+    }
+  }
+  const menuLines = CEREMONY_TIER_MENUS.map(([t, menu]) => `- ${t}：${menu}${t === active ? ' ◀ 当前档' : ''}`)
+  const lightTier = active === 'S0' || active === 'S1'
+  const shadowNote = lightTier && shadow
+    ? '\n（影子期 on：轻档明面轻仪，后台静默派发重仪式对照只记账不阻断——local.yaml ceremony.shadow 开关，对照报告见 doctor）'
+    : ''
+  const auditTrail = planLevel === 'full' && lightTier
+    ? '\n⚠️ 强制轻仪审计痕：agent 报 plan_level=full 但 ceremony 档为轻档——仪式按 risk 计价、plan_level 仅编排，按当前轻档菜单执行，勿因「计划写得完整」自行升回 independent×2'
+    : ''
+  const menuMd = `\nceremony_tier: ${active}${forceNote}（仪式按 risk 计价，plan_level 仅编排——四档菜单：）\n${menuLines.join('\n')}${shadowNote}${auditTrail}`
+  return { tierValue: effectiveTierValue, menuMd }
+}
 
 /**
  * 从 _module-map.yaml 读取模块上下文索引
@@ -70,10 +163,9 @@ export function loadModuleContextIndex(specBase, projectName) {
  * @param {object} moduleIndex - loadModuleContextIndex 返回值
  * @param {string} specBase - 规范目录
  * @param {string} projectName - 项目名
- * @returns {string} 上下文注入文本，空字符串表示无匹配模块
+ * @returns {{text: string, frModules: Array<{id: string, count: number}>}} 上下文注入文本（空=无匹配模块）+ 有活需求的模块清单（供遥测）
  */
-function buildModuleContextInjection(taskDescription, moduleIndex, specBase, projectName) {
-  if (!moduleIndex || !taskDescription) return ''
+export function buildModuleContextInjection(taskDescription, moduleIndex, specBase, projectName) {  if (!moduleIndex || !taskDescription) return { text: '', frModules: [] }
 
   const taskLower = taskDescription.toLowerCase()
   const matched = []
@@ -93,15 +185,22 @@ function buildModuleContextInjection(taskDescription, moduleIndex, specBase, pro
     if (score > 0) matched.push({ moduleId, data, score, matchReasons })
   }
 
-  if (matched.length === 0) return ''
+  if (matched.length === 0) return { text: '', frModules: [] }
 
   matched.sort((a, b) => b.score - a.score)
 
   let injection = '\n### 📦 模块上下文（按相关性排序，来自 Module Context Index）\n\n'
   injection += `> 以下模块上下文由 scan 阶段生成的 _module-map.yaml 自动匹配。\n`
+  injection += `> 活需求来自 knowledge/fr 索引（active 以索引为准，现场 join）——承接/取代指引见 step8 digest\n`
   injection += `> Matched modules: ${matched.map(m => m.moduleId).join(', ')}\n`
   injection += `> Reasons: ${matched.map(m => m.matchReasons.join(', ')).join('; ')}\n\n`
 
+  // FR 活需求注入期 join（ql-20260919-002，L2 替代形态）：join 键 = 域≡模块 id
+  // （fr-index.js resolveTouchedDomains 同键），现场查 active 条目——id+标题紧凑行（场景名
+  // 留给 brainstorm step8 digest：此处设计期感知，digest 写作期指引——**有意冗余勿当重复
+  // 优化掉**）。截前 5 条+溢出指针行；空段消隐（与 digest 空态同款）。fail-open：读失败该
+  // 模块无活需求行，绝不阻塞注入。
+  const frModules = []
   for (const { moduleId, data } of matched) {
     injection += `#### ${moduleId}\n`
     if (data.role) injection += `- **职责**: ${String(data.role).slice(0, 100)}\n`
@@ -124,10 +223,21 @@ function buildModuleContextInjection(taskDescription, moduleIndex, specBase, pro
     if (recentChanges.length > 0) {
       injection += `- **最近变更**: ${recentChanges.slice(0, 3).map(e => e.name).join('、')}\n`
     }
+    // 活需求行（注入期 join 本体）
+    try {
+      const frs = readActiveFrDigest(join(specBase, 'knowledge'), [moduleId])
+      if (frs.length > 0) {
+        const top = frs.slice(0, 5).map(f => `${f.id} ${f.title}`.trim()).join('；')
+        injection += `- **活需求**: ${top}`
+        if (frs.length > 5) injection += `；+${frs.length - 5} 条见 knowledge/fr/${moduleId}.md`
+        injection += '\n'
+        frModules.push({ id: moduleId, count: frs.length })
+      }
+    } catch { /* fail-open：FR 读失败该模块无活需求行 */ }
     injection += '\n'
   }
 
-  return injection
+  return { text: injection, frModules }
 }
 
 /**
@@ -450,6 +560,198 @@ export function requiresUser(step, promptText) {
   return WAIT_MARKER_RE.test(String(promptText || ''))
 }
 
+// ── 前置失败清单 + 注入账本分叉（2026-09-18-preflight-slimming task-01，D-001@v1 / D-002@v1）──
+// 纯函数面三导出之二/之三（hasDecisionId 在 src/decisions-io.js）。本节只打底零接线：
+// {PREFLIGHT_FAILURES} 占位符渲染与模块/scan 注入分叉归 task-02，stages 步骤定义上的
+// preflightValidators 声明归 task-04——声明落地前 renderPreflightFailures 恒返 ''，旧 prompt
+// 逐字节不变（design 兼容策略第一条）。
+
+/** 前置清单聚合条数帽（R-01 防打架三约束：条数帽 5——截断防清单全文顶回上下文） */
+const PREFLIGHT_MAX_ITEMS = 5
+
+/** 单 validator 超时帽 ms（R-02：只读快跑不拖慢 prompt 渲染；超时该 validator 计为跳过） */
+const PREFLIGHT_VALIDATOR_TIMEOUT_MS = 3000
+
+/** 超时哨兵（Promise.race 输出侧标记；Symbol 防与 validator 返回值撞车） */
+const PREFLIGHT_TIMEOUT = Symbol('preflight-validator-timeout')
+
+/**
+ * 已声明 validator 名 → 只读校验函数映射（分发骨架的映射表）。
+ *
+ * 步骤定义在 stages/* 上声明 `preflightValidators: ['<键名>', ...]`（task-04 落地），渲染时按
+ * 声明序查本表调用。本表收录键：
+ *   - `design-file-list`：design-facts.validateDesignFileList 只读快查（design.md 文件清单
+ *     幻觉路径 gate 前置）——errors 项为 {path, message}，取 message。
+ *   - `four-piece-rules`：stage-contract 引擎轻查 brainstorm 四件套规则（evaluateRules 纯 kind
+ *     dispatch，existsSync/readFileSync 量级）。scale 读取与 stage-contract.js
+ *     validateBrainstormOutputs 同源（design.md frontmatter，fail-safe 无 scale → 四件套全
+ *     要求），保证「事前给的 == 事后查的」。v2 扩展点：若内容类规则实测拖慢渲染，可按
+ *     rule.id 白名单只跑四件套 file-exists 子集。
+ *   - `postcheck-lite`（plan postcheck 轻子集）/ `allowed-paths-scan`（execute allowed_paths
+ *     越界速查）：v2 扩展点——task-04 先声明亦安全跳过（未收录键零贡献，不报错）。
+ *
+ * 每个 validator 返回 { errors: string[] }（error 级失败消息；warning 不入清单——帽 5 内
+ * 只放会拦 --done 的项，防噪声挤占）。
+ */
+const PREFLIGHT_VALIDATORS = {
+  'design-file-list': ({ changeDir, cwd }) => {
+    const r = validateDesignFileList({ changeDir, cwd })
+    const errors = (r && Array.isArray(r.errors)) ? r.errors : []
+    return { errors: errors.map((e) => (e && e.message) ? e.message : String(e)) }
+  },
+  'four-piece-rules': ({ changeDir }) => {
+    let scale = null
+    const designPath = join(changeDir, 'design.md')
+    if (existsSync(designPath)) {
+      const fm = readFileSync(designPath, 'utf8').match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n/)
+      const sm = fm && fm[1].match(/^scale:[ \t]*['"]?(\w+)/m)
+      if (sm) scale = sm[1]
+    }
+    const r = evaluateRules('brainstorm', { changeDir, scale })
+    return { errors: (r && Array.isArray(r.errors)) ? r.errors : [] }
+  },
+}
+
+/**
+ * 单 validator 只读快跑（带 3s 超时帽）：Promise.race 模式——超时计为跳过（零贡献）；
+ * validator 抛错原样上抛（由 renderPreflightFailures 外层 catch 整体 fail-open 返 ''——
+ * 验收口径「validator 抛错或无失败返回空串」）。finally clearTimeout 防 3s 定时器
+ * 拖住 CLI 短进程退出（prompt 渲染完即退，悬挂 handle 会多挂 3s）。
+ *
+ * @param {string} name PREFLIGHT_VALIDATORS 键名
+ * @param {{ changeDir: string|null, cwd: string, specBase: string, stageName: string, stepName: string, changeName: string|null }} ctx
+ * @returns {Promise<string[]>} 该 validator 的 error 级失败消息（超时/未收录键 → []）
+ */
+async function runPreflightValidator(name, ctx) {
+  const fn = PREFLIGHT_VALIDATORS[name]
+  if (typeof fn !== 'function') return [] // 未收录键安全跳过（v2 扩展点见 PREFLIGHT_VALIDATORS 注释）
+  let timerId = null
+  try {
+    const timeout = new Promise((resolve) => { timerId = setTimeout(() => resolve(PREFLIGHT_TIMEOUT), PREFLIGHT_VALIDATOR_TIMEOUT_MS) })
+    const result = await Promise.race([Promise.resolve().then(() => fn(ctx)), timeout])
+    if (result === PREFLIGHT_TIMEOUT) return []
+    return (result && Array.isArray(result.errors)) ? result.errors : []
+  } finally {
+    if (timerId != null) clearTimeout(timerId)
+  }
+}
+
+/**
+ * renderPreflightFailures —— 产出型步骤 prompt 的前置失败清单渲染（D-001@v1 Phase 1 纯函数面）。
+ *
+ * 只读快跑本步骤 --done 将消费的 validator 子集，聚合 error 级失败为清单文本：
+ *   - 分发骨架：从 stages 注册表步骤定义读 `preflightValidators` 键（task-04 落声明；无声明/
+ *     无该 stage/无该步骤名 → 返 ''——渐进兼容，声明落地前零注入）。
+ *   - 聚合帽：条数帽 5 截断，截断时加「…另 N 项见 gate」行（完整判定归 gate，清单是预检
+ *     不是替身）；单 validator 超时帽 3s 计跳过；任何异常整体返 ''（fail-open 注入面——
+ *     绝不阻塞 prompt 渲染与门判定，R-02）。
+ *   - 防应试头行（R-07/FR-01）：清单头固定「已知失败项（非全部要求）」明示，防清单被当
+ *     待办清单应试打磨致清单外质量失查；尾行指路 gate 完整清单。
+ *
+ * 零副作用：只读不写（validator 全部只读函数），不碰 stages 定义与 outputStep 渲染路径。
+ *
+ * @param {{ stageName?: string, stepName?: string, cwd?: string, specBase?: string, changeName?: string }} args
+ * @returns {Promise<string>} 清单文本；无失败 / 无声明 / 异常 → ''
+ */
+export async function renderPreflightFailures({ stageName, stepName, cwd, specBase, changeName } = {}) {
+  try {
+    const stageDef = stageRegistry[stageName]
+    const steps = (stageDef && Array.isArray(stageDef.steps)) ? stageDef.steps : []
+    const step = steps.find((s) => s && s.name === stepName)
+    const declared = (step && Array.isArray(step.preflightValidators)) ? step.preflightValidators : []
+    if (declared.length === 0) return ''
+    const changeDir = (specBase && changeName) ? join(specBase, 'changes', changeName) : null
+    const ctx = { changeDir, cwd, specBase, stageName, stepName, changeName }
+    // 并行只读快跑（R-02）：validator 抛错 → Promise.all 整体 reject → 外层 catch 返 ''
+    const outcomes = await Promise.all(declared.map(async (name) => ({ name, errors: await runPreflightValidator(name, ctx) })))
+    // 聚合（声明序）+ 折行压平（gate failMessage 可能含换行，清单一项一行）
+    const items = []
+    for (const o of outcomes) {
+      for (const msg of o.errors) items.push(`- ${o.name}: ${String(msg).replace(/\s*\n\s*/g, ' ')}`)
+    }
+    if (items.length === 0) return ''
+    const shown = items.slice(0, PREFLIGHT_MAX_ITEMS)
+    const hidden = items.length - shown.length
+    return [
+      '⚠️ 已知失败项（非全部要求），清单外仍需按步骤说明自检：',
+      ...shown,
+      ...(hidden > 0 ? [`…另 ${hidden} 项见 gate`] : []),
+      `完整清单：sillyspec gate ${stageName} --json`,
+    ].join('\n')
+  } catch {
+    return '' // fail-open：任何异常静默不注（不阻 prompt 渲染）
+  }
+}
+
+/**
+ * shouldInjectFullContext —— 阶段注入账本分叉判定（D-002@v1 Phase 2 纯函数面）。
+ *
+ * 读 `<runtimeRoot>/prompt-inject-<changeName>.json` 账本（{stages:{[stage]:{firstStep,digest,at}}}）：
+ *   - 文件不存在 / JSON 坏 / 无该 stage 记录 → { full: true }（首步语义：本阶段尚未注过全量）
+ *   - 有记录 → { full: false, digest, firstStep }（同阶段后续步骤注摘要行的判定输入——
+ *     「本阶段上下文已于步骤 N 注入（digest 前 8 位）」）
+ *   - 账本读/解析异常 → { full: true }（design 兼容策略：分叉失败回退每步全量现状）
+ *
+ * 纯读不写：账本写入（首步全量注入后 withFileLock 幂等落盘）归 task-02；archive 回收
+ * （pruneArchivedChangeRuntime 枚举登记）归 task-03。
+ *
+ * @param {{ changeName?: string, stageName?: string, runtimeRoot?: string }} args
+ * @returns {{ full: boolean, digest?: string, firstStep?: number }}
+ */
+export function shouldInjectFullContext({ changeName, stageName, runtimeRoot } = {}) {
+  try {
+    if (!runtimeRoot || !changeName || !stageName) return { full: true }
+    const ledgerPath = join(runtimeRoot, `prompt-inject-${changeName}.json`)
+    if (!existsSync(ledgerPath)) return { full: true }
+    const ledger = JSON.parse(readFileSync(ledgerPath, 'utf8'))
+    const rec = (ledger && ledger.stages && typeof ledger.stages === 'object') ? ledger.stages[stageName] : null
+    if (!rec || typeof rec !== 'object') return { full: true }
+    return { full: false, digest: rec.digest, firstStep: rec.firstStep }
+  } catch {
+    return { full: true }
+  }
+}
+
+/**
+ * 阶段注入摘要行渲染（task-02 接线，D-002@v1 Phase 2）：shouldInjectFullContext 判 full=false
+ * 时的一行替代注入——同阶段后续步骤不再重注全量模块/scan 上下文，改指路（首步步骤号 + digest
+ * 前 8 位 + 可 Read 路径，R-03 摘要丢上下文风险的对冲：该读可读回）。firstStep/digest 缺失
+ * （账本记录不完整）给占位符不抛（渲染层永不因账本数据炸）。
+ *
+ * @param {{ firstStep?: number, digest?: string, specBase: string, projectName: string }} args
+ * @returns {string} 单行摘要（「> 」引语形态）
+ */
+function renderPromptInjectSummaryLine({ firstStep, digest, specBase, projectName }) {
+  const moduleMapPath = join(specBase, 'docs', projectName, 'modules', '_module-map.yaml')
+  const scanDocsDir = join(specBase, 'docs', projectName, 'scan')
+  return `> 本阶段模块/scan 上下文已于步骤 ${firstStep ?? '?'} 注入（digest ${digest || 'unknown'}）；需要时 Read ${moduleMapPath}（模块索引）或 ${scanDocsDir}/ 下 scan 文档（ARCHITECTURE.md / _facts.md）`
+}
+
+/**
+ * 阶段注入账本落账（task-02 接线，D-002@v1 Phase 2 / R-06）：首步全量注入后写
+ * `<runtimeRoot>/prompt-inject-<changeName>.json`（{stages:{[stage]:{firstStep,digest,at}}}，
+ * design 数据模型节）。withFileLock 串行化 read-modify-write（quicklog.js:40 先例——多会话
+ * 并行写同账本防丢更新）；幂等：已有该 stage 记录不覆盖（并发首步/同步重渲染不改写首步锚点）。
+ * digest=全量注入内容 sha256 前 8 位（摘要行可核对的指纹）。异常上抛由调用方 catch 静默
+ * （fail-open：账本写失败 → 后续步仍判 full 全量注入，绝不阻塞渲染）；archive 回收登记
+ * （pruneArchivedChangeRuntime 枚举补本文件名）归 task-03。
+ *
+ * @param {{ runtimeRoot: string, changeName: string, stageName: string, firstStep: number, digest: string }} args
+ */
+async function recordPromptInjectLedger({ runtimeRoot, changeName, stageName, firstStep, digest }) {
+  const ledgerPath = join(runtimeRoot, `prompt-inject-${changeName}.json`)
+  await withFileLock(ledgerPath + '.lock', () => {
+    let ledger = null
+    try { ledger = JSON.parse(readFileSync(ledgerPath, 'utf8')) } catch { ledger = null }
+    if (!ledger || typeof ledger !== 'object' || Array.isArray(ledger)) ledger = {}
+    if (!ledger.stages || typeof ledger.stages !== 'object' || Array.isArray(ledger.stages)) ledger.stages = {}
+    if (ledger.stages[stageName] && typeof ledger.stages[stageName] === 'object') return // 幂等：已有该 stage 记录不覆盖
+    ledger.stages[stageName] = { firstStep, digest, at: new Date().toISOString() }
+    mkdirSync(runtimeRoot, { recursive: true })
+    writeAtomicSync(ledgerPath, JSON.stringify(ledger, null, 2) + '\n')
+  })
+}
+
 export async function outputStep(stageName, stepIndex, steps, cwd, changeName, dbProjectName, platformOpts = {}, prevStepAnswer = null, waitHistory = null, autoMeta = null) {
   const step = steps[stepIndex]
   const total = steps.length
@@ -857,7 +1159,7 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
       try {
         const { appendKnowledgeHit } = await import('../knowledge-hits.js')
         appendKnowledgeHit(join(frSpecBase, '.runtime'), {
-          type: 'fr-inject', change: changeName, domains, count: entries.length,
+          type: 'fr-inject', change: changeName, domains, count: entries.length, source: 'digest',
         })
       } catch { /* 遥测 fail-soft */ }
     } catch (e) {
@@ -1069,7 +1371,10 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
 
   // Stage Review Tier：brainstorm/plan/execute 阶段注入审查分级占位符
   // （scanProfile 只在 scan 生效、change-risk-profile 只管 apply/verify，都不约束这些阶段的审查方式，
-  //  故按 plan_level / 变更文件数分级：self 当前 agent 自审，independent 强制独立子代理 + review.json）
+  //  故按 ceremony_tier 风险定价分级——2026-09-18-ceremony-risk-pricing task-05 起 plan_level 降级为
+  //  编排标签不再驱动仪式档：S0/S1 → self 轻仪，S2 → independent×1，S3 → independent 多轮；
+  //  {REVIEW_TIER} 注入值 = tier 值 + 追加 ceremony 档位菜单块（renderCeremonyTierInjection），
+  //  {REVIEW_TIER_REASON} 注入机制不动（reason 已含 ceremony 档与 blast 来源，task-02 契约））
   if (['brainstorm', 'plan', 'execute'].includes(stageName) && promptText.includes('{REVIEW_TIER}')) {
     try {
       const { classifyReviewTier } = await import('../review-tier.js')
@@ -1086,6 +1391,12 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
         }
       }
       const tier = classifyReviewTier({ planLevel, designPath })
+      // ceremony 档位菜单（第三消费面，task-05）：classifyReviewTier 双字段的 ceremonyTier 驱动
+      // 仪式档渲染；force_tier 逃生阀只升不降（升向强制 S2/S3 时注入 tier 值随调 independent，
+      // 与下方契约渲染/前序事实注入同用 effective 值，防 prompt 与注入块自相矛盾）
+      const ceremonyInjection = renderCeremonyTierInjection({
+        ceremonyTier: tier.ceremonyTier, tierValue: tier.tier, planLevel, cwd,
+      })
       // reviewRunId：优先读 marker 复用（保证多次渲染 prompt 注入同一 ID == gate 读取的 ID，
       // 修复「prompt 多次渲染 / 多次 review 时 gate 取错 ID 读错 review.json」），marker 缺失才
       // generate + 落盘。对齐 execute {EXECUTE_RUN_ID} 段（prompt.js:449-467）。
@@ -1112,13 +1423,13 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
       // process.cwd 兜底会读错 local.yaml，2026-09-10 通道配置批次）；tier=independent 时契约
       // 头部渲染「审查执行通道」段（按用户配置序，见 local.yaml review_dispatch.channel_priority）。
       const reviewChannelPriority = readReviewChannelPriority(cwd)
-      const reviewContractMd = renderReviewJsonContract({ stage: stageName, changeDir: tierChangeDir, reviewRunId, tier: tier.tier, channelPriority: reviewChannelPriority })
+      const reviewContractMd = renderReviewJsonContract({ stage: stageName, changeDir: tierChangeDir, reviewRunId, tier: ceremonyInjection.tierValue, channelPriority: reviewChannelPriority })
       // C2 前阶段实证清单机械附带（坑 review-subagent-redundant-verify，2026-09-15 wp EHS 实证：
       // plan 审查把 brainstorm 已两轮实证的三仓源码全量重验——94 分钟不收敛被用户三催。此前只有
       // prompt 散文说「前序实证勿重验」，子代理并不知道前序具体审过了什么；现把前序 stage review
       // 的 checklist pass 项机械注入派发 prompt（封顶 15 条防灌爆），审查子代理据此跳过已实证面。
       let priorFactsMd = ''
-      if (tier.tier === 'independent') {
+      if (ceremonyInjection.tierValue === 'independent') {
         try {
           const priorStages = stageName === 'plan' ? ['brainstorm'] : stageName === 'execute' ? ['brainstorm', 'plan'] : []
           const factLines = []
@@ -1147,18 +1458,32 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
       // 审过什么/报过什么）。骨架轮/他变更轮由采集端过滤；tier=self 不注入（当前 agent 自带
       // 上一轮上下文）。
       try {
-        const priorRound = collectSameStagePriorReview(tierRuntimeRoot, stageName, changeName)
+        const priorRound = await collectSameStagePriorReview(tierRuntimeRoot, stageName, changeName)
         if (priorRound) {
           const blockMd = renderPriorRoundFindingsMd(priorRound)
           priorFactsMd = priorFactsMd ? priorFactsMd + blockMd : blockMd
         }
       } catch {}
+      // {REVIEW_MATERIALS} 机械组装（2026-09-19-review-material-cli-wiring，Gap 1 收口）：CLI 半边
+      // 素材（designDigest/fileList/硬约束/diff 摘要/热区/checklist）经 assembleStageReviewMaterials
+      // 组包注入（specBase 用上方 tierSpecBase——块内唯一解析源，平台模式不漂）；主代理点名半边
+      // （五交叉点/plan 差量）留位，模板补位指引接手。占位符在场才组装（省无槽步骤的 git IO）；
+      // best-effort：失败空串（与占位符缺失同态，模板散文兜底）。
+      let reviewMaterialsMd = ''
+      if (promptText.includes('{REVIEW_MATERIALS}')) {
+        try {
+          const { assembleStageReviewMaterials } = await import('../review-material-pack.js')
+          const matStage = stageName === 'brainstorm' ? 'grill-first' : stageName === 'plan' ? 'plan-review' : 'execute-qa'
+          reviewMaterialsMd = await assembleStageReviewMaterials({ stage: matStage, cwd, changeName, specBase: tierSpecBase })
+        } catch { /* 组装 best-effort：失败零注入 */ }
+      }
       promptText = promptText
-        .split('{REVIEW_TIER}').join(tier.tier)
+        .split('{REVIEW_TIER}').join(ceremonyInjection.tierValue + ceremonyInjection.menuMd)
         .split('{REVIEW_TIER_REASON}').join(tier.reason)
         .split('{STAGE_REVIEW_RUN_ID}').join(reviewRunId)
         .split('{REVIEW_JSON_CONTRACT}').join(reviewContractMd)
         .split('{PRIOR_REVIEW_FACTS}').join(priorFactsMd)
+        .split('{REVIEW_MATERIALS}').join(reviewMaterialsMd) // 三阶段材料包槽（CLI 组装注入，Gap 1 收口——此前恒空串靠主代理手组，机械保证断一半；主代理点名半边由模板补位指引接手）
     } catch (e) {
       // 降级 self，避免 prompt 残留占位符
       promptText = promptText
@@ -1167,6 +1492,7 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
         .split('{STAGE_REVIEW_RUN_ID}').join('review-unknown')
         .split('{REVIEW_JSON_CONTRACT}').join('(review 契约注入失败,按 schemaVersion=1 + reviewType + verdicts∈pass/fail/cannot_verify + reviewedFiles + docHash=主文档 sha256 产出)')
         .split('{PRIOR_REVIEW_FACTS}').join('')
+        .split('{REVIEW_MATERIALS}').join('') // 降级分支同步 join（plan 审查提示：防占位符字面量残留）
     }
   }
 
@@ -1379,22 +1705,76 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
     promptText = promptText.split('{HANDOVER_SUMMARY}').join(handoverBlock)
   }
 
-  // 注入模块上下文（brainstorm/plan/execute 阶段全步 + quick 首步「理解任务」——刀①：quick
+  // 注入模块上下文（brainstorm/plan/execute 阶段 + quick 首步「理解任务」——刀①：quick
   // step1 原让 agent cat module-map 再挑模块卡读，改为按任务描述匹配后注入，基于 Module Context Index）
+  // ── 阶段感知注入分叉（2026-09-18-preflight-slimming task-02，D-002@v1 Phase 2）──
+  // 三主阶段由「每步全注」改「每阶段首步全量、后续摘要行」：shouldInjectFullContext（task-01）
+  // 读 .runtime/prompt-inject-<change>.json 账本判定——full=真注全量（现状）并在注入后
+  // recordPromptInjectLedger 落账（withFileLock 幂等，R-06）；full=假改注一行摘要（首步步骤号 +
+  // digest 前 8 位 + 可 Read 路径，R-03）。quick 不分叉：仅首步注入，本无重注面（现状逐字保留）。
+  // fail-open 红线（design 兼容策略）：分叉判定/账本读写任何异常 → 回退全量注入（现状），
+  // 绝不阻塞渲染。
   const quickFirstStep = stageName === 'quick' && step && step.name === '理解任务'
-  if ((['brainstorm', 'plan', 'execute'].includes(stageName) || quickFirstStep) && projectName) {
+  const mainStageModuleInject = ['brainstorm', 'plan', 'execute'].includes(stageName)
+  if ((mainStageModuleInject || quickFirstStep) && projectName) {
     const effectiveSpecBase = resolvePromptSpecBase(platformOpts, cwd)
     const moduleIndex = loadModuleContextIndex(effectiveSpecBase, projectName)
     if (moduleIndex && Object.keys(moduleIndex).length > 0) {
-      // 尝试从 step prompt / changeName 匹配模块；quick 用 guard.taskDescription（启动 --input）——
-      // changeName 是 quick-<hash> 无语义、step.prompt 全文噪音大（刀①）
-      let taskDesc = step.prompt || changeName || ''
-      if (stageName === 'quick') {
-        taskDesc = readQuickGuardField(changeName, effectiveSpecBase, 'taskDescription') || taskDesc
+      // runtimeRoot 与 {EXECUTE_RUN_ID}/{REVIEW_TIER} 段同源解析（resolveRuntimeRoot(platformOpts, specBase)）
+      let injectFork = { full: true } // 缺省=现状全量（quick / 无 changeName / 分叉判定异常）
+      if (mainStageModuleInject && changeName) {
+        try {
+          injectFork = shouldInjectFullContext({
+            changeName, stageName,
+            runtimeRoot: resolveRuntimeRoot(platformOpts, effectiveSpecBase),
+          })
+        } catch { injectFork = { full: true } } // fail-open：判定异常回退全量（现状）
       }
-      const injection = buildModuleContextInjection(taskDesc, moduleIndex, effectiveSpecBase, projectName)
-      if (injection) {
-        promptText = injection + '\n' + promptText
+      if (!injectFork.full) {
+        // 同阶段后续步骤：不重注全量，改摘要行（digest 前 8 位 + 可 Read 路径）
+        promptText = renderPromptInjectSummaryLine({
+          firstStep: injectFork.firstStep, digest: injectFork.digest,
+          specBase: effectiveSpecBase, projectName,
+        }) + '\n' + promptText
+      } else {
+        // 尝试从 step prompt / changeName 匹配模块；quick 用 guard.taskDescription（启动 --input）——
+        // changeName 是 quick-<hash> 无语义、step.prompt 全文噪音大（刀①）
+        let taskDesc = step.prompt || changeName || ''
+        if (stageName === 'quick') {
+          taskDesc = readQuickGuardField(changeName, effectiveSpecBase, 'taskDescription') || taskDesc
+        }
+        const injRes = buildModuleContextInjection(taskDesc, moduleIndex, effectiveSpecBase, projectName) || { text: '', frModules: [] }
+        const injection = injRes.text
+        if (injection) {
+          promptText = injection + '\n' + promptText
+          // fr-inject 遥测（module-inject 源，ql-20260919-002）：仅 count>0 模块发事件（防 jsonl
+          // 堆 count-0 噪音）；type 不变+source 归因（新 type 会静默漏过 knowledge-stats 的 if 链
+          // 缩水 D-006 总数——source 字段保口径）。与 step8 digest 侧可能对同一变更各发一次，
+          // frInjectChanges 按 change 去重不受双发影响。fail-soft。
+          if (injRes.frModules && injRes.frModules.length > 0 && changeName) {
+            try {
+              for (const fm of injRes.frModules) {
+                appendKnowledgeHit(join(effectiveSpecBase, '.runtime'), {
+                  type: 'fr-inject', change: changeName, domains: [fm.id], count: fm.count, source: 'module-inject',
+                })
+              }
+            } catch { /* 遥测 fail-soft */ }
+          }
+          // 首步全量注入后落账：本阶段首个非空注入即「首步」锚点（记 firstStep/digest/at——后续
+          // 步骤摘要行的判定输入）。只在真注入非空内容时落账——空注入不占首步位（防摘要行
+          // 「已于步骤 N 注入」指向一个实际没注入任何模块内容的步骤，丢真上下文）。fail-open：
+          // 落账异常静默（语义=后续步仍全量注入），绝不阻塞渲染。
+          if (mainStageModuleInject && changeName) {
+            try {
+              await recordPromptInjectLedger({
+                runtimeRoot: resolveRuntimeRoot(platformOpts, effectiveSpecBase),
+                changeName, stageName,
+                firstStep: stepIndex + 1,
+                digest: createHash('sha256').update(injection, 'utf8').digest('hex').slice(0, 8),
+              })
+            } catch { /* fail-open：账本写失败 → 后续步仍全量注入（现状），不阻塞渲染 */ }
+          }
+        }
       }
     }
   }
@@ -1478,6 +1858,28 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
     }
   }
 
+  // ── {PREFLIGHT_FAILURES} 前置失败清单接线（2026-09-18-preflight-slimming task-02，D-001@v1 Phase 1）──
+  // renderPreflightFailures（task-01 纯函数）从 stageRegistry 步骤定义读 preflightValidators
+  // 声明（三 stages 声明统一归 task-04）只读快跑本步骤 --done 将消费的 validator 子集：
+  // 未声明/无失败/超时/异常 → ''。注入位（计划锚点）：步骤说明之后、门禁提示（铁律/完成后
+  // 执行/gate 预检）之前——非空且模板无字面占位符时追加到 promptText 末尾；模板含字面
+  // {PREFLIGHT_FAILURES} 时按既有占位符替换机制原位替换（空串替换零残留——「空串时占位符
+  // 零出现」）。空串零注入：声明落地（task-04）前恒 ''——旧 prompt 逐字节不变（design 兼容
+  // 策略第一条，knowledge-inject A/B 双渲染字节一致金丝雀守护）。接线层再包一层 try：
+  // 任何异常静默不注不阻（fail-open 注入面，plan 全局硬约束 2）。
+  let preflightFailuresMd = ''
+  try {
+    const pfSpecBase = resolvePromptSpecBase(platformOpts, cwd)
+    preflightFailuresMd = await renderPreflightFailures({
+      stageName, stepName: step.name, cwd, specBase: pfSpecBase, changeName,
+    })
+  } catch { preflightFailuresMd = '' }
+  if (promptText.includes('{PREFLIGHT_FAILURES}')) {
+    promptText = promptText.split('{PREFLIGHT_FAILURES}').join(preflightFailuresMd)
+  } else if (preflightFailuresMd) {
+    promptText = `${promptText}\n\n${preflightFailuresMd}`
+  }
+
   console.log(promptText)
   // 铁律拆分（W3 token 效率）：通用流程纪律（文档优先/不跳步/不编造命令）只在首个 agent 可见步注入——
   // 每步重复 ~800B 纯耗 context。但【平台写入规则 + 路径规则】是安全关键（防写错目录/绕过 Write），

package/src/run/shared.js

@@ -23,6 +23,7 @@ import { createHash } from 'node:crypto'
 // 分级门禁画像信号层（2026-09-14-quick-exit-tiered-gates task-01 / FR-02）：纯函数零 IO，
 // 仅依赖 change-risk-profile，无环——auditQuickCompletion 静态 import 安全（task-02 接线）。
 import { computeGateProfile, resolveGateThresholds } from '../quick-gate-profile.js'
+import { loadSpanRiskPatterns } from '../span-risk-surface.js'
 export { safeGit, unquoteGitPath }
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
@@ -1771,10 +1772,15 @@ export async function auditQuickCompletion(cwd, guard, options = {}) {
         } catch { /* 坏 YAML → 纯默认阈值 */ }
       }
       const gateFiles = result.changedFiles.filter(f => !isQuicklogFileLineNoise(f, guard.linkedChanges))
+      // span 声明面装载（2026-09-19-span-risk-pattern-migration task-03）：与 loadQuickModuleIndex 同
+      // specBase/projectName 上下文（_module-map.yaml 顶层 span_risk 段）→ gateOpts.riskTable；
+      // 无声明项目 → 空表（riskTable 已默认 []，此处显式装载与其他声明面入参同风格，D-003）
+      const riskTable = loadSpanRiskPatterns({ specBase, project: projectName })
       const gateOpts = {
         ...(thresholds ? { thresholds } : {}),
         ...(noDocs ? { noDocs: true } : {}),
         ...(Array.isArray(fileNotes) && fileNotes.length > 0 ? { fileNotes } : {}),
+        riskTable,
       }
       const moduleIndex = await loadQuickModuleIndex(specBase, projectName)
       result.gateProfile = computeGateProfile(gateFiles, moduleIndex, gateOpts)
@@ -1783,6 +1789,36 @@ export async function auditQuickCompletion(cwd, guard, options = {}) {
         const attrGateFiles = gateFiles.filter(f => !undeclaredNorm.has(String(f).replace(/\\/g, '/')))
         result.gateProfile.checks.docClaim = computeGateProfile(attrGateFiles, moduleIndex, gateOpts).checks.docClaim
       }
+      // ── FR 写面腐烂 suspect 遥测（钩子 #1，L3 裁决数据，advisory 零阻断）──
+      // quick 永不归档 → FR 索引对 quick 改动无感知（L1 显式划出覆盖面），改掉 FR 覆盖行为后
+      // 条目仍标 active——账本从 quick 路径腐烂且今天完全不可见。此钩子把它量出来：changedFiles
+      // 经 moduleIndex 路径匹配得触达域（与 computeGateProfile 同 join），域内有 active FR 即记
+      // fr-rot-suspect 事件+一行 warn（只提醒不阻断——看得见约束≠声明取代，L3 才有裁决权）。
+      // 盲区预登（评审要求）：①unmapped 文件静默漏 join（新路径未录 map 即无信号）②map 文件
+      // 清单自身漂移——**无信号 ≠ 无腐烂**。fail-open：异常跳过不碰审计结论。
+      try {
+        const { readActiveFrDigest } = await import('../fr-index.js')
+        const { appendKnowledgeHit } = await import('../knowledge-hits.js')
+        const gateFilesNorm = gateFiles.map(f => String(f).replace(/\\/g, '/'))
+        const touchedDomains = new Set()
+        for (const [modId, mod] of Object.entries(moduleIndex || {})) {
+          const prefixes = [...(mod && Array.isArray(mod.paths) ? mod.paths : []), ...(mod && Array.isArray(mod.core_files) ? mod.core_files : [])]
+          for (const raw of prefixes) {
+            const p = String(raw).replace(/\\/g, '/').replace(/\/+$/, '')
+            if (p && gateFilesNorm.some(f => f === p || f.startsWith(p + '/'))) { touchedDomains.add(modId); break }
+          }
+        }
+        if (touchedDomains.size > 0) {
+          const frs = readActiveFrDigest(join(specBase, 'knowledge'), [...touchedDomains])
+          if (frs.length > 0) {
+            appendKnowledgeHit(join(specBase, '.runtime'), {
+              type: 'fr-rot-suspect', change: guard.changeName || null,
+              domains: [...touchedDomains], count: frs.length, source: 'quick-done',
+            })
+            console.warn(`⚠️ [FR 腐烂 suspect·advisory] 本次 quick 触达 ${[...touchedDomains].join('、')} 域的 ${frs.length} 条 active FR——quick 不走归档，若改动影响这些行为，索引不会自动 supersede（L3 声明义务；盲区：unmapped 文件/map 漂移不报警）`)
+          }
+        }
+      } catch { /* fail-open：遥测异常不影响审计 */ }
     } catch { /* 画像 fail-open：异常只跳过（gateProfile 保持 null，D-003 不碰 status） */ }
 
     // --confirm 模式：展示 diff 并等待确认