sillyspec 3.29.4 → 3.30.0

package/src/foreign-declared.js

@@ -10,7 +10,7 @@
  * 独立零环模块：被 verify-postcheck / verify-probes / contract-matrix 共用（verify-
  * postcheck import contract-matrix，parity 侧不能反向 import verify-postcheck）。
  */
-import { existsSync, readFileSync, readdirSync } from 'fs'
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs'
 import { join } from 'path'
 import { parseFileChangeListDetailed } from './change-list.js'
 import { safeGit, unquoteGitPath } from './git-helper.js'
@@ -131,6 +131,10 @@ export function collectForeignDeclaredFiles(cwd, currentChangeName, opts = {}) {
       } catch { /* 损坏/缺失跳过 */ }
     }
     // ② 其他变更的 design §6 清单（目录在即视为在途变更；archive/ 下不算）
+    // 时效判据（2026-09-25-platform-feedback-batch2 B）：变更目录 mtime 超 7 天未动 → 声明视为
+    // 陈旧忽略（平台狗粮实证：9-21 未归档旧变更 9-25 还在抢文件——活性被 dirty 反向喂活但
+    // 变更本身已死。mtime 是最便宜的活性信号：任何文件写入/勾选/槽位填写都会 touch 目录）。
+    const STALE_CHANGE_MS = 7 * 24 * 60 * 60 * 1000
     const changesDir = join(specBase, 'changes')
     let changeDirs = []
     try { changeDirs = readdirSync(changesDir, { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name) } catch {}
@@ -138,6 +142,18 @@ export function collectForeignDeclaredFiles(cwd, currentChangeName, opts = {}) {
       if (cn === currentChangeName || cn === 'archive') continue
       const designPath = join(changesDir, cn, 'design.md')
       if (!existsSync(designPath)) continue
+      // 时效：变更目录内最新文件 mtime 超 7 天 → 陈旧（目录 mtime 在 POSIX 上只反映子项增删
+      // 不反映文件内容修改——用目录内所有文件的最大 mtime 做活性信号，跨平台一致）
+      try {
+        let newestMtime = 0
+        const changePath = join(changesDir, cn)
+        for (const fe of readdirSync(changePath)) {
+          try { const m = statSync(join(changePath, fe)).mtimeMs; if (m > newestMtime) newestMtime = m } catch { /* 个别文件 stat 失败跳过 */ }
+        }
+        if (newestMtime > 0 && Date.now() - newestMtime > STALE_CHANGE_MS) {
+          continue // 陈旧变更——声明已死，不抢活人的文件
+        }
+      } catch { /* stat 失败保守保留 */ }
       try {
         for (const e of parseFileChangeListDetailed(designPath)) add(e.path, cn)
       } catch { /* 清单解析失败跳过该变更 */ }

package/src/fr-index.js

@@ -17,8 +17,11 @@
  *     syncIndexRoutingLines/discoverModuleIndex），不复制实现。
  */
 
+import { readChangeTrace, upsertFrBindings, applySupersededToEntryLines, testAnchorFile, resolveTestFileRel } from './test-bindings.js'
+import { suggestDomainFromFiles } from './knowledge-digest.js'
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { basename, dirname, join } from 'path';
+import { writeAtomicSync } from './fs-atomic.js';
 import {
   splitKnowledgeSections,
   joinKnowledgeFile,
@@ -29,11 +32,102 @@ import {
 /** epoch：此前归档不检查/不索引（存量 93 份不回填——不伪造历史，D-007）。 */
 export const FR_INDEX_EPOCH = '2026-09-18';
 
+/** design.md 交付清单表行解析（「| 新增|修改|删除 | 路径 |」行，含 NEW: 前缀形态）——剥反引号：
+ * 实测 29.4% 厚道交付条目带壳（fr-rot-precision 评审 P1-2），不剥与 git 路径永不相等。
+ * 从 resolveTouchedDomains 内部正则抽出公共（frCoverageFiles 与域路由共用同一解析）。 */
+export function deliverableFilesFromDesignText(text) {
+  const out = [];
+  for (const line of String(text || '').replace(/\r\n/g, '\n').split('\n')) {
+    const m = line.match(/^\|\s*(?:新增|修改|删除)\s*\|\s*(?:NEW:)?([^\s|]+)\s*\|/);
+    if (m) out.push(m[1].trim().replace(/^`+|`+$/g, ''));
+  }
+  return out;
+}
+
+/**
+ * FR 覆盖文件集（fr-rot-precision：rot 三分判据/存量清理的文件面底座）——归档变更三源并集：
+ * ①design.md 交付表（厚道主源，剥反引号）②change-patch.json 的 files（thin 主源——thin 归档
+ * 27/30 在场，早期 3 份缺补位靠绑定）③（绑定由消费方并入——readActiveFrDigest.bindings）。
+ * 统一剔 .sillyspec/ 前缀（内部产物≠交付面）；POSIX 归一；fail-soft（缺件=空贡献）。
+ * 匹配口径（消费方约定）：changed 恒为文件级路径，判定用单向「相等 || changed.startsWith(cov 补/ 结尾)」。
+ */
+export function frCoverageFiles({ archiveRoot, changeName }) {
+  const out = new Set();
+  const dir = join(archiveRoot, String(changeName || ''));
+  try {
+    const dp = join(dir, 'design.md');
+    if (existsSync(dp)) {
+      for (const f of deliverableFilesFromDesignText(readFileSync(dp, 'utf8'))) {
+        const v = f.replace(/\\/g, '/').replace(/\/+$/, '');
+        if (v) out.add(v);
+      }
+    }
+  } catch { /* 源1 fail-soft */ }
+  try {
+    const pp = join(dir, 'change-patch.json');
+    if (existsSync(pp)) {
+      const j = JSON.parse(readFileSync(pp, 'utf8'));
+      for (const f of (Array.isArray(j && j.files) ? j.files : [])) {
+        const v = String(f || '').replace(/\\/g, '/').replace(/\/+$/, '');
+        if (v) out.add(v);
+      }
+    }
+  } catch { /* 源2 fail-soft */ }
+  return [...out].filter((p) => !p.startsWith('.sillyspec/'));
+}
+
+/** 条目「测试绑定：」子块的 tests 文件提取（多文件 | 分隔）。边界=下一个 ## 节头（FR 节）——
+ * 子块内顶格的 `<!-- test-bindings -->` 机器注释与 `- row:` 行不终止收集（评审 P1 修复：
+ * 原「任意顶格行 break」遇子块首行顶格注释即断，生产库 bindings 恒空；缩进 tests: 键名 +
+ * 节头边界已足够防条目正文误匹配）。readActiveFrDigest.bindings 与 cleanupStaleReviewMarks 共用。 */
+function readEntryBindings(lines) {
+  const idx = lines.findIndex((l) => l.startsWith('测试绑定：'));
+  if (idx === -1) return [];
+  const out = [];
+  for (const l of lines.slice(idx + 1)) {
+    if (/^##\s/.test(l)) break; // 下一节头=条目边界
+    const m = l.match(/^\s+tests:\s*(.+)$/);
+    if (m) {
+      for (const t of m[1].split('|')) {
+        const v = t.trim().replace(/^['"]|['"]$/g, '');
+        if (v) out.push(v.replace(/\\/g, '/'));
+      }
+    }
+  }
+  return out;
+}
+
+/** 条目未确认绑定行计数（2026-09-27-confirm-on-use）：绑定子块内 confirmed_by≠agent 的
+ * `- row:` 块数——机器提升行恒 candidate/null（状态机有机制无消费者的病灶面），注入面据此
+ * 打 ⚪N未确认 标记 + 抽查确认提示。行块边界=下一个 `- row:` 或节头。 */
+export function readEntryUnconfirmed(lines) {
+  const idx = lines.findIndex((l) => l.startsWith('测试绑定：'));
+  if (idx === -1) return 0;
+  let unconfirmed = 0
+  let inRow = false
+  let rowConfirmed = false
+  for (const l of lines.slice(idx + 1)) {
+    if (/^##\s/.test(l)) break
+    if (/^-\s+row:/.test(l)) {
+      if (inRow && !rowConfirmed) unconfirmed++
+      inRow = true; rowConfirmed = false; continue
+    }
+    if (inRow && /^\s+confirmed_by:\s*agent\s*$/.test(l)) rowConfirmed = true
+  }
+  if (inRow && !rowConfirmed) unconfirmed++
+  return unconfirmed
+}
+
+/** 标题 bigram 重叠判「重复嫌疑/承接漏写」的阈值（fr-index 判据函数与两处消费方——brainstorm
+ * 软门（stage-contract.js）与轻量道 dup 软门（flow.js）——共用同一常量，防两处各写一份字面量
+ * 漂移（fr-rot-precision 评审 P3 清偿：改阈值只改这里）。 */
+export const FR_TITLE_OVERLAP_THRESHOLD = 0.6;
+
 const FR_DIR = 'fr';
 /** FR 节头：## FR-<域>-NNN 标题（域=[a-z0-9-] **含连字符**——真实模块 id 多为 cli-entry/core-engine 等连字符形态，
  *  R1 审查阻断①实证：漏 - 会让连字符域的发号/幂等/解析/承接全断。第二组为非捕获可选占位，
  *  三组结构与底座 splitKnowledgeSections 的 decisions 正则对齐（m[3]=标题，勿改组序）。 */
-const FR_SECTION_RE = /^## (FR-[a-z0-9-]+-\d+)(?:@v(\d+))?\s*(.*)$/;
+export const FR_SECTION_RE = /^## (FR-[a-z0-9-]+-\d+)(?:@v(\d+))?\s*(.*)$/;
 const FR_GLOBAL_ID_RE = /^FR-[a-z0-9-]+-\d+$/;
 
 /**
@@ -130,33 +224,72 @@ export function parseChangeRequirements(changeDir) {
   return { missing: false, frs, malformed };
 }
 
-/** 域解析（导出供注入/软门消费）：变更自身 design.md 文件变更清单表行（剥 NEW: 前缀）× moduleIndex paths 前缀匹配；无匹配 → unmapped。 */
-export function resolveTouchedDomains(changeDir, moduleIndex) {
+/** 域解析（导出供注入/软门消费）：变更自身 design.md 文件变更清单表行（剥 NEW: 前缀）× moduleIndex paths 前缀匹配；
+ * 无匹配 → 伪域回退（auto-<路径段>，按文件路径段投票——2026-09-21 R5R 实证主仓 706 条 FR 落
+ * 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) {
   const domains = new Set();
   const designPath = join(changeDir, 'design.md');
-  if (moduleIndex && existsSync(designPath)) {
+  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);
+      }
+    }
+  };
+  if (Array.isArray(filesOverride)) {
+    for (const f of filesOverride) {
+      const filePath = String(f || '').trim();
+      if (!filePath) continue;
+      files.push(filePath);
+      matchModules(filePath);
+    }
+  } else if (existsSync(designPath)) {
     let design;
     try {
       design = readFileSync(designPath, 'utf8');
     } catch {
       design = '';
     }
-    for (const line of design.replace(/\r\n/g, '\n').split('\n')) {
-      const m = line.match(/^\|\s*(?:新增|修改|删除)\s*\|\s*(?:NEW:)?([^\s|]+)\s*\|/);
-      if (!m) continue;
-      const filePath = m[1].trim();
-      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 filePath of deliverableFilesFromDesignText(design)) {
+      files.push(filePath);
+      matchModules(filePath);
     }
   }
-  if (domains.size === 0) domains.add('unmapped');
+  if (domains.size === 0) domains.add(files.length > 0 ? pseudoDomainFromPaths(files) : 'unmapped');
   return [...domains];
 }
 
+// 泛化首段（src/lib/test/...）不承载域语义——目录段里跳过它们取首个具体段。
+const GENERIC_PATH_SEGMENTS = new Set(['src', 'lib', 'test', 'tests', 'spec', 'docs', 'doc', 'app', 'packages', 'scripts', 'config', 'public', 'internal']);
+
+/**
+ * 文件清单 → 伪域名（auto-<段>）：逐文件取目录段（末段是文件名不投票）里首个非泛化段，
+ * 按出现次数投票取众数；全部泛化/根文件 → 'unmapped'。auto- 前缀保证与真实模块 id
+ * （模块卡派生）不冲突，且在 fr 文件头与 INDEX 路由键里自明身份。
+ */
+function pseudoDomainFromPaths(files) {
+  const votes = new Map();
+  for (const f of files) {
+    const segs = String(f || '').replace(/\\/g, '/').split('/').filter(Boolean);
+    if (segs.length < 2) continue; // 根文件无目录段
+    for (const seg of segs.slice(0, -1)) {
+      const s = seg.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '');
+      if (!s || GENERIC_PATH_SEGMENTS.has(s)) continue;
+      votes.set(s, (votes.get(s) || 0) + 1);
+      break; // 首个非泛化目录段即该文件的票，一文件一票
+    }
+  }
+  if (votes.size === 0) return 'unmapped';
+  const top = [...votes.entries()].sort((a, b) => b[1] - a[1])[0][0];
+  return `auto-${top}`;
+}
+
 /** 域文件路径与域索引读写（复用参数化底座；FR 节无版本段，id 恒等）。 */
 function frDirPath(knowledgeRoot) {
   return join(knowledgeRoot, FR_DIR);
@@ -176,7 +309,9 @@ function loadDomainSections(knowledgeRoot, domain) {
         '',
         '> fr-index 从归档变更 requirements.md 幂等提炼（「最近确认」= 归档时 HEAD）。条目字段行为机械解析契约，勿手改。',
         '> superseded 条目保留供取代链回溯；brainstorm 注入默认只给 active。',
-        `> 模块卡：modules/${domain}.md（域=模块 id 同构；行为条目↔模块契约互跳）`,
+        String(domain).startsWith('auto-')
+          ? '> 伪域（auto- 前缀）：由文件路径段投票派生，无模块卡——为该域补模块卡后，新变更将自动落回真域'
+          : `> 模块卡：modules/${domain}.md（域=模块 id 同构；行为条目↔模块契约互跳）`,
         '',
       ],
       sections: [],
@@ -252,10 +387,22 @@ function nextIdForDomain(domain, allSections) {
 
 /**
  * 归档索引主入口（幂等）：解析 → 域解析 → 发号 → 承接翻链 → 写域文件 → INDEX 路由。
- * @param {{ changeDir: string, knowledgeRoot: string, headHash?: string, cwd?: string }} args
+ * @param {{ changeDir: string, knowledgeRoot: string, headHash?: string, cwd?: string, deliverableFiles?: string[] }} args
+ *   deliverableFiles：显式交付文件清单（轻量变更无 design.md 时由调用方供基线 diff，域路由同口径）
  * @returns {{ skipped?: string, written: Array<{file,id,action}>, superseded: Array<{from,to,change}>, unreferenced: Array<{domain,count}>, warnings: string[] }}
  */
-export function indexRequirements({ changeDir, knowledgeRoot, headHash = '' }) {
+/** projectRoot 启发式（绑定路径仓根归一用）：specBase 目录名是 .sillyspec 且其父像仓根
+ * （.git/package.json/pyproject.toml 在场）→ 父目录；否则 null（不猜——归一跳过保原值）。 */
+function deriveProjectRootFromSpec(specBase) {
+  try {
+    const parent = dirname(specBase)
+    if (basename(specBase) === '.sillyspec'
+      && (existsSync(join(parent, '.git')) || existsSync(join(parent, 'package.json')) || existsSync(join(parent, 'pyproject.toml')))) return parent
+  } catch { /* 启发式失败 → null */ }
+  return null
+}
+
+export function indexRequirements({ changeDir, knowledgeRoot, headHash = '', deliverableFiles = null, projectRoot = null }) {
   const changeName = changeDir.split(/[\\/]/).pop();
   const parsed = parseChangeRequirements(changeDir);
   if (parsed.missing) {
@@ -267,7 +414,7 @@ export function indexRequirements({ changeDir, knowledgeRoot, headHash = '' }) {
 
   const warnings = [...parsed.malformed];
   const moduleIndex = discoverModuleIndex(knowledgeRoot);
-  const domains = resolveTouchedDomains(changeDir, moduleIndex);
+  const domains = resolveTouchedDomains(changeDir, moduleIndex, deliverableFiles);
   const all = scanAllDomains(knowledgeRoot);
 
   // 幂等闸门：任一域文件已有本变更「来源变更」条目 → 全量 no-op（同变更重跑零新增零漂移）
@@ -333,6 +480,11 @@ export function indexRequirements({ changeDir, knowledgeRoot, headHash = '' }) {
           `superseded_by：${id}`,
           `取代链：${refId} ← ${id}（${changeName} 承接）`,
           ...(reason ? [`退役理由：${reason}`] : []));
+        // 绑定行同步退役（2026-09-24-fr-test-bindings task-06，fr-test-binding §3.2 四硬约束④）：
+        // 被承接条目的绑定行 status→superseded（内存态翻转——文件稍后统一落盘，禁死锚）
+        try {
+          target.lines = applySupersededToEntryLines(target.lines);
+        } catch { /* 绑定翻转 fail-open：翻链语义不受影响 */ }
         // scenario-loss 检测（对标 OpenSpec 同名检查）：被取代条目的场景名在新 FR 场景集
         //（scenarios 名字数组 ∪ scenarioBodies 名）无对应 → warning 提示核对（advisory 不阻断
         //——场景名合法漂移存在，人裁）。旧条目无场景信息（摘要「（无场景名）」/空）不比对。
@@ -380,14 +532,71 @@ export function indexRequirements({ changeDir, knowledgeRoot, headHash = '' }) {
     const stx = all.get(d);
     writeFileSync(join(frDirPath(knowledgeRoot), `${d}.md`), joinKnowledgeFile(stx.preamble, stx.sections));
   }
+  // ── 归档提升（2026-09-24-fr-test-bindings task-06，fr-test-binding §3.2）：本变更 test-trace
+  //    的 FR 局部锚行随发号映射铸全局后 upsert 进活库条目机器子块（source_change+row_id 键、
+  //    内容全等 no-op、机器不删 agent 行）；orphan/ql 行不在此面（前者留档审计，后者在
+  //    quicklog 机器面）。fail-open：提升异常只告警不炸归档（幂等可重跑）。──
+  const promotedBindings = [];
+  try {
+    const traceRows = readChangeTrace(changeDir);
+    if (traceRows.length > 0) {
+      // 局部→全局映射：本函数发号段 written[{id}] 与 parsed.frs 逐条对应（同循环序）
+      const localToGlobal = new Map();
+      parsed.frs.forEach((fr, i) => { if (written[i] && written[i].id) localToGlobal.set(fr.local, written[i].id); });
+      for (const [local, globalId] of localToGlobal) {
+        const rows = traceRows.filter((r) => r.anchor === local);
+        if (rows.length === 0) continue;
+        // projectRoot 优先调用方（真仓根），缺省启发式自 specBase 推（.sillyspec 父目录像仓根才取）
+        const res = upsertFrBindings({ knowledgeRoot, frId: globalId, rows, projectRoot: projectRoot || deriveProjectRootFromSpec(dirname(changeDir)) });
+        if (res.ok) promotedBindings.push({ fr: globalId, rows: rows.length, changed: res.changed });
+      }
+      if (promotedBindings.length > 0) {
+        console.log(`🔗 测试绑定归档提升：${promotedBindings.map((p) => `${p.fr}(${p.rows}行)`).join('、')} → knowledge/fr/ 机器子块`);
+      }
+    }
+  } catch (e) {
+    console.warn(`⚠️ 测试绑定归档提升失败（fail-open，可重跑归档幂等重试）：${e && e.message ? e.message : e}`);
+  }
   if (written.length > 0 || superseded.length > 0) {
     syncIndexRoutingLines(knowledgeRoot, {
       section: 'FR 需求索引',
       subdir: FR_DIR,
-      makeLine: (d) => `- ${d}|FR|需求|承接 → [${FR_DIR}/${d}.md](${FR_DIR}/${d}.md)`,
+      // 伪域路由行追加裸段关键词（auto-backend 行同时吃 'backend' 命中——域名字面作为
+      // 唯一路由键对 auto- 域过窄，2026-09-21 unmapped 大池路由失效的教训）
+      makeLine: (d) => d.startsWith('auto-')
+        ? `- ${d}|${d.slice(5)}|FR|需求|承接 → [${FR_DIR}/${d}.md](${FR_DIR}/${d}.md)`
+        : `- ${d}|FR|需求|承接 → [${FR_DIR}/${d}.md](${FR_DIR}/${d}.md)`,
     });
   }
 
+  // ── 绿地知识面提醒（greenfield-bootstrap）：本变更条目落伪域/unmapped 时提示升级路径；
+  //    unmapped 域总条目超阈（50）告警配治理指引（本仓 720 条实证堆积病——告警不阻断）。──
+  try {
+    const pseudoHits = written.filter((w) => /^(auto-|unmapped$)/.test(String(w.file || '').replace(/^fr\//, '')))
+    if (pseudoHits.length > 0) {
+      // 落域机械改进（2026-09-27-knowledge-digest）：伪域告警附交付路径推导的建议域——
+      // 归档时转达人工 1 秒确认（建议器与 digest 信号卡共用 suggestDomainFromFiles 单源）
+      const suggested = suggestDomainFromFiles(deliverableFiles || [])
+      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（伪域信号卡）`)
+    }
+    const unm = all.get('unmapped')
+    if (unm && unm.sections.length > 50) {
+      // 基线消音（2026-09-26 修复轮）：本仓 unmapped 720 条是 MP 仓历史变更的跨仓知识基线
+      // （103 个来源变更全在归档，非新增堆积）——警告只对新增超基线时触发，不重复刷历史池。
+      // 基线锚定 local.yaml 的 fr_unmapped_baseline（缺省 0=无基线，警告行为不变）。
+      let baseline = 0
+      try {
+        const raw = readFileSync(join(knowledgeRoot, '..', 'local.yaml'), 'utf8')
+        const m = raw.match(/^fr_unmapped_baseline:\s*(\d+)\s*$/m)
+        if (m) baseline = parseInt(m[1], 10)
+      } catch { /* 无 local.yaml = 无基线 */ }
+      if (unm.sections.length > Math.max(50, baseline + 10)) {
+        console.warn(`⚠️ [unmapped 大池] ${unm.sections.length} 条 FR 堆积在 unmapped 域（基线 ${baseline} + 增量 >10）——若为跨仓历史基线可在 local.yaml 设 fr_unmapped_baseline: ${unm.sections.length} 消音；新变更落 unmapped 时建议补模块卡自动分流`)
+      }
+    }
+  } catch { /* 提醒 fail-open */ }
+
   return { written, superseded, unreferenced, warnings };
 }
 
@@ -570,12 +779,80 @@ export function readActiveFrDigest(knowledgeRoot, domains) {
       // 注入面带 ⚠️ 提示后续变更核对——是信号非失效，承接翻链时清除。
       const reviewLine = s.lines.find((l) => l.startsWith('待复核：'));
       const needsReview = reviewLine ? reviewLine.replace(/^待复核：\s*/, '').trim() : null;
-      out.push({ domain, id: s.number, title: s.title || '', change: s.change || '', scenarios, decisions, needsReview });
+      // 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) });
     }
   }
   return out;
 }
 
+// ── active FR 覆盖命中查询（2026-09-26-dynamic-test-inference）─────────────────────
+// 查询核单源双消费：flow 侧 rotSuspectFlow 打待复核标记（信号面）；verify 侧
+// collectFrLinkedTests 反用为「需求关联回归测试面」（测试门三源之二）。覆盖判定与
+// rot 完全同口径：来源变更 patch 文件 ∪ 绑定 tests（剥用例锚）∩ 本次触碰文件 ≠ ∅。
+
+/**
+ * 触达域内 active FR 的强命中集。
+ * @returns {{ domains: string[], hits: Array<{domain,id,title,change,bindings:string[],coverage:Set}>, unknownSources: string[] }}
+ *   hits=覆盖面与触碰文件相交者；unknownSources=覆盖源缺失（无 patch 无绑定）的来源变更名。
+ */
+export function activeFrCoverageHits({ specBase, change = null, changeDir = null, files = [] }) {
+  const knowledgeRoot = join(specBase, 'knowledge')
+  const archiveRoot = join(specBase, 'changes', 'archive')
+  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')
+  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 }
+}
+
+/**
+ * 需求关联回归测试面（测试门三源之二）：强命中 FR 的绑定 tests 解析为仓根相对文件集。
+ * 路径解析三段（resolveTestFileRel）：根相对直取 → 子项目根前缀补全 → 裸文件名受限 glob；
+ * 解析失败路径不进测试面（unresolved 披露，宁缺勿错跑）。
+ * @returns {{ files: string[], frHits: Array<{domain,id,title,files:string[]}>, unresolved: string[], domains: string[] }}
+ */
+export function collectFrLinkedTests({ specBase, changeName = null, changedFiles = [], projectRoot }) {
+  const q = activeFrCoverageHits({
+    specBase,
+    change: changeName,
+    changeDir: changeName ? join(specBase, 'changes', changeName) : null,
+    files: changedFiles,
+  })
+  const filesSet = new Set()
+  const frHits = []
+  const unresolved = []
+  for (const h of q.hits) {
+    if (!Array.isArray(h.bindings) || h.bindings.length === 0) continue
+    const resolvedFiles = new Set()
+    for (const b of h.bindings) {
+      const filePart = testAnchorFile(b)
+      const rel = resolveTestFileRel(filePart, { projectRoot })
+      if (rel) { resolvedFiles.add(rel); filesSet.add(rel) } else unresolved.push(`${h.id}:${b}`)
+    }
+    if (resolvedFiles.size > 0) frHits.push({ domain: h.domain, id: h.id, title: h.title, files: [...resolvedFiles].sort() })
+  }
+  return { files: [...filesSet].sort(), frHits, unresolved, domains: q.domains }
+}
+
 /**
  * 标题 bigram 重叠率（中英混排零依赖）：字符 bigram 集合 |A∩B| / |A∪B|。
  */
@@ -643,3 +920,100 @@ export function markFrNeedsReview(knowledgeRoot, frIds, refNote) {
   }
   return { marked, warnings };
 }
+
+/**
+ * 归档侧 FR 域路由文件面（greenfield-bootstrap：archive 侧 indexRequirements 此前不传
+ * deliverableFiles——域路由退化为 design 清单单源，design 全泛化段/根文件时落 unmapped，
+ * R17 臂3 十条 FR 实证）：design 交付表 ∪ apply-manifest.json 的 files[].path（apply 链
+ * 落盘的真实交付清单）。与轻量道 attributedChangedFiles 口径对齐（文件面供域路由投票）。
+ */
+export function archiveDeliverableFiles(changeDir) {
+  const out = new Set()
+  try {
+    const dp = join(changeDir, 'design.md')
+    if (existsSync(dp)) {
+      for (const f of deliverableFilesFromDesignText(readFileSync(dp, 'utf8'))) out.add(f.replace(/\\/g, '/'))
+    }
+  } catch { /* fail-soft */ }
+  try {
+    const mp = join(changeDir, 'apply-manifest.json')
+    if (existsSync(mp)) {
+      const j = JSON.parse(readFileSync(mp, 'utf8'))
+      for (const f of Array.isArray(j && j.files) ? j.files : []) {
+        const p = String(f && f.path ? f.path : f || '').replace(/\\/g, '/').replace(/\/+$/, '')
+        if (p) out.add(p)
+      }
+    }
+  } catch { /* fail-soft */ }
+  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/fs-atomic.js

@@ -7,7 +7,7 @@
  * 注意：DB 持久化由 node:sqlite 引擎承担（提交即落盘 sillyspec.db + WAL 侧车），
  * 不经此处的 writeAtomicSync；sillyspec.db 不走原子写改名。
  */
-import { renameSync, unlinkSync, openSync, writeSync, fsyncSync, closeSync, statSync } from 'fs';
+import { renameSync, unlinkSync, openSync, writeSync, fsyncSync, closeSync, statSync, mkdirSync } from 'fs';
 import { randomBytes } from 'node:crypto';
 import { dirname, basename, join } from 'path';
 
@@ -64,6 +64,10 @@ export function renameSyncRetry(from, to, retries = 5) {
  */
 export function writeAtomicSync(filePath, content) {
   const dir = dirname(filePath);
+  // 父目录保位（坑 thin-flow-adopt-edge-cases 坑2，2026-09-25 实证）：adopt 收编补件等
+  // 「目录刚建、.runtime 尚不存在」的写点直接 ENOENT——原子写的契约是「写出完整文件」，
+  // 缺父目录按 mkdir -p 语义创建（已存在零成本）；权限类失败仍如实抛错。
+  try { mkdirSync(dir, { recursive: true }); } catch { /* 创建失败留给 openSync 抛真实原因 */ }
   // pid + 随机段双因子：Windows PID 重用激进，两进程可能撞同 pid，tmp 名碰撞 rename 互相覆盖。
   // crypto 随机源（Math.random 可预测，tmp 名被预猜中有 symlink 预放置理论面）
   const rnd = randomBytes(6).toString('hex');

package/src/git-helper.js

@@ -99,7 +99,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'] })
+      let value = execFileSync('git', fullArgs, { encoding: 'utf8', timeout: t, maxBuffer: GIT_MAX_BUFFER, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
       if (trim) value = value.trim()
       return { value, errorObj: null }
     } catch (e) {
@@ -128,7 +128,7 @@ export function git(cwd, args, 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 })
+  const value = execFileSync('git', fullArgs, { encoding, timeout, maxBuffer: GIT_MAX_BUFFER, stdio: ['ignore', 'pipe', 'pipe'], env, windowsHide: true })
   if (Buffer.isBuffer(value)) return value
   return trim ? value.trim() : value
 }