sillyspec 3.31.0 → 3.32.0

package/src/foreign-declared.js

@@ -202,6 +202,70 @@ function loadOwnDeclaredSet(specBase, runtimeRoot, currentChangeName) {
   return set
 }
 
+/**
+ * 提交标题 → 变更名数组（2026-10-05-diff-commit-attribution）：项目提交惯例 message 尾部
+ * 携带 "(2026-MM-DD-名)" 后缀（多变更并列各自提取；归档提交 chore(archive): <名> 的标题
+ * 首部同名形态不提取——归档提交触碰的是治理面移动，交付文件归属看交付提交）。
+ */
+export function parseChangeNamesFromSubject(subject) {
+  const out = []
+  const re = /\((\d{4}-\d{2}-\d{2}-[A-Za-z0-9._-]+)\)/g
+  let m
+  while ((m = re.exec(String(subject || '')))) out.push(m[1])
+  return out
+}
+
+/**
+ * git log 文本（--format=%x00%s --name-only，每提交 NUL+标题+文件行）→ 文件提交归属映射。
+ * 每文件聚合：owners=触碰过它的全部提交携带的变更名；unknown=被无变更名裸提交触碰过
+ * （归属不明，消费端必须保守保留——fail-closed 不因裸提交剔文件）。
+ */
+export function buildCommitAttribution(logText) {
+  const map = new Map()
+  for (const block of String(logText || '').split('\x00')) {
+    const lines = block.split('\n').map((l) => l.trim()).filter(Boolean)
+    if (lines.length === 0) continue
+    const names = parseChangeNamesFromSubject(lines[0])
+    for (const f of lines.slice(1)) {
+      const file = f.replace(/\\/g, '/')
+      let e = map.get(file)
+      if (!e) { e = { owners: new Set(), unknown: false }; map.set(file, e) }
+      if (names.length === 0) e.unknown = true
+      else for (const n of names) e.owners.add(n)
+    }
+  }
+  return map
+}
+
+/**
+ * 提交事实归属切分（2026-10-05-diff-commit-attribution）：声明面（collectForeignDeclaredFiles
+ * ②扫描）对已归档他侧变更不可见——他会话在 baseline..HEAD 窗口内交付并归档后目录进
+ * archive/（「archive/ 下不算」），其文件漏归本变更 → patch 冻结面夹带 + FR 域路由触达
+ * 他侧域（双 P1 实证）。按提交 message 变更名归属是已发生的提交事实，不是声明抢文件——
+ * 不触碰否决决策 sentinel-evidence-freeze⑤（其禁的是陈旧声明的意图抢夺）。
+ * baseline 自取：opts.baselineCommit 优先，缺省读当前变更 flow-state.yaml（调用点零改动）。
+ * @returns {Map|null} null=不可得（非 git 仓/无 baseline/git 失败）——消费端退化现状。
+ */
+export function commitAttributionForChange(cwd, specBase, currentChangeName, baselineCommit) {
+  try {
+    let base = baselineCommit || null
+    if (!base && currentChangeName) {
+      const st = readFileSync(join(specBase, 'changes', currentChangeName, 'flow-state.yaml'), 'utf8')
+      const m = /^baseline_commit:\s*(\S+)/m.exec(st)
+      if (m) base = m[1]
+    }
+    if (!base) return null
+    const r = safeGit(cwd, ['log', '--name-only', '--format=%x00%s', `${base}..HEAD`], { trim: false })
+    if (r.value === null) return null
+    return buildCommitAttribution(r.value)
+  } catch { return null }
+}
+
+/** 纯他侧文件判定：有提交归属且全部提交均属他侧（无本变更名、无裸提交触碰）。 */
+export function isForeignByCommit(entry, currentChangeName) {
+  return !!entry && !entry.unknown && entry.owners.size > 0 && !entry.owners.has(currentChangeName)
+}
+
 /**
  * 按他者声明集切分 diff 文件（collectForeignDeclaredFiles 的消费端快捷封装）。
  *
@@ -214,7 +278,7 @@ function loadOwnDeclaredSet(specBase, runtimeRoot, currentChangeName) {
  * @param {string} cwd 项目根
  * @param {string|null} currentChangeName 本变更名
  * @param {string[]|null} diffFiles 待切分文件列表（null 透传，保持调用方 null 语义）
- * @param {{ specBase?: string, runtimeRoot?: string }} [opts] 平台模式路径（透传 collectForeignDeclaredFiles）
+ * @param {{ specBase?: string, runtimeRoot?: string, baselineCommit?: string }} [opts] 平台模式路径（透传 collectForeignDeclaredFiles）+ 显式 baseline（缺省自取 flow-state）
  * @returns {{ own: string[]|null, foreign: Array<{file: string, owners: string[]}> }}
  */
 export function splitOwnVsForeignDiffFiles(cwd, currentChangeName, diffFiles, opts = {}) {
@@ -222,7 +286,9 @@ export function splitOwnVsForeignDiffFiles(cwd, currentChangeName, diffFiles, op
   const specBase = opts.specBase || join(cwd, '.sillyspec')
   const runtimeRoot = opts.runtimeRoot || join(specBase, '.runtime')
   const foreignMap = collectForeignDeclaredFiles(cwd, currentChangeName, { specBase, runtimeRoot })
-  if (foreignMap.size === 0) return { own: diffFiles, foreign: [] }
+  // 提交事实归属补位（声明面归档盲区）：优先级 ownDeclared > 声明面 foreign > 提交归属 foreign > own
+  const commitAttr = commitAttributionForChange(cwd, specBase, currentChangeName, opts.baselineCommit)
+  if (foreignMap.size === 0 && !commitAttr) return { own: diffFiles, foreign: [] }
   const ownDeclared = loadOwnDeclaredSet(specBase, runtimeRoot, currentChangeName)
   const own = []
   const foreign = []
@@ -230,7 +296,9 @@ export function splitOwnVsForeignDiffFiles(cwd, currentChangeName, diffFiles, op
     const n = String(f).replace(/\\/g, '/')
     if (ownDeclared.size > 0 && ownDeclared.has(n)) { own.push(f); continue } // own 优先
     const owners = foreignMap.get(n)
-    if (owners) foreign.push({ file: f, owners })
+    if (owners) { foreign.push({ file: f, owners }); continue }
+    const ce = commitAttr ? commitAttr.get(n) : null
+    if (isForeignByCommit(ce, currentChangeName)) foreign.push({ file: f, owners: [...ce.owners] })
     else own.push(f)
   }
   return { own, foreign }

package/src/fr-index.js

@@ -18,7 +18,7 @@
  */
 
 import { readChangeTrace, upsertFrBindings, applySupersededToEntryLines, testAnchorFile, resolveTestFileRel } from './test-bindings.js'
-import { suggestDomainFromFiles } from './knowledge-digest.js'
+import { suggestDomainFromFiles, snapDomainToDictionary } from './knowledge-digest.js'
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'fs';
 import { basename, dirname, join } from 'path';
 import { writeAtomicSync } from './fs-atomic.js';
@@ -79,7 +79,7 @@ export function frCoverageFiles({ archiveRoot, changeName }) {
 /** 条目「测试绑定：」子块的 tests 文件提取（多文件 | 分隔）。边界=下一个 ## 节头（FR 节）——
  * 子块内顶格的 `<!-- test-bindings -->` 机器注释与 `- row:` 行不终止收集（评审 P1 修复：
  * 原「任意顶格行 break」遇子块首行顶格注释即断，生产库 bindings 恒空；缩进 tests: 键名 +
- * 节头边界已足够防条目正文误匹配）。readActiveFrDigest.bindings 与 cleanupStaleReviewMarks 共用。 */
+ * 节头边界已足够防条目正文误匹配）。readActiveFrDigest.bindings 与 activeFrCoverageHits 共用。 */
 function readEntryBindings(lines) {
   const idx = lines.findIndex((l) => l.startsWith('测试绑定：'));
   if (idx === -1) return [];
@@ -229,18 +229,26 @@ export function parseChangeRequirements(changeDir) {
  * unmapped 大池且 INDEX 路由键为通用词无法命中，模块卡覆盖不足时 FR 复利断路）；无文件清单 → unmapped。
  * filesOverride（2026-09-22-thin-fr-distill-sync）：显式交付文件清单旁路 design.md 解析——轻量变更
  * 变更无 design.md（轻量工件面三件套），flow done 以基线以来交付 diff 供清单，伪域路由同口径。 */
-export function resolveTouchedDomains(changeDir, moduleIndex, filesOverride = null) {
+/** 路径 ↔ 模块匹配规则（精确或目录前缀）——resolveTouchedDomains 域路由与 flow start 在场
+ * 过滤（坑 module-map-list-leak）共用同一判定的单一来源。@returns {string[]} 命中模块 id */
+export function matchedModuleIds(moduleIndex, filePath) {
+  if (!moduleIndex) return [];
+  const hits = [];
+  for (const [modId, mod] of Object.entries(moduleIndex)) {
+    const paths = (mod && Array.isArray(mod.paths)) ? mod.paths : [];
+    if (paths.some((pp) => filePath === pp || filePath.startsWith(pp.endsWith('/') ? pp : pp + '/'))) {
+      hits.push(modId);
+    }
+  }
+  return hits;
+}
+
+export function resolveTouchedDomains(changeDir, moduleIndex, filesOverride = null, knowledgeRoot = null) {
   const domains = new Set();
   const designPath = join(changeDir, 'design.md');
   const files = [];
   const matchModules = (filePath) => {
-    if (!moduleIndex) return;
-    for (const [modId, mod] of Object.entries(moduleIndex)) {
-      const paths = (mod && Array.isArray(mod.paths)) ? mod.paths : [];
-      if (paths.some((pp) => filePath === pp || filePath.startsWith(pp.endsWith('/') ? pp : pp + '/'))) {
-        domains.add(modId);
-      }
-    }
+    for (const modId of matchedModuleIds(moduleIndex, filePath)) domains.add(modId);
   };
   if (Array.isArray(filesOverride)) {
     for (const f of filesOverride) {
@@ -261,7 +269,9 @@ export function resolveTouchedDomains(changeDir, moduleIndex, filesOverride = nu
       matchModules(filePath);
     }
   }
-  if (domains.size === 0) domains.add(files.length > 0 ? pseudoDomainFromPaths(files) : 'unmapped');
+  // 伪域铸造过词典守卫（坑 fr-domain-suggest-typo-and-no-split-migration 缺陷1：路径段投票产出
+  // 拼写漂移段时吸附既有域，杜绝 auto-rontend 类伪域凭空出生；knowledgeRoot 缺席=无词典不干预）。
+  if (domains.size === 0) domains.add(files.length > 0 ? pseudoDomainFromPaths(files, knowledgeRoot) : 'unmapped');
   return [...domains];
 }
 
@@ -273,7 +283,7 @@ const GENERIC_PATH_SEGMENTS = new Set(['src', 'lib', 'test', 'tests', 'spec', 'd
  * 按出现次数投票取众数；全部泛化/根文件 → 'unmapped'。auto- 前缀保证与真实模块 id
  * （模块卡派生）不冲突，且在 fr 文件头与 INDEX 路由键里自明身份。
  */
-function pseudoDomainFromPaths(files) {
+function pseudoDomainFromPaths(files, knowledgeRoot = null) {
   const votes = new Map();
   for (const f of files) {
     const segs = String(f || '').replace(/\\/g, '/').split('/').filter(Boolean);
@@ -287,6 +297,10 @@ function pseudoDomainFromPaths(files) {
   }
   if (votes.size === 0) return 'unmapped';
   const top = [...votes.entries()].sort((a, b) => b[1] - a[1])[0][0];
+  // 词典守卫（坑 fr-domain-suggest 缺陷1）：top 与既有域编辑距离 ≤1 → 直接落既有域
+  //（fr/<既有域>.md 已在场，条目并入真域而非另铸 auto- 拼写漂移壳）；远距离=绿地新模块照旧。
+  const snapped = snapDomainToDictionary(top, { knowledgeRoot });
+  if (snapped) return snapped;
   return `auto-${top}`;
 }
 
@@ -333,6 +347,9 @@ function renderFrLines(entry, headHash) {
   // （design 接口定义示例中的「来源变更」即本字段，语义等价，取解析器认的字面）
   lines.push(`变更：${entry.change}`);
   lines.push(`状态：${entry.supersededBy ? 'superseded' : 'active'}`);
+  // 骨架标记（2026-10-03-fr-skeleton-gate）：纯骨架条目（全部场景体 Then=flow-draft 占位句）
+  // 落「骨架：thin」——注入面据此排除（TierA 覆盖命中例外）；查重/rot/绑定面不受影响。
+  if (entry.skeleton) lines.push('骨架：thin');
   if (entry.supersededBy) lines.push(`superseded_by：${entry.supersededBy}`);
   if (entry.supersededOf) lines.push(`取代链：${entry.supersededOf} ← 本条目（${entry.change} 承接）`);
   lines.push(`摘要：${(entry.scenarios || []).slice(0, 5).join('；') || '（无场景名）'}`);
@@ -414,7 +431,7 @@ export function indexRequirements({ changeDir, knowledgeRoot, headHash = '', del
 
   const warnings = [...parsed.malformed];
   const moduleIndex = discoverModuleIndex(knowledgeRoot);
-  const domains = resolveTouchedDomains(changeDir, moduleIndex, deliverableFiles);
+  const domains = resolveTouchedDomains(changeDir, moduleIndex, deliverableFiles, knowledgeRoot);
   const all = scanAllDomains(knowledgeRoot);
 
   // 幂等闸门：任一域文件已有本变更「来源变更」条目 → 全量 no-op（同变更重跑零新增零漂移）
@@ -456,7 +473,7 @@ export function indexRequirements({ changeDir, knowledgeRoot, headHash = '', del
       id,
       title: fr.title,
       change: changeName,
-      lines: renderFrLines({ id, title: fr.title, change: changeName, scenarios: fr.scenarios, decisions: fr.decisions, scenarioBodies: fr.scenarioBodies, local: fr.local }, headHash),
+      lines: renderFrLines({ id, title: fr.title, change: changeName, scenarios: fr.scenarios, decisions: fr.decisions, scenarioBodies: fr.scenarioBodies, local: fr.local, skeleton: isThinSkeletonBodies(fr.scenarioBodies) }, headHash),
     });
     dirtyDomains.add(primaryDomain);
     written.push({ file: `${FR_DIR}/${primaryDomain}.md`, id, action: 'added' });
@@ -467,11 +484,9 @@ export function indexRequirements({ changeDir, knowledgeRoot, headHash = '', del
         const target = st2.sections.find((s) => s.number === refId && !s.lines.some((l) => l.startsWith('superseded_by：')));
         if (!target) continue;
         // 就地补丁：状态翻 superseded + 插 superseded_by + 追取代链注记 + 刷新最近确认（摘要/标题保留）
-        // 待复核行随承接清除（2026-09-20-quick-asset-tail D-003：quick 触达留下的 needs_review 信号
-        // 在条目被正式承接取代时一并清——取代即复核完成，语义自然闭环）
         target.lines = target.lines
           .map((l) => (l.startsWith('状态：') ? `状态：superseded` : l.startsWith('最近确认：') ? `最近确认：${headHash || ''}` : l))
-          .filter((l) => !l.startsWith('superseded_by：') && !l.startsWith('取代链：') && !l.startsWith('退役理由：') && !l.startsWith('待复核：'));
+          .filter((l) => !l.startsWith('superseded_by：') && !l.startsWith('取代链：') && !l.startsWith('退役理由：'));
         const stateIdx = target.lines.findIndex((l) => l.startsWith('状态：'));
         // 退役理由（追平刀②）：承接令牌带（退役理由：…）时写进被取代条目——对标 OpenSpec REMOVED
         // 的 Migration 语义；无理由则省略行（不伪造）。
@@ -522,8 +537,10 @@ export function indexRequirements({ changeDir, knowledgeRoot, headHash = '', del
       .filter((s) => !s.lines.some((l) => l.startsWith('superseded_by：')))
       .map((s) => s.number)
       .filter((n) => n && !written.some((w) => w.id === n));
-    const count = activeIds.filter((id) => !refIds.has(id)).length;
-    if (count > 0) unreferenced.push({ domain, count });
+    const unreferencedIds = activeIds.filter((id) => !refIds.has(id));
+    // ids（2026-10-03-fr-governance-telemetry）：条目级信号帽 20——archive-distill 透传进事件，
+    // stats 裁决候选视图按 id 聚合（域级计数保留兼容）。
+    if (unreferencedIds.length > 0) unreferenced.push({ domain, count: unreferencedIds.length, ids: unreferencedIds.slice(0, 20) });
   }
 
   // 落盘（dirty 集=新条目域 ∪ 翻链命中域——R1 审查阻断②：漏翻链域会返回值谎报成功但盘上丢失）
@@ -576,7 +593,7 @@ export function indexRequirements({ changeDir, knowledgeRoot, headHash = '', del
     if (pseudoHits.length > 0) {
       // 落域机械改进（2026-09-27-knowledge-digest）：伪域告警附交付路径推导的建议域——
       // 归档时转达人工 1 秒确认（建议器与 digest 信号卡共用 suggestDomainFromFiles 单源）
-      const suggested = suggestDomainFromFiles(deliverableFiles || [])
+      const suggested = suggestDomainFromFiles(deliverableFiles || [], { knowledgeRoot })
       console.warn(`⚠️ [FR 域路由降级] 本变更 ${pseudoHits.length} 条 FR 落伪域/unmapped（${[...new Set(pseudoHits.map((w) => w.file))].join('、')}）${suggested ? `——按交付路径建议域：${suggested}（确认后可迁移；` : '（'}补模块卡（docs/<项目>/modules/_module-map.yaml 登记该目录）后，新变更将自动落回真域；绿地仓可跑 sillyspec run scan 校准）`)
       if (suggested) console.warn(`   迁移/存量清单：sillyspec knowledge digest（伪域信号卡）`)
     }
@@ -775,22 +792,118 @@ export function readActiveFrDigest(knowledgeRoot, domains) {
       const decisionLine = s.lines.find((l) => l.startsWith('依据决策：'));
       const decisions = decisionLine ? decisionLine.replace(/^依据决策：s*/, '').split('、').map((x) => x.trim()).filter(Boolean) : [];
       const scenarios = scenarioLine ? scenarioLine.replace(/^摘要：\s*/, '').split('；').map((x) => x.trim()).filter(Boolean) : [];
-      // 待复核标记透传（2026-09-20-quick-asset-tail FR-02）：quick 触达留下的信号，
-      // 注入面带 ⚠️ 提示后续变更核对——是信号非失效，承接翻链时清除。
-      const reviewLine = s.lines.find((l) => l.startsWith('待复核：'));
-      const needsReview = reviewLine ? reviewLine.replace(/^待复核：\s*/, '').trim() : null;
+      // 骨架位（2026-10-03-fr-skeleton-gate）：「骨架：thin」行在场 → skeleton=true——纯增量字段，
+      // 注入面消费（TierA 例外）；查重/rot/绑定消费方不读此位照旧。
+      const skeleton = s.lines.some((l) => l.startsWith('骨架：thin'));
       // bindings（fr-rot-precision）：条目测试绑定的 test 文件——rot coverage 三源之一；纯新增
       // 字段，既有消费方（prompt.js 注入渲染等）不受影响。
-      out.push({ domain, id: s.number, title: s.title || '', change: s.change || '', scenarios, decisions, needsReview, bindings: readEntryBindings(s.lines), unconfirmed: readEntryUnconfirmed(s.lines) });
+      out.push({ domain, id: s.number, title: s.title || '', change: s.change || '', scenarios, decisions, bindings: readEntryBindings(s.lines), unconfirmed: readEntryUnconfirmed(s.lines), skeleton });
     }
   }
   return out;
 }
 
+// ── 骨架信息量门（2026-10-03-fr-skeleton-gate）─────────────────────────────────────
+// 薄道机器预填的空 GWT 骨架（When=标题回显、Then=占位句）永久入索引，挤占注入席位——
+// 判据锚定 flow-draft 占位句字面量，标记（骨架：thin）+ 存量回填 + 注入面排除（TierA 例外）。
+// 只装阀门不删数据：查重/rot/测试绑定/承接面零改动。
+
+/** flow-draft draftGwtSkeleton 的 Then 兜底占位句（字面量锚点——判据与起草端同源防漂移）。 */
+export const SKELETON_THEN_PLACEHOLDER = '行为符合本条标准描述';
+
+/** 纯骨架判据：全部场景体的 Then 均为占位句 → true；任一实质 Then 或无场景体 → false
+ *  （保守，宁漏勿误杀：误标只影响注入可见性，漏标只是继续占席）。 */
+export function isThinSkeletonBodies(scenarioBodies) {
+  const bodies = (Array.isArray(scenarioBodies) ? scenarioBodies : []).filter((b) => b && (b.given || b.when || b.then))
+  if (bodies.length === 0) return false
+  return bodies.every((b) => String(b.then || '').trim() === SKELETON_THEN_PLACEHOLDER)
+}
+
+/** 条目 场景正文 行的 Then 段提取（lastIndexOf——When 文本含「Then」字样不误切）。 */
+function scenarioLineThen(line) {
+  const i = line.lastIndexOf('Then ')
+  return i < 0 ? null : line.slice(i + 5).trim()
+}
+
+/** 存量回填（幂等）：全域扫描，纯骨架（场景正文行的 Then 全为占位句）且未标 → 状态行后插
+ *  「骨架：thin」。已有标记/非骨架/无场景体零变更；二次执行零写盘。
+ *  @returns {{ marked: Array<{domain,id}>, files: string[] }} */
+export function markSkeletonThin(knowledgeRoot) {
+  const marked = []
+  const files = []
+  const all = scanAllDomains(knowledgeRoot)
+  for (const [domain, st] of all.entries()) {
+    if (!st.sections || st.sections.length === 0) continue
+    let dirty = false
+    for (const s of st.sections) {
+      if (s.lines.some((l) => l.startsWith('骨架：thin'))) continue
+      const scenarioLines = s.lines.filter((l) => l.startsWith('- 场景：'))
+      if (scenarioLines.length === 0) continue
+      if (!scenarioLines.every((l) => scenarioLineThen(l) === SKELETON_THEN_PLACEHOLDER)) continue
+      const stateIdx = s.lines.findIndex((l) => l.startsWith('状态：'))
+      if (stateIdx < 0) continue
+      s.lines.splice(stateIdx + 1, 0, '骨架：thin')
+      dirty = true
+      marked.push({ domain, id: s.number || s.id })
+    }
+    if (dirty) {
+      writeFileSync(join(frDirPath(knowledgeRoot), `${domain}.md`), joinKnowledgeFile(st.preamble, st.sections))
+      files.push(`${FR_DIR}/${domain}.md`)
+    }
+  }
+  return { marked, files }
+}
+
 // ── active FR 覆盖命中查询（2026-09-26-dynamic-test-inference）─────────────────────
-// 查询核单源双消费：flow 侧 rotSuspectFlow 打待复核标记（信号面）；verify 侧
-// collectFrLinkedTests 反用为「需求关联回归测试面」（测试门三源之二）。覆盖判定与
-// rot 完全同口径：来源变更 patch 文件 ∪ 绑定 tests（剥用例锚）∩ 本次触碰文件 ≠ ∅。
+// 查询核单源双消费：flow 侧 rotSuspectFlow 出收口 advisory 与遥测（信号面）；verify 侧
+// collectFrLinkedTests 反用为「需求关联回归测试面」（测试门三源之二）；2026-10-03 起
+// rankFrDigestForInjection 作第三消费方（注入排序 TierA）。覆盖判定与 rot 完全同口径：
+// 来源变更 patch 文件 ∪ 绑定 tests（剥用例锚）∩ 本次触碰文件 ≠ ∅。
+
+/** 覆盖三分判定（2026-10-03-fr-inject-relevance-rank 自 activeFrCoverageHits 抽取）：
+ *  active FR × 触碰文件 → hits（覆盖相交）/ skip（覆盖可判无交集）/ unknown（覆盖源缺失）。
+ *  判据逐字不变——三消费方（rot/测试门/注入排序）共用同一实现，防口径漂移。
+ *  covCache 供调用方跨查询复用归档读取。 */
+function partitionActiveByCoverage({ archiveRoot, frs, changed, covCache = new Map() }) {
+  const hits = []
+  const unknownSources = new Set()
+  let skip = 0
+  let unknownFrCount = 0
+  for (const f of frs) {
+    if (!covCache.has(f.change)) covCache.set(f.change, frCoverageFiles({ archiveRoot, changeName: f.change }))
+    // bindings 可携带用例锚（2026-09-26-binding-anchor-fidelity）——覆盖判定按文件面取值走剥锚
+    const cov = new Set([...(covCache.get(f.change) || []), ...(Array.isArray(f.bindings) ? f.bindings.map((b) => testAnchorFile(b)) : [])])
+    if (cov.size === 0) { unknownSources.add(f.change || '（无来源变更）'); unknownFrCount++; continue }
+    const hit = [...cov].some((p) => changed.some((c) => c === p || c.startsWith(p.endsWith('/') ? p : p + '/')))
+    if (hit) hits.push({ domain: f.domain, id: f.id, title: f.title, change: f.change, bindings: f.bindings || [], coverage: cov })
+    else skip++
+  }
+  return { hits, skip, unknownFrCount, unknownSources: [...unknownSources] }
+}
+
+/**
+ * 注入排序（2026-10-03-fr-inject-relevance-rank）：取代「文件序前 N」——域增长后注入面恒为
+ * 每域最老 N 条，新立规格与覆盖命中的老规格均不可见（平台 backend 域 480 条实证：9 月新立
+ * 455 条永不出现在注入里）。两档：TierA=覆盖命中（partitionActiveByCoverage 同口径）置前；
+ * TierB=其余按来源变更日期新→旧（`变更：` 字段 YYYY-MM-DD 前缀；无日期/异形来源居尾——存量
+ * 43 条非日期形态实证）；同档 tie-break 全局 id 升序。纯排序不删条目，cap/指针行由消费方裁。
+ * @returns {{ ranked: Array, tierAIds: Set<string> }}
+ */
+export function rankFrDigestForInjection({ archiveRoot, frs, changed = [], covCache = new Map() }) {
+  const normalized = (Array.isArray(changed) ? changed : []).map((f) => String(f || '').replace(/\\/g, '/')).filter(Boolean)
+  const { hits } = partitionActiveByCoverage({ archiveRoot, frs, changed: normalized, covCache })
+  const tierAIds = new Set(hits.map((h) => h.id))
+  const dateOf = (f) => { const m = /^(\d{4}-\d{2}-\d{2})/.exec(String(f.change || '')); return m ? m[1] : '' }
+  const byRecency = (a, b) => {
+    const da = dateOf(a)
+    const db = dateOf(b)
+    if (da !== db) return da < db ? 1 : -1 // 日期新→旧；空串（无日期）居尾
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0
+  }
+  const tierA = frs.filter((f) => tierAIds.has(f.id)).sort(byRecency)
+  const tierB = frs.filter((f) => !tierAIds.has(f.id)).sort(byRecency)
+  return { ranked: [...tierA, ...tierB], tierAIds }
+}
 
 /**
  * 触达域内 active FR 的强命中集。
@@ -803,25 +916,12 @@ export function activeFrCoverageHits({ specBase, change = null, changeDir = null
   const moduleIndex = discoverModuleIndex(knowledgeRoot)
   const changed = (Array.isArray(files) ? files : []).map((f) => String(f || '').replace(/\\/g, '/')).filter(Boolean)
   // changeDir 仅为 design.md 兜底路由用（files 在场时不读）；不可传 null——resolveTouchedDomains 无条件 join
-  const domains = resolveTouchedDomains(changeDir || join(specBase, 'changes', String(change || 'x')), moduleIndex, changed).filter((d) => d !== 'unmapped')
+  const domains = resolveTouchedDomains(changeDir || join(specBase, 'changes', String(change || 'x')), moduleIndex, changed, knowledgeRoot).filter((d) => d !== 'unmapped')
   if (domains.length === 0) return { domains: [], hits: [], unknownSources: [] }
   const frs = readActiveFrDigest(knowledgeRoot, domains)
   if (frs.length === 0) return { domains, hits: [], unknownSources: [] }
-  const hits = []
-  const unknownSources = new Set()
-  const covCache = new Map()
-  let skip = 0
-  let unknownFrCount = 0
-  for (const f of frs) {
-    if (!covCache.has(f.change)) covCache.set(f.change, frCoverageFiles({ archiveRoot, changeName: f.change }))
-    // bindings 可携带用例锚（2026-09-26-binding-anchor-fidelity）——覆盖判定按文件面取值走剥锚
-    const cov = new Set([...(covCache.get(f.change) || []), ...(Array.isArray(f.bindings) ? f.bindings.map((b) => testAnchorFile(b)) : [])])
-    if (cov.size === 0) { unknownSources.add(f.change || '（无来源变更）'); unknownFrCount++; continue }
-    const hit = [...cov].some((p) => changed.some((c) => c === p || c.startsWith(p.endsWith('/') ? p : p + '/')))
-    if (hit) hits.push({ domain: f.domain, id: f.id, title: f.title, change: f.change, bindings: f.bindings || [], coverage: cov })
-    else skip++
-  }
-  return { domains, hits, unknownSources: [...unknownSources], unknownFrCount, skip, total: frs.length }
+  const { hits, skip, unknownFrCount, unknownSources } = partitionActiveByCoverage({ archiveRoot, frs, changed })
+  return { domains, hits, unknownSources, unknownFrCount, skip, total: frs.length }
 }
 
 /**
@@ -871,55 +971,10 @@ export function frTitleOverlap(a, b) {
   return inter / (A.size + B.size - inter);
 }
 
-// ── needs_review 标记（2026-09-20-quick-asset-tail，D-003：信号非门禁）─────────────
-
-/** 待复核行前缀（机械解析契约：digest 按此前缀读，条目可多轮标记仅保最新一条）。 */
-const FR_NEEDS_REVIEW_PREFIX = '待复核：';
-
-/**
- * quick 触达域后给 active FR 条目打待复核标记（钩子#1 升级：遥测之外让地图本身诚实）。
- * 幂等：条目已有含同 ref 的待复核行 → 跳过；superseded 条目不标（digest 注入面本就不含）。
- * 只动文件不改语义——行是信号，承接翻链时被 indexRequirements 的 filter 清除。
- * @param {string} knowledgeRoot
- * @param {string[]} frIds - 全局 id 列表（钩子#1 的 readActiveFrDigest 命中集）
- * @param {string} refNote - 标记来源（ql-id 或 change 名）
- * @returns {{ marked: number, warnings: string[] }}
- */
-export function markFrNeedsReview(knowledgeRoot, frIds, refNote) {
-  const warnings = [];
-  let marked = 0;
-  if (!Array.isArray(frIds) || frIds.length === 0 || !refNote) return { marked, warnings };
-  const all = scanAllDomains(knowledgeRoot);
-  const idSet = new Set(frIds);
-  const dirty = new Set();
-  for (const [domain, st] of all.entries()) {
-    for (const s of st.sections) {
-      if (!idSet.has(s.number)) continue;
-      if (s.lines.some((l) => l.startsWith('superseded_by：'))) continue; // 已取代不标
-      const line = `${FR_NEEDS_REVIEW_PREFIX}${refNote}`;
-      if (s.lines.some((l) => l === line)) continue; // 幂等：同 ref 已标
-      // 移除旧 ref 的待复核行（多轮标记仅保最新），追加新行到摘要行后
-      s.lines = s.lines.filter((l) => !l.startsWith(FR_NEEDS_REVIEW_PREFIX));
-      const sumIdx = s.lines.findIndex((l) => l.startsWith('摘要：'));
-      s.lines.splice(sumIdx === -1 ? s.lines.length : sumIdx + 1, 0, line);
-      dirty.add(domain);
-      marked++;
-    }
-  }
-  if (dirty.size > 0) {
-    mkdirSync(frDirPath(knowledgeRoot), { recursive: true });
-    for (const d of dirty) {
-      const st = all.get(d);
-      writeFileSync(join(frDirPath(knowledgeRoot), `${d}.md`), joinKnowledgeFile(st.preamble, st.sections));
-    }
-  }
-  for (const id of idSet) {
-    let found = false;
-    for (const st of all.values()) if (st.sections.some((s) => s.number === id)) { found = true; break; }
-    if (!found) warnings.push(`markFrNeedsReview：${id} 不在索引中（跳过）`);
-  }
-  return { marked, warnings };
-}
+// ── needs_review 持久标记层（2026-09-20-quick-asset-tail D-003）已拆除 ──────────────
+// 2026-09-29-rot-retire-inject-cap：markFrNeedsReview/FR_NEEDS_REVIEW_PREFIX/cleanupStaleReviewMarks
+// 移除——371 条标记零消费实证（归档全量检索无一次复核行动），信号饱和反噬注入排序。腐烂 suspect
+// 的信号面保留在 flow.js rotSuspectFlow（收口 advisory + fr-rot-suspect 遥测），不再落盘。
 
 /**
  * 归档侧 FR 域路由文件面（greenfield-bootstrap：archive 侧 indexRequirements 此前不传
@@ -948,72 +1003,3 @@ export function archiveDeliverableFiles(changeDir) {
   return [...out].filter((p) => !p.startsWith('.sillyspec/'))
 }
 
-/**
- * 存量待复核标记治理（fr-rot-precision 评审修正稿）：按「新判据下 ref 变更收口时该条会不会被
- * 打标」重算——keep iff coverageFiles(FR 来源变更) ∪ bindings 与 coverageFiles(ref 变更) 有文件面
- * 交集。ref 无归档或任一侧 coverage 空 → 删（自然覆盖 quick 侧 ref——quick 永不归档无文件面；
- * 与运行时 unknown 不打标口径一致：宁漏勿滥，漏标只损失注入排序优先级）。
- * 并发安全：写前重读比对快照，盘上已被并行会话改写的文件跳过（幂等可重跑消化）；原子写。
- * superseded 条目不碰（无 active 语义）；**在途变更的标记跳过**（rot 打标在归档前、ref 必无
- * 冻结件——误判面实证后修复：收口落地后重跑清理再判）。
- * @returns {{ removed: number, kept: number, inFlight: number, skipped: string[], files: string[], byRef: Record<string, number> }}
- */
-export function cleanupStaleReviewMarks({ specBase, archiveRoot }) {
-  const knowledgeRoot = join(specBase, 'knowledge');
-  const frDir = frDirPath(knowledgeRoot);
-  const snapshot = new Map();
-  try {
-    for (const f of readdirSync(frDir)) {
-      if (f.endsWith('.md')) snapshot.set(f, readFileSync(join(frDir, f), 'utf8'));
-    }
-  } catch { /* 目录不可读=空治理面 */ }
-  const all = scanAllDomains(knowledgeRoot);
-  const covCache = new Map();
-  const coverageOf = (changeName) => {
-    if (!changeName) return [];
-    if (!covCache.has(changeName)) covCache.set(changeName, frCoverageFiles({ archiveRoot, changeName }));
-    return covCache.get(changeName);
-  };
-  let removed = 0, kept = 0, inFlight = 0;
-  const byRef = {};
-  const dirty = new Set();
-  const covHit = (frChange, bindings, refCover) => {
-    // bindings 可携带用例锚（2026-09-26-binding-anchor-fidelity）——覆盖判定按文件面取值走剥锚
-    const frCov = new Set([...coverageOf(frChange), ...(Array.isArray(bindings) ? bindings.map((b) => testAnchorFile(b)) : [])]);
-    if (frCov.size === 0 || refCover.length === 0) return false;
-    return [...frCov].some((p) => refCover.some((c) => c === p || c.startsWith(p.endsWith('/') ? p : p + '/') || p.startsWith(c.endsWith('/') ? c : c + '/')));
-  };
-  for (const [domain, st] of all.entries()) {
-    for (const s of st.sections) {
-      const reviewLines = s.lines.filter((l) => l.startsWith(FR_NEEDS_REVIEW_PREFIX));
-      if (reviewLines.length === 0) continue;
-      if (s.lines.some((l) => l.startsWith('superseded_by：'))) continue; // 已取代：翻链自会清，不在此治理
-      const ref = reviewLines[0].slice(FR_NEEDS_REVIEW_PREFIX.length).trim();
-      // 在途变更跳过（第二轮清理实证）：rot 打标发生在 flow done ledger（归档前），ref 指向的
-      // 变更此刻必无归档冻结件——coverage(ref) 恒空会误判全删。跳过，收口落地后重跑再判。
-      if (ref && existsSync(join(specBase, 'changes', ref))) { inFlight++; continue; }
-      const keep = covHit(s.change, readEntryBindings(s.lines), coverageOf(ref));
-      if (keep) { kept++; continue; }
-      s.lines = s.lines.filter((l) => !l.startsWith(FR_NEEDS_REVIEW_PREFIX));
-      removed++;
-      byRef[ref] = (byRef[ref] || 0) + 1;
-      dirty.add(domain);
-    }
-  }
-  const files = [];
-  const skipped = [];
-  if (dirty.size > 0) {
-    mkdirSync(frDir, { recursive: true });
-    for (const d of dirty) {
-      const fname = `${d}.md`;
-      try {
-        const before = snapshot.get(fname);
-        const now = existsSync(join(frDir, fname)) ? readFileSync(join(frDir, fname), 'utf8') : null;
-        if (before == null || before !== now) { skipped.push(fname); continue; } // 并行写已发生——跳过，重跑消化
-      } catch { skipped.push(fname); continue; }
-      writeAtomicSync(join(frDir, fname), joinKnowledgeFile(all.get(d).preamble, all.get(d).sections));
-      files.push(fname);
-    }
-  }
-  return { removed, kept, inFlight, skipped, files, byRef };
-}

package/src/git-helper.js

@@ -79,6 +79,18 @@ function buildFullArgs(cwd, args) {
 // ENOBUFS 只能 git merge 绕行）——上限只在真输出那么大时才占用
 const GIT_MAX_BUFFER = 256 * 1024 * 1024
 
+/**
+ * CLI 自建 git 子进程的统一 env：GIT_OPTIONAL_LOCKS=0（坑 git-optional-locks，
+ * 2026-10-06-module-map-list-leak 收口 add 静默失效根因收口）——status/diff 等读命令的
+ * 机会性 index 刷新会短暂持 index.lock（watcher 每 ~3s 轮询 status 即常驻锁源），并发
+ * git add 落进窗口即失败。该开关只禁机会性锁，add/commit 等真写的必需锁不受影响；
+ * 权威注入（调用方显式值不覆盖）——「CLI 子进程恒不机会性抢锁」是统一不变量，不逐调用点分叉。
+ * 展开合并不裸替换（丢 SystemRoot/USERPROFILE/TEMP 会毁 Windows 子进程，终批-③ 同坑）。
+ */
+function gitChildEnv(env) {
+  return { ...(env || process.env), GIT_OPTIONAL_LOCKS: '0' }
+}
+
 /**
  * 安全执行 git：失败不抛，返回 { value, error } 结构。
  * @param {string} cwd
@@ -99,7 +111,7 @@ export function safeGit(cwd, args, opts = {}) {
   // 格式化（取首行）推迟到最终返回，避免重试分支重复格式化，并保留原始 code 供重试判定。
   const attempt = (t) => {
     try {
-      let value = execFileSync('git', fullArgs, { encoding: 'utf8', timeout: t, maxBuffer: GIT_MAX_BUFFER, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
+      let value = execFileSync('git', fullArgs, { encoding: 'utf8', timeout: t, maxBuffer: GIT_MAX_BUFFER, stdio: ['ignore', 'pipe', 'pipe'], env: gitChildEnv(), windowsHide: true })
       if (trim) value = value.trim()
       return { value, errorObj: null }
     } catch (e) {
@@ -127,8 +139,9 @@ export function git(cwd, args, opts = {}) {
   const { trim = true, timeout = 5000, encoding = 'utf8', env } = opts
   const fullArgs = buildFullArgs(cwd, args)
   // env（终批-③）：可选注入（如 baseline checkpoint 的临时 GIT identity）——调用方必须
-  // 用 { ...process.env, GIT_xxx } 展开形式，裸替换会丢 SystemRoot/USERPROFILE/TEMP（Windows）
-  const value = execFileSync('git', fullArgs, { encoding, timeout, maxBuffer: GIT_MAX_BUFFER, stdio: ['ignore', 'pipe', 'pipe'], env, windowsHide: true })
+  // 用 { ...process.env, GIT_xxx } 展开形式，裸替换会丢 SystemRoot/USERPROFILE/TEMP（Windows）；
+  // 最终经 gitChildEnv 展开合并并权威注入 GIT_OPTIONAL_LOCKS=0（调用方 GIT 键照常透传）
+  const value = execFileSync('git', fullArgs, { encoding, timeout, maxBuffer: GIT_MAX_BUFFER, stdio: ['ignore', 'pipe', 'pipe'], env: gitChildEnv(env), windowsHide: true })
   if (Buffer.isBuffer(value)) return value
   return trim ? value.trim() : value
 }

package/src/hooks/worktree-guard.js

@@ -60,7 +60,11 @@ const STAGE_HINTS = {
     '没有检测到活跃的 SillySpec 流程。',
     '你需要先启动一个任务流程才能修改源码（调用对应的 sillyspec skill）：',
     '',
-    '  BUG修复(skill sillyspec-quick)：sillyspec run quick "任务描述"',
+    '  轻量变更/BUG修复（默认快道，skill sillyspec-flow）——--input 引号内换行合法，下例可照抄：',
+    '  sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>',
+    '',
+    '  成功标准：',
+    '  - <可验证标准>"',
     '  逻辑变更(skill sillyspec-brainstorm)：sillyspec run brainstorm → plan → execute → verify → archive',
     '  全自动模式(skill sillyspec-auto)：sillyspec run auto "任务描述"',
   ],
@@ -75,16 +79,23 @@ const STAGE_HINTS = {
   ],
   'verify': [
     '当前在 verify（验证）阶段，只做代码审查和测试验证，不修改源码。',
-    '如需修改，请先回到 execute 阶段或使用 quick 模式：',
-    '  sillyspec run quick "修改描述"',
+    '如需修改，请先回到 execute 阶段，或收口后开轻量变更（--input 引号内换行合法，可照抄）：',
+    '  sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>',
+    '',
+    '  成功标准：',
+    '  - <可验证标准>"',
   ],
   'archive': [
     '当前在 archive（归档）阶段，不修改源码。',
-    '如需修改，请开启新变更：sillyspec run quick "修改描述"',
+    '如需修改，请开启新变更（--input 引号内换行合法，可照抄）：',
+    '  sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>',
+    '',
+    '  成功标准：',
+    '  - <可验证标准>"',
   ],
   'explore': [
     '当前在 explore（探索）阶段，只读不写。',
-    '确认方案后使用：sillyspec run brainstorm 或 sillyspec run quick',
+    '确认方案后使用：sillyspec run brainstorm，或小改动直接走轻量变更 sillyspec flow start',
   ],
 }