sillyspec 3.33.2 → 3.33.4

package/src/knowledge-match.js

@@ -292,6 +292,16 @@ function asciiWordHit(sh, text) {
   return new RegExp(`(^|[^a-z0-9-])${sh.replace(/[.*+?^${}()|[\]\\-]/g, '\\$&')}([^a-z0-9-]|$)`, 'i').test(text)
 }
 
+/** 停车场文件（未归类 unmapped 域——decisions 与 fr 两面）：检索核心零返回，文件本身
+ *  保留在盘上供人工直查（search 面以 parkingFiltered 披露指路）。2026-10-21-knowledge-tier-denoise
+ *  FR-01，对齐 FR 注入面 2026-09-29-rot-retire-inject-cap 的 unmapped 过滤口径（停车场非行为域）。 */
+const PARKING_FILES = new Set(['decisions/unmapped.md', 'fr/unmapped.md'])
+
+/** file 是否停车场文件（decisions/fr unmapped；Windows 反斜杠归一后判等）。 */
+export function isParkingFile(file) {
+  return PARKING_FILES.has(String(file || '').replace(/\\/g, '/'))
+}
+
 /**
  * 零命中查询侧词片回退（2026-09-29-decision-route-vocab）：路由行零命中时，只测「查询自己的
  * 词片」——逐 decisions 域文件数词片在条目文本（标题∪理由）的出现次数，落在「跨条目复现但
@@ -309,6 +319,7 @@ export function fallbackByQueryShingles(indexDir, taskContext) {
   if (all.length === 0) return null
   const byFile = new Map()
   for (const h of all) {
+    if (isParkingFile(h.file)) continue // 停车场文件不参与词片回退（FR-01）
     let st = byFile.get(h.file)
     if (!st) { st = { entries: [], texts: [] }; byFile.set(h.file, st) }
     st.entries.push(h)
@@ -395,16 +406,21 @@ export function matchByRouting(indexDir, taskContext) {
   }
 
   const contextLower = taskContext.toLowerCase()
-  const matched = allEntries.filter(entry => {
+  const matchedRaw = allEntries.filter(entry => {
     return entry.keywords.some(kw => keywordMatchesContext(kw, contextLower))
   })
+  // 停车场过滤（FR-01，2026-10-21-knowledge-tier-denoise）：unmapped 路由行不进命中集；
+  // 只命中停车场行 → 按零命中处理（hybrid 链继续走向量/图/词片层），json.parkingFiltered
+  // 披露被滤文件供 search 面提示人工直查（可见性不因去噪丢失）。
+  const parkingFiltered = [...new Set(matchedRaw.filter((e) => isParkingFile(e.file)).map((e) => e.file))]
+  const matched = matchedRaw.filter((e) => !isParkingFile(e.file))
 
   if (matched.length === 0) {
     return {
       matched: false,
       entries: [],
       report: 'Status: no matches',
-      json: { matched: false, entry_count: 0, entries: [] },
+      json: { matched: false, entry_count: 0, entries: [], ...(parkingFiltered.length > 0 ? { parkingFiltered } : {}) },
       decisionHits: []
     }
   }

package/src/knowledge-quicklog.js

@@ -19,6 +19,7 @@
 
 import { existsSync, readFileSync, readdirSync, statSync } from 'fs'
 import { join } from 'path'
+import { readHotCache, writeHotCache, dirStamp } from './hot-cache.js'
 
 const QUICKLOG_ENTRY_RE = /^##\s+(ql-[\w-]+)\s*\|\s*([^|]+)\s*\|\s*(.+)$/
 // 文件注记行：`- path（中文括注）` / `- path(ascii)` / 裸 `- path`（allocateQuicklogEntry
@@ -95,10 +96,23 @@ function parseQuicklogFileEntries(specBase) {
   return entries
 }
 
+/** 伪条目扫描缓存版本（解析契约变化时 bump 即全量失效）。 */
+const FLOW_ARCHIVE_CACHE_VERSION = 1
+
 /** 源②：flow 归档变更伪条目——目录内 flow-state.yaml 在场即认（不校验 yaml 内容：伪条目
- * 只需「这曾是一个 flow 变更」的存在信号，字段全来自目录名与 proposal.md，缺件逐项降级）。 */
-function parseFlowArchiveEntries(specBase) {
+ * 只需「这曾是一个 flow 变更」的存在信号，字段全来自目录名与 proposal.md，缺件逐项降级）。
+ * 跨进程缓存（FR-03，2026-10-21-knowledge-tier-denoise）：指纹=归档根子项名全集+根 mtimeMs
+ * （一次 readdir+一次 stat，廉价每次重算）——命中即免逐目录列举与逐变更 proposal.md 读。
+ * 归档件是冻结审计面（无就地编辑形态），指纹对增删/改名完备；坏缓存/失配 fail-open 全量重建。
+ * 导出供测试断言缓存三态（命中/失效/坏缓存）。 */
+export function parseFlowArchiveEntries(specBase) {
   const archiveDir = join(specBase, 'changes', 'archive')
+  const fingerprint = dirStamp(archiveDir)
+  if (fingerprint === null) return []
+  const cachePath = join(specBase, '.runtime', 'cache', 'quicklog-archive-entries.json')
+  const cached = readHotCache(cachePath, { version: FLOW_ARCHIVE_CACHE_VERSION, fingerprint })
+  if (Array.isArray(cached)) return cached
+
   let dirs
   try {
     dirs = readdirSync(archiveDir, { withFileTypes: true })
@@ -125,6 +139,7 @@ function parseFlowArchiveEntries(specBase) {
       out.push({ qlId: d.name, date, title: title || d.name, solution: '', files: [], source: 'flow' })
     } catch { /* 单目录读取异常 → 跳过该目录（fail-open，不影响其余源） */ }
   }
+  writeHotCache(cachePath, { version: FLOW_ARCHIVE_CACHE_VERSION, fingerprint, payload: out })
   return out
 }
 

package/src/knowledge-vector.js

@@ -38,7 +38,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
 import { runtimeStatePath } from './runtime-paths.js'
 import { join, dirname } from 'path'
 import { readPlatformConfig } from './sync.js'
-import { matchByRouting, fallbackByQueryShingles, parseDecisionEntries } from './knowledge-match.js'
+import { matchByRouting, fallbackByQueryShingles, parseDecisionEntries, isParkingFile } from './knowledge-match.js'
 
 const VECTOR_TIMEOUT_MS = 3000
 const ENDPOINT_PATH = '/api/spec/knowledge/vector-search'
@@ -181,12 +181,14 @@ function specPathToFile(specPath) {
   return String(specPath).replace(/^knowledge\//, '').replace(/\\/g, '/')
 }
 
-/** 平台候选 → matchKnowledge 同构结果（策略面全本地解析）。 */
-function buildResultFromPlatform(indexDir, pvResults) {
+/** 平台候选 → matchKnowledge 同构结果（策略面全本地解析）。导出供测试（FR-01 停车场
+ *  候选丢弃断言；策略面全在本地解析的契约不变）。 */
+export function buildResultFromPlatform(indexDir, pvResults) {
   const byFile = new Map()
   for (const r of pvResults) {
     const file = specPathToFile(r.spec_path)
     if (!file.startsWith('decisions/')) continue
+    if (isParkingFile(file)) continue // 停车场候选丢弃（FR-01）——平台向量语料含 unmapped，策略面本地滤
     if (!byFile.has(file)) byFile.set(file, [])
     byFile.get(file).push(r)
   }

package/src/machine-interface.js

@@ -352,9 +352,24 @@ export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot, s
       // 绿缓存根：与 runtimeRoot 解析同源（drift 锚主仓口径）；解析失败 null → 不缓存不命中
       let greenRoot = null;
       try { greenRoot = resolveRuntimeRoot({ runtimeRoot, specDriftAnchor }, specRoot); } catch { greenRoot = null; }
-      const vt = greenCachedCheck({ kind: 'test', greenRoot, cwd, specBase: specRoot, changeName },
-        () => runVerifyTestCheck({ cwd, specBase: specRoot, changeName, ctx }),
-        (hit) => ({ status: 'passed', exitCode: 0, durationMs: 0, resultPath: null, mode: null, fallbackReason: null, exemptedCount: 0, cached: true, reason: greenCacheNotice(hit, 'verify-test') }));
+      // 失败签名复用（2026-10-21-verify-reuse-large-repo FR-03）：真跑前咨询上次质量扫描失败——
+      // 同签名（代码指纹×豁免面）+ 快照口径一致（CLI 门主仓口径跑，plannedSnapshot=false）+
+      // 30min 窗口 → 不重跑，合成 failed（♻️ 披露 + 四出路）照常进 check not-ok 语义。
+      // gate verify 预检每轮整跑同签名失败 10~13.5 分钟的浪费由此消除（dsh 0ff6f1c8 取证）。
+      let vt = null;
+      try {
+        const { consultFailedScanReuse, synthesizeReusedFailedCheck } = await import('./run/verify-quality-scan.js');
+        const consult = consultFailedScanReuse({
+          specBase: specRoot, cwd, changeName, plannedSnapshot: false,
+          forceRerun: Boolean(process.env.SILLYSPEC_VERIFY_QUALITY_SCAN_RERUN),
+        });
+        if (consult.reuse) vt = synthesizeReusedFailedCheck(consult.record);
+      } catch { /* 咨询异常 → 照旧 green-cache/真跑 */ }
+      if (vt == null) {
+        vt = greenCachedCheck({ kind: 'test', greenRoot, cwd, specBase: specRoot, changeName },
+          () => runVerifyTestCheck({ cwd, specBase: specRoot, changeName, ctx }),
+          (hit) => ({ status: 'passed', exitCode: 0, durationMs: 0, resultPath: null, mode: null, fallbackReason: null, exemptedCount: 0, cached: true, reason: greenCacheNotice(hit, 'verify-test') }));
+      }
       const vtWarnings = [];
       if (vt.cached) vtWarnings.push(vt.reason);
       if (vt.status === 'skipped') {
@@ -455,7 +470,7 @@ export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot, s
     // 回合）：①target_files reconcile 只读跑（reconcileTargetFiles 纯计算不落盘，--done 的写结果
     // 文件在其调用方）；②stage review 在场探测（marker+review.json——缺则报预期路径，同 --done
     // Stage Review Gate 口径，只报缺不生成）。全只读零副作用；未传 full 零行为变化。
-    if (full && (stage === 'verify' || stage === 'execute')) {
+    if (full && (stage === 'verify' || stage === 'execute' || stage === 'brainstorm' || stage === 'plan')) {
       // e1. reconcile（verify --done 的 target_files 对账门）
       if (stage === 'verify') {
         try {
@@ -484,10 +499,13 @@ export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot, s
           });
         }
       }
-      // e2. stage review 在场探测（execute --done 的 Stage Review Gate——verify 不在其列，
-      // 坑 stage-review-verify-enum-gap 2026-10-11：gate 实际只拦 brainstorm/plan/execute，
-      // register 枚举亦无 verify，verify 阶段不产 stage review 期望；verify 的真实门面是 e1 对账）
-      if (stage === 'execute') try {
+      // e2. stage review 在场探测（Stage Review Gate 拦截面的 --full 预检——brainstorm/plan/execute
+      // 三阶段与 gates.js Stage Review Gate 实拦范围逐字对齐；verify 不在其列，坑
+      // stage-review-verify-enum-gap 2026-10-11：register 枚举亦无 verify，verify 阶段不产
+      // stage review 期望；verify 的真实门面是 e1 对账。dsh z1 实证（2026-10-21-p0-p1-hardening
+      // FR-04）：此前 execute 单值使 brainstorm Step8 --done 被 Stage Review Gate「伏击」——
+      // gate 预检全绿而 --done 被拦，46 分钟+3 轮子代理评审才过）
+      if (stage === 'execute' || stage === 'brainstorm' || stage === 'plan') try {
         const { getLatestStageReviewRunId } = await import('./stage-review.js');
         const rrRoot = runtimeRoot || join(specRoot, '.runtime');
         const runId = getLatestStageReviewRunId(rrRoot, stage, changeName);
@@ -496,7 +514,7 @@ export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot, s
           code: checkCode('full-stage-review') || 'full_stage_review_missing',
           ok: !!runId,
           errors: !runId
-            ? [`缺 ${stage} 阶段的 stage review.json（tier=independent 要求独立审查产出）——execute --done 将被 Stage Review Gate 拦；可先 sillyspec register-stage-review --change ${changeName} --stage ${stage} 生成骨架再填（降级条款照 review.json reviewerNotes 首行留痕）`]
+            ? [`缺 ${stage} 阶段的 stage review.json（tier=independent 要求独立审查产出）——${stage} --done 将被 Stage Review Gate 拦；可先 sillyspec register-stage-review --change ${changeName} --stage ${stage} 生成骨架再填（降级条款照 review.json reviewerNotes 首行留痕）`]
             : [],
           data: { runId: runId || null },
         });
@@ -518,9 +536,12 @@ export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot, s
     //    register 指引；在场 → 静默 ok。独立 check id 不与 --full 的 full-stage-review 碰撞，
     //    error 语义（--done 拦）仍归 --full 档与 --done 本体。
     // stage 期望面对齐（坑 stage-review-verify-enum-gap，2026-10-11 实证）：Stage Review Gate
-// 实际只拦 brainstorm/plan/execute（gates.js），register-stage-review 枚举亦无 verify——
-// verify 阶段不产 stage review 提示（提示命令不可执行 + 指称的门禁不存在，双重误导）。
-if (!full && stage === 'execute') {
+    // 实际只拦 brainstorm/plan/execute（gates.js），register-stage-review 枚举亦无 verify——
+    // verify 阶段不产 stage review 提示（提示命令不可执行 + 指称的门禁不存在，双重误导）。
+    // 覆盖面扩全（2026-10-21-p0-p1-hardening FR-04 / dsh z1 实证）：此前 execute 单值——brainstorm
+    // Step8 --done 被 Stage Review Gate 伏击（预检绿灯 vs 收口拦截口径不一致，损失 46 分钟）。
+    // 现与 gates.js 拦截面三阶段逐字对齐；文案按 stage 参数化。
+    if (!full && (stage === 'execute' || stage === 'brainstorm' || stage === 'plan')) {
       try {
         const { getLatestStageReviewRunId } = await import('./stage-review.js');
         const rrRoot = runtimeRoot || join(specRoot, '.runtime');
@@ -531,7 +552,7 @@ if (!full && stage === 'execute') {
           ok: true,
           informational: true,
           warnings: runId ? [] : [
-            `缺 ${stage} 阶段的 stage review.json——execute --done 的 Stage Review Gate 会拦（本提示不改变 gate 结论）。先产出评审再注册：sillyspec register-stage-review --change ${changeName} --stage ${stage}（骨架生成后填，或 --from review.json 过继独立评审产出）`,
+            `缺 ${stage} 阶段的 stage review.json——${stage} --done 的 Stage Review Gate 会拦（本提示不改变 gate 结论）。先产出评审再注册：sillyspec register-stage-review --change ${changeName} --stage ${stage}（骨架生成后填，或 --from review.json 过继独立评审产出）`,
           ],
           data: { runId: runId || null },
         });

package/src/progress/change-registry.js

@@ -3,6 +3,7 @@
 // pm._changePath（persistence-core 留 facade 本体）。无共享常量依赖。
 import { existsSync, mkdirSync, readFileSync, renameSync } from 'fs';
 import { join } from 'path';
+import { hostname } from 'os';
 import { appendDeletedLedger } from '../deleted-ledger.js';
 
 // 所有权活跃心跳窗缺省（2026-09-14-change-ownership-guards task-02 / FR-01）：owner 非本会话
@@ -290,6 +291,7 @@ export class ChangeRegistry {
    *   - opts.forced（--takeover）            → takeover-forced       放行（无条件接管，调用方重写 owner 留痕）
    *   - owner 为空（无行/NULL）               → no-owner              放行（存量无主行，任何会话可接管）
    *   - owner === selfSession                 → self                  放行（本会话自有 change 零路径变化）
+   *   - owner 本机匿名占位 + selfSession 显式 → takeover-anon-upgrade 放行（同主机显式身份自动升级，FR-05）
    *   - owner 他人 且 now-last_active ≥ 窗口  → takeover-stale        放行（窗口外自动接管重写）
    *   - owner 他人 且活跃窗内                 → blocked-active-owner  拒绝（allowed:false，调用方打结构化错误）
    * last_active 缺失/不可解析按陈旧处理：无法证明新鲜即不拦——护栏拦「可证活跃」，不因时间戳
@@ -313,6 +315,19 @@ export class ChangeRegistry {
     if (opts.forced) return { allowed: true, action: 'takeover-forced', owner, lastActive, heartbeatMs };
     if (owner === null) return { allowed: true, action: 'no-owner', owner: null, lastActive, heartbeatMs };
     if (owner === opts.selfSession) return { allowed: true, action: 'self', owner, lastActive, heartbeatMs };
+    // 匿名占位所有权自动升级（2026-10-21-p0-p1-hardening FR-05 / dsh z1 实证：首调未设
+    // SESSION_ID → owner 落 anon@<host>，同机 agent 数分钟后补设显式身份，被
+    // blocked-active-owner 拦 15 分钟活跃窗，被迫 --takeover——自己锁自己）。anon@ 是机器级
+    // 降级标识（缺省只拦他机），同主机的显式身份（--session/env 三级解析，非 anon 降级）严格
+    // 更具体：直接放行升级（调用方 setChangeOwner 重写留痕），不必 --takeover。跨主机匿名
+    // （owner 的 @ 后缀 ≠ 本机 hostname）与任何显式 owner 持有不在此列，照旧新鲜度判定。
+    if (
+      typeof owner === 'string' && owner.startsWith('anon@')
+      && typeof opts.selfSession === 'string' && opts.selfSession && !opts.selfSession.startsWith('anon@')
+      && owner === `anon@${hostname()}`
+    ) {
+      return { allowed: true, action: 'takeover-anon-upgrade', owner, lastActive, heartbeatMs };
+    }
     // owner 他人：新鲜度决定拒绝 / 自动接管
     const lastMs = lastActive ? new Date(lastActive).getTime() : NaN;
     const nowMs = Number.isFinite(opts.nowMs) ? opts.nowMs : Date.now();

package/src/progress/shared.js

@@ -16,6 +16,10 @@ export const STAGE_LABELS = {
   quick: '⚡ 快速任务',
   explore: '🧭 自由探索',
   archive: '📦 归档变更',
+  // thin 展示键（2026-10-21-overview-thin-stage）：轻量变更出身投影专用（overview
+  // stage_label 查找），不进 VALID_STAGES/STAGE_ORDER——thin 不走阶段机，加进阶段
+  // 清单会建空阶段行扰动级联。◈ 对齐 SillyHub 前端旁路徽标字形（◈ thin）。
+  thin: '◈ 轻量变更',
 };
 
 // 完整阶段顺序（含 scan），仅用于展示/迭代顺序

package/src/progress/stage-machine.js

@@ -9,6 +9,9 @@ import { writeAtomicSync } from '../fs-atomic.js';
 import { timeAgo } from '../datetime.js';
 import { runValidators } from '../stage-contract.js';
 import { QUICK_SID_RE } from '../run/shared.js';
+// thin 出身投影读 flow-state（2026-10-21-overview-thin-stage）：叶子模块，与 progress.js
+// 2026-10-13-thin-sync-stage 同款 import 先例，零新依赖链。
+import { readFlowState } from '../flow-state.js';
 import { VALID_STAGES, STAGE_LABELS, STAGE_ORDER, MAIN_FLOW_ORDER, SPEC_DIR_NAME, CURRENT_VERSION, STALL_WARN_DAYS, emptyStage } from './shared.js';
 
 // quick 会话行（quick-<8hex>）按设计无实体 changes/ 目录（progress.js initChange 跳过建目录），
@@ -314,12 +317,22 @@ export class StageMachine {
     for (const cn of changes) {
       const data = this.pm.read(cwd, cn);
       const dirMissing = _isGhostChange(changesRoot, cn);
+      // thin 出身投影（2026-10-21-overview-thin-stage，对齐 2026-10-13-thin-sync-stage
+      // 平台上行同款覆写）：本地行出生恒 'brainstorm'（thin 不走阶段机），总览按
+      // flow-state tier 覆写展示值——否则面板把轻量变更渲染成 brainstorm 主管线。仅覆写
+      // envelope 载荷，DB 行不动；listChanges 恒回 active 行（归档不进循环，sync 侧的
+      // status 守卫在此天然满足）；flow-state 缺失/损坏 readFlowState→null、tier=thick
+      // 一律按行值（fail-open 同 sync 口径）。
+      let currentStage = data?.currentStage || null;
+      if (currentStage && readFlowState(this.pm._changePath(cwd, cn))?.tier === 'thin') {
+        currentStage = 'thin';
+      }
       const entry = {
         name: cn,
         readable: !!data,
         ghost: dirMissing,
-        current_stage: data?.currentStage || null,
-        stage_label: data ? (STAGE_LABELS[data.currentStage] || data.currentStage || null) : null,
+        current_stage: currentStage,
+        stage_label: currentStage ? (STAGE_LABELS[currentStage] || currentStage) : null,
         last_active: this.pm._dumpIso(data?.lastActive) || null,
       };
       if (data) {

package/src/progress.js

@@ -12,6 +12,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, appendFileSync, copyFileSync, readdirSync, statSync, realpathSync } from 'fs';
 import { RUNTIME_TEMP_DIRNAME, runtimeTempPath } from './runtime-paths.js'
+import { timedSync } from './timing.js';
 import { join, basename, dirname, resolve, sep } from 'path';
 import { tmpdir, hostname } from 'os';
 import { writeAtomicSync } from './fs-atomic.js';
@@ -959,6 +960,10 @@ export class ProgressManager {
   }
 
   _write(cwd, data, changeName = null) {
+    return timedSync('state-write', () => this._writeImpl(cwd, data, changeName))
+  }
+
+  _writeImpl(cwd, data, changeName = null) {
     const cn = changeName || data.currentChange;
     if (!cn) {
       console.warn('⚠️  _write: 无变更名，跳过写入');

package/src/redomain-unmapped.js

@@ -0,0 +1,204 @@
+/**
+ * redomain-unmapped.js — unmapped 停车场存量批量清偿驱动（FR-04，2026-10-21-knowledge-tier-denoise）
+ *
+ * 决策/FR 条目落 unmapped 是域路由失败的兜底——源头匹配器已修（2026-10-15-module-path-glob-match），
+ * 存量需机器通道清偿（decision-redomain.js 头注：迁移原语已在，缺批量推断与编排）。本模块即编排：
+ *   - decisions 条目：文件锚（「文件：」字段行）逐文件 matchedModuleIds 投票 → 目标真模块域
+ *   - fr 条目：来源变更覆盖面（frCoverageFiles 三源：归档 design 交付表 ∪ change-patch ∪ git）→ 同款投票
+ *   - 投票零命中/无锚 → 留 unmapped 并在报告列明残量原因（宁漏勿错，不裸删）
+ * 迁移原语复用 redomainDecisionEntries / redomainFrEntries：段字节整体搬运、迁域不换号、
+ * 目标域同 id 同变更冲突跳过、幂等；INDEX 路由行随原语内 sync 维护（FR-02 泛词已退役）。
+ * 只动 knowledge 活库，不回写归档件（D-unmapped-152 死路：归档是冻结审计面）。
+ */
+import { existsSync, readFileSync } from 'fs'
+import { join } from 'path'
+import { splitKnowledgeSections, discoverModuleIndex } from './decision-distill.js'
+import { matchedModuleIds, frCoverageFiles, FR_SECTION_RE } from './fr-index.js'
+import { anchorFilePaths } from './knowledge-match.js'
+import { redomainDecisionEntries, sectionMeta } from './decision-redomain.js'
+import { redomainFrEntries } from './redomain.js'
+
+const DECISION_FILE_LINE_RE = /^文件[：:]\s*(.+)$/
+const DECISION_ANCHOR_LINE_RE = /^锚点[：:]\s*(.*)$/
+const FR_HEADER_RE = /^## (FR-[\w.-]+-\d+|FR-\d+)\s*(.*)$/
+
+/** 决策段 → 路径数组：双源——「文件：」行集（显式字段）∪「锚点：」行 anchorFilePaths 路径
+ *  提取（本仓实证 443 条全走锚点源：distill 的 文件： 字段极少发射，锚点是标准兜底
+ *  命中源——与 knowledge-match/knowledge-graph 的 anchors 边同判法）。 */
+function filesFromDecisionSection(lines) {
+  const out = []
+  for (const l of lines) {
+    const line = String(l || '')
+    const m = line.match(DECISION_FILE_LINE_RE)
+    if (m) out.push(...String(m[1]).split(/[,，、\s]+/).map((s) => s.replace(/\\/g, '/')).filter(Boolean))
+    const a = line.match(DECISION_ANCHOR_LINE_RE)
+    if (a) out.push(...anchorFilePaths(a[1]))
+  }
+  return out
+}
+
+/** FR 段「变更：」行（source change 迁移过滤键同款判法）。 */
+function changeFromSection(lines) {
+  for (const l of lines) {
+    const m = String(l || '').match(/^变更[：:]\s*(\S+)/)
+    if (m) return m[1]
+  }
+  return null
+}
+
+/** 文件集 → 目标域投票：逐文件 matchedModuleIds（修复后的 glob 匹配器，多命中并计），
+ *  最高票为域；平票字典序（确定性）。零命中 → null（留停车场）。 */
+function voteDomain(files, moduleIndex) {
+  const tally = new Map()
+  for (const f of files) {
+    for (const mid of matchedModuleIds(moduleIndex, f)) tally.set(mid, (tally.get(mid) || 0) + 1)
+  }
+  if (tally.size === 0) return null
+  return [...tally.entries()].sort((a, b) => (b[1] - a[1]) || (a[0] < b[0] ? -1 : 1))[0][0]
+}
+
+function planDecisionsFace(knowledgeRoot, archiveRoot, moduleIndex) {
+  const fromPath = join(knowledgeRoot, 'decisions', 'unmapped.md')
+  if (!existsSync(fromPath)) return { absent: true, groups: [], leftover: [] }
+  const parsed = splitKnowledgeSections(readFileSync(fromPath, 'utf8'))
+  const groups = new Map()
+  const leftover = []
+  for (const s of parsed.sections) {
+    const meta = sectionMeta(s)
+    if (!meta) continue
+    // 三源：文件： 行 ∪ 锚点路径（显式锚优先）→ 都不中再走来源变更覆盖面（fr 面同款——
+    // 本仓实证 417/443 锚点「未记录」，436/443 有「变更：」行，覆盖面是主力推断源）
+    const files = filesFromDecisionSection(s.lines)
+    const change = changeFromSection(s.lines)
+    let domain = files.length > 0 ? voteDomain(files, moduleIndex) : null
+    if (!domain && change) {
+      const cov = [...frCoverageFiles({ archiveRoot, changeName: change })]
+      if (cov.length > 0) domain = voteDomain(cov, moduleIndex)
+    }
+    if (!domain) {
+      const reason = files.length === 0
+        ? (change ? '锚点无路径且来源覆盖面不命中任何模块' : '无文件锚/锚点路径且无来源变更')
+        : '锚不命中任何模块'
+      leftover.push({ id: meta.id, title: meta.title, reason })
+      continue
+    }
+    if (!groups.has(domain)) groups.set(domain, [])
+    groups.get(domain).push(meta.id)
+  }
+  return {
+    groups: [...groups.entries()].map(([domain, ids]) => ({ domain, ids })),
+    leftover,
+    total: parsed.sections.filter((s) => sectionMeta(s)).length,
+  }
+}
+
+function planFrFace(knowledgeRoot, archiveRoot, moduleIndex) {
+  const fromPath = join(knowledgeRoot, 'fr', 'unmapped.md')
+  if (!existsSync(fromPath)) return { absent: true, groups: [], leftover: [] }
+  const parsed = splitKnowledgeSections(readFileSync(fromPath, 'utf8'), { sectionRegex: FR_SECTION_RE, buildId: (n) => n })
+  const groups = new Map()
+  const leftover = []
+  for (const s of parsed.sections) {
+    const h = FR_HEADER_RE.exec(s.lines[0] || '')
+    if (!h) continue
+    const id = h[1]
+    const title = (h[2] || '').trim()
+    const change = changeFromSection(s.lines)
+    const files = change ? [...frCoverageFiles({ archiveRoot, changeName: change })] : []
+    const domain = files.length > 0 ? voteDomain(files, moduleIndex) : null
+    if (!domain) {
+      leftover.push({ id, title, reason: !change ? '无来源变更' : '来源变更覆盖面不命中任何模块' })
+      continue
+    }
+    if (!groups.has(domain)) groups.set(domain, [])
+    groups.get(domain).push(id)
+  }
+  return {
+    groups: [...groups.entries()].map(([domain, ids]) => ({ domain, ids })),
+    leftover,
+    total: parsed.sections.filter((s) => FR_HEADER_RE.exec(s.lines[0] || '')).length,
+  }
+}
+
+/**
+ * 干跑计划：各面分组（目标域 → 条目 id 集）与残量（id/标题/不可推断原因）。
+ * @param {{knowledgeRoot: string, archiveRoot: string}} opts
+ * @returns {{decisions: object, fr: object}} 各面 {absent?, groups, leftover, total?}
+ */
+export function planUnmappedRedomain({ knowledgeRoot, archiveRoot }) {
+  const moduleIndex = discoverModuleIndex(knowledgeRoot) || { modules: {} }
+  return {
+    decisions: planDecisionsFace(knowledgeRoot, archiveRoot, moduleIndex),
+    fr: planFrFace(knowledgeRoot, archiveRoot, moduleIndex),
+  }
+}
+
+/**
+ * 执行清偿（先内部重算计划——apply 自带干跑等价性；幂等：重跑同批 0 迁移）。
+ * 单组失败不拦其余组（逐组收集结果与错误如实上报）。
+ * @param {{knowledgeRoot: string, archiveRoot: string, faces?: string[]}} opts faces 缺省双面
+ * @returns {{results: object, plan: object}} results 各面 {moved, movedByDomain, skippedConflicts, errors}
+ */
+export function applyUnmappedRedomain({ knowledgeRoot, archiveRoot, faces = ['decisions', 'fr'] }) {
+  const plan = planUnmappedRedomain({ knowledgeRoot, archiveRoot })
+  const empty = { moved: 0, movedByDomain: {}, skippedConflicts: [], errors: [] }
+  const results = {}
+  const run = (groups, migrate) => {
+    const acc = { moved: 0, movedByDomain: {}, skippedConflicts: [], errors: [] }
+    for (const g of groups) {
+      try {
+        const res = migrate(g)
+        acc.moved += res.moved.length
+        acc.movedByDomain[g.domain] = res.moved.length
+        if (Array.isArray(res.skippedConflicts)) acc.skippedConflicts.push(...res.skippedConflicts.map((id) => `${g.domain}:${id}`))
+      } catch (e) {
+        acc.errors.push({ domain: g.domain, error: e && e.message ? e.message : String(e) })
+      }
+    }
+    return acc
+  }
+  results.decisions = faces.includes('decisions')
+    ? run(plan.decisions.groups,
+        (g) => redomainDecisionEntries({ knowledgeRoot, from: 'unmapped', to: g.domain, anchors: g.ids }))
+    : { ...empty }
+  results.fr = faces.includes('fr')
+    ? run(plan.fr.groups,
+        (g) => redomainFrEntries({ knowledgeRoot, from: 'unmapped', to: g.domain, anchors: g.ids }))
+    : { ...empty }
+  return { results, plan }
+}
+
+/**
+ * CLI 子命令（stages/knowledge.js 经 tryImportSubcommandImpl 装载）：
+ * sillyspec knowledge redomain-unmapped [--face decisions|fr] [--apply]
+ * 缺省 dry-run 只出报告（JSON 出口与 search/graph 同族）；--apply 幂等落盘。
+ */
+export async function cmdRedomainUnmapped(dir, args, opts = {}) {
+  const specBase = opts.specDir || join(dir, '.sillyspec')
+  const knowledgeRoot = join(specBase, 'knowledge')
+  const archiveRoot = join(specBase, 'changes', 'archive')
+  const face = args.includes('--face')
+    ? (args[args.indexOf('--face') + 1] === 'decisions' ? 'decisions' : args[args.indexOf('--face') + 1] === 'fr' ? 'fr' : 'all')
+    : 'all'
+  const apply = args.includes('--apply')
+  const emit = (ok, data, error) => console.log(JSON.stringify({ ok, ...data, ...(error ? { error } : {}) }, null, 2))
+
+  if (!existsSync(join(knowledgeRoot, 'INDEX.md'))) {
+    emit(false, {}, { code: 'knowledge_dir_missing', path: knowledgeRoot })
+    return
+  }
+  if (apply) {
+    const faces = face === 'all' ? ['decisions', 'fr'] : [face]
+    const { results, plan } = applyUnmappedRedomain({ knowledgeRoot, archiveRoot, faces })
+    const leftoverFace = (name) => (faces.includes(name) ? plan[name].leftover : [])
+    emit(true, {
+      mode: 'apply', face,
+      decisions: results.decisions,
+      fr: results.fr,
+      leftover: { decisions: leftoverFace('decisions'), fr: leftoverFace('fr') },
+    })
+    return
+  }
+  const plan = planUnmappedRedomain({ knowledgeRoot, archiveRoot })
+  emit(true, { mode: 'dry-run', face, decisions: plan.decisions, fr: plan.fr })
+}

package/src/redomain.js

@@ -14,7 +14,7 @@
  */
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs'
 import { join } from 'path'
-import { splitKnowledgeSections, joinKnowledgeFile, syncIndexRoutingLines } from './decision-distill.js'
+import { splitKnowledgeSections, joinKnowledgeFile, syncIndexRoutingLines, FR_ROUTE_STRIP_TOKENS } from './decision-distill.js'
 import { FR_SECTION_RE } from './fr-index.js'
 import { writeAtomicSync } from './fs-atomic.js'
 
@@ -141,9 +141,11 @@ export function redomainFrEntries({ knowledgeRoot, from, to, anchors = null, byC
     syncIndexRoutingLines(knowledgeRoot, {
       section: 'FR 需求索引',
       subdir: 'fr',
+      // 泛词退役（FR-02，2026-10-21-knowledge-tier-denoise）：与 fr-index.js 蒸馏侧同款模板
+      stripTokens: FR_ROUTE_STRIP_TOKENS,
       makeLine: (d) => d.startsWith('auto-')
-        ? `- ${d}|${d.slice(5)}|FR|需求|承接 → [fr/${d}.md](fr/${d}.md)`
-        : `- ${d}|FR|需求|承接 → [fr/${d}.md](fr/${d}.md)`,
+        ? `- ${d}|${d.slice(5)} → [fr/${d}.md](fr/${d}.md)`
+        : `- ${d} → [fr/${d}.md](fr/${d}.md)`,
     })
   } catch { /* INDEX 缺席/同步失败不拦迁移（主手术已成） */ }
   const after = existsSync(indexPath) ? readFileSync(indexPath, 'utf8') : ''