sillyspec 3.32.9 → 3.33.0

package/src/decision-distill.js

@@ -22,6 +22,7 @@
  * 零输出：无 decisions.md 或无入选条目 → skipped 带原因，不写任何文件、不动 INDEX。
  */
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { modulePathMatches } from './modules.js'
 import { basename, dirname, join } from 'node:path'
 
 /** FR-02：有实现影响的五类 type（scope 与未知 type 的 confirmed/accepted 不入选） */
@@ -36,7 +37,29 @@ const UNMAPPED_DOMAIN = 'unmapped'
 /** 旧格式容错占位值（FR-01：缺锚点/缺 headHash 不阻断） */
 const NOT_RECORDED = '未记录'
 
-/** 多行/带空白值压成单行字段值（条目行是单行契约） */
+/**
+ * 锚点自动回填候选（2026-10-15-decision-anchor-backfill 单一源；收割端 flow-parity 与
+ * 蒸馏渲染端共用）。条目正文（答案/理由散文）中的路径形态 token——「恰一个唯一」即高置信
+ * 落点，返回该 token；多候选/无 token 返回 null（保守：错锚比无锚更误导 impact 查询与
+ * 悬空检查）。收益率探针（2026-10-15）：恰一路径口径救 28%（本仓 174/616、平台 150/543）。
+ * 过滤黑名单（存量干跑实测坏锚类）：知识治理面（.sillyspec/）、运行时面（.runtime/）、
+ * 归档与变更工件（changes/、allowed_paths 段）、知识互引（knowledge/、decisions/、fr/）、
+ * 消费仓坑文档目录（docs/sillyspec/）、前导 / 路径碎片、遥测日志扩展（.jsonl/.log）、
+ * repo:// 跨仓协议前缀剥除。token 须带扩展名收尾（:行号 形态锚点契约原生支持）。
+ * @param {string} text 条目正文拼接（答案/理由/question 等）
+ * @returns {string|null}
+ */
+export function anchorBackfillCandidate(text) {
+  const raw = String(text || '').match(/[A-Za-z0-9_\-.\\/:]+/g) || []
+  const pathed = [...new Set(raw
+    .map((t) => t.replace(/\\/g, '/').replace(/^repo:\/\//, '').replace(/\/+$/, '').replace(/:$/, ''))
+    .filter((t) => t.includes('/')
+      && /\.[A-Za-z0-9]{1,10}(:\d+)?$/.test(t)
+      && !/^(\.sillyspec|\.runtime|changes|knowledge|decisions|fr|docs\/sillyspec|allowed_paths)(\/|$)/.test(t)
+      && !t.startsWith('/')
+      && !/\.(jsonl|log)$/i.test(t)))]
+  return pathed.length === 1 ? pathed[0] : null
+}/** 多行/带空白值压成单行字段值（条目行是单行契约） */
 function oneLine(s) {
   return String(s ?? '').replace(/\s*\r?\n\s*/g, ' ').trim()
 }
@@ -274,7 +297,7 @@ function matchImpactsToModules(impacts, moduleIndex) {
   const hits = []
   for (const t of tokens) {
     for (const { id, p } of modPaths) {
-      if (t === p || t.startsWith(p + '/')) { if (!hits.includes(id)) hits.push(id); break }
+      if (modulePathMatches(t, p)) { if (!hits.includes(id)) hits.push(id); break }
     }
   }
   if (hits.length === 0) {
@@ -313,11 +336,17 @@ function newDomainPreamble(domain) {
  * 变更：行（2026-08-28，坑 distill-cross-change-supersede）：D-xxx 编号是变更内局部序号，
  * 跨变更同号（两个 D-002）互不相干——条目必须携带变更名限定，消费方（knowledge-match/
  * docs-check 的字段行解析）只认各自标签，新增字段行是增量安全。 */
-function renderBlockLines(entry, headHash, supersedesNote, changeName) {
-  const lines = [`## ${entry.id} ${oneLine(entry.title)}`.replace(/\s+$/, '')]
+function renderBlockLines(entry, headHash, supersedesNote, changeName, sectionNumber, originId) {
+  const lines = [`## ${sectionNumber}@v${entry.version} ${oneLine(entry.title)}`.replace(/\s+$/, '')]
   lines.push(`状态：${entry.selected}`)
   if (changeName) lines.push(`变更：${oneLine(changeName)}`)
-  lines.push(`锚点：${oneLine(entry.anchor) || NOT_RECORDED}`)
+  // 原编号（2026-10-14-decision-global-id-epoch）：epoch 形态溯源字段——变更行后/锚点行前
+  // （不破「文件：紧跟锚点」行序红线）；legacy 复用段（originId=null）不渲染，形态零变化
+  if (originId) lines.push(`原编号：${oneLine(originId)}`)
+  // 锚点自动回填（2026-10-15-decision-anchor-backfill）：源条目未填锚点时，从条目正文
+  // （答案/理由）提取路径形态 token——「恰一个唯一」即高置信落点（正文明确只谈一个文件），
+  // 多候选/无 token 保持未记录（保守：错锚比无锚更误导 impact 查询与悬空检查）。
+  lines.push(`锚点：${oneLine(entry.anchor) || anchorBackfillCandidate([entry.answer, entry.reason, entry.normalizedRequirement, entry.question].join('\n')) || NOT_RECORDED}`)
   // 文件行（FR-01/D-001@v1）：仅非空渲染——存量条目零迁移，幂等重归档不添空行
   if (entry.files && entry.files.length > 0) lines.push(`文件：${entry.files.join(', ')}`)
   lines.push(`最近确认：${oneLine(headHash) || NOT_RECORDED}`)
@@ -336,12 +365,14 @@ function renderBlockLines(entry, headHash, supersedesNote, changeName) {
 }
 
 /** 知识文件切段：preamble 行 + 条目段（段边界 = 下一节头）。
- * 段的变更归属取段内 `变更：<name>` 行；无该行的历史条目 → change=null（legacy：
- * 升级前落库的条目，不参与新条目的同号匹配/supersede——只共存不误删）。
+ * 段的变更归属取段内 `变更：<name>` 行，「来源：<name>` 兜底（2026-10-14-decision-id-p2-hardening：
+ * 08-24 首修形态残留——读出后带来源的 legacy 段参与同变更同号匹配/supersede，重蒸馏在位更新收敛）；
+ * 无任何限定行的历史条目 → change=null（legacy：升级前落库的条目，不参与新条目的同号匹配——只共存不误删）。
  * 2026-09-18-fr-index-l1 参数化：sectionRegex/buildId 经参（decisions 缺省不变；fr 侧传 FR 节头
  * 正则与恒等 id），decisions 调用点零改动。 */
 export function splitKnowledgeSections(content, opts = {}) {
-  const sectionRegex = opts.sectionRegex || /^## (D-\d+)@v(\d+)\s*(.*)$/
+  // 节头号双形态（2026-10-14-decision-global-id-epoch）：局部 D-011@v1 与全局 D-<域>-042@v1 并存
+  const sectionRegex = opts.sectionRegex || /^## (D-(?:[A-Za-z0-9_\-\u4e00-\u9fff]+-)?\d+)@v(\d+)\s*(.*)$/
   const buildId = opts.buildId || ((n, v) => `${n}@v${v}`)
   const sections = []
   const preamble = []
@@ -359,8 +390,15 @@ export function splitKnowledgeSections(content, opts = {}) {
   if (cur) sections.push(cur)
   for (const s of sections) {
     s.id = buildId(s.number, s.version)
-    const cm = s.lines.find(l => /^变更[：:]/.test(l))
-    s.change = cm ? cm.replace(/^变更[：:]\s*/, '').trim() || null : null
+    // 「变更：」优先、「来源：」兜底（行内前缀按命中行剥除；无任何限定行 → null 不互认）
+    const cm = s.lines.find(l => /^变更[：:]/.test(l)) || s.lines.find(l => /^来源[：:]/.test(l))
+    s.change = cm ? cm.replace(/^(变更|来源)[：:]\s*/, '').trim() || null : null
+    // 原编号（2026-10-14-decision-global-id-epoch 溯源字段）：「原编号：D-011@v1」→ origin/originNumber；
+    // legacy 段无该行 → null（幂等匹配谓词按号兜底）
+    const oi = s.lines.find(l => /^原编号[：:]/.test(l))
+    s.origin = oi ? oi.replace(/^原编号[：:]\s*/, '').trim() || null : null
+    const on = s.origin ? /^(D-(?:[A-Za-z0-9_\-\u4e00-\u9fff]+-)?\d+)@v?\d+/.exec(s.origin) : null
+    s.originNumber = on ? on[1] : null
   }
   return { preamble, sections }
 }
@@ -385,14 +423,23 @@ export function joinKnowledgeFile(preamble, sections) {
  * 升级前落库）不与任何新条目互认，只共存不误删。
  * @returns {{ action: 'append'|'update'|'supersede' }|null} null = 同变更同号高版本已落库，迟到低版本不降级。
  */
-function applyEntryToSections(sections, entry, headHash) {
+/** 同变更同段匹配谓词（2026-10-14-decision-global-id-epoch 扩展）：变更一致 且
+ *  （段号==条目局部号 或 段.原编号号段==条目局部号）——legacy 段按号匹配、epoch 段按原编号匹配。
+ * @returns {{action: 'append'|'update'|'supersede'}|null} null = 同变更同段高版本已落库，迟到低版本不降级。 */
+function sameDecisionNumber(s, entry) {
+  return (s.change || null) === (entry.change || null) && (s.number === entry.number || s.originNumber === entry.number)
+}
+
+function applyEntryToSections(sections, entry, headHash, sectionNumber, originId) {
   const change = entry.change || null
-  const sameNumber = sections.filter(s => s.number === entry.number && (s.change || null) === change)
+  const sameNumber = sections.filter(s => sameDecisionNumber(s, entry))
   if (sameNumber.some(s => s.version > entry.version)) return null
   let action
   let supersedesNote = oneLine(entry.supersedes) || null
+  const sectionId = `${sectionNumber}@v${entry.version}`
+  const originNumber = originId ? (/^(D-(?:[A-Za-z0-9_\-\u4e00-\u9fff]+-)?\d+)/.exec(originId) || [])[1] || null : null
   if (sameNumber.length === 0) {
-    sections.push({ number: entry.number, version: entry.version, id: entry.id, title: entry.title, change, lines: renderBlockLines(entry, headHash, supersedesNote, change || undefined) })
+    sections.push({ number: sectionNumber, version: entry.version, id: sectionId, title: entry.title, change, origin: originId, originNumber, lines: renderBlockLines(entry, headHash, supersedesNote, change || undefined, sectionNumber, originId) })
     action = 'append'
   } else {
     const same = sameNumber.find(s => s.version === entry.version)
@@ -400,10 +447,14 @@ function applyEntryToSections(sections, entry, headHash) {
     if (!same && !supersedesNote) supersedesNote = `${slot.number}@v${slot.version}`
     slot.version = entry.version
     slot.title = entry.title
-    slot.lines = renderBlockLines(entry, headHash, supersedesNote, change || undefined)
-    // 同变更同号旧版本段（< 新版本）就地清除——同文件内同变更同号只留一个段
+    slot.number = sectionNumber
+    slot.id = sectionId
+    slot.origin = originId
+    slot.originNumber = originNumber
+    slot.lines = renderBlockLines(entry, headHash, supersedesNote, change || undefined, sectionNumber, originId)
+    // 同变更同段（号或原编号匹配）旧版本就地清除——同文件内同变更同段只留一个段
     for (let i = sections.length - 1; i >= 0; i--) {
-      if (sections[i].number === entry.number && (sections[i].change || null) === change && sections[i] !== slot) sections.splice(i, 1)
+      if (sameDecisionNumber(sections[i], entry) && sections[i] !== slot) sections.splice(i, 1)
     }
     action = same ? 'update' : 'supersede'
   }
@@ -577,31 +628,62 @@ export function distillIntoKnowledge(changeDir, knowledgeRoot, headHash, moduleI
   }
 
   const written = []
+  // 域全集（跨文件清理与复用扫描共用；磁盘 ∪ 本批已加载）
+  let onDisk = []
+  try { onDisk = readdirSync(decisionsDir).filter(f => f.endsWith('.md')).map(f => f.replace(/\.md$/, '')) } catch { /* 刚创建，走 store */ }
+  let allDomains = [...new Set([...onDisk, ...store.keys()])]
+  // 发号器（2026-10-14-decision-global-id-epoch）：域前缀全域 max+1 只增不复用；mintMax 批内会话
+  // 计数防同批撞号（磁盘扫描只做初值）；并发蒸馏撞号窗口与 FR 侧发号同病（接受，doctor 可见）。
+  const mintMax = new Map()
+  const mintFor = (domain) => {
+    if (!mintMax.has(domain)) {
+      let max = 0
+      for (const f of onDisk) {
+        let c; try { c = readFileSync(join(decisionsDir, f.endsWith('.md') ? f : `${f}.md`), 'utf8') } catch { continue }
+        const re = /^## D-([A-Za-z0-9_\-\u4e00-\u9fff]+?)-(\d+)@v\d+/gm
+        let m
+        while ((m = re.exec(c)) !== null) if (m[1] === domain) max = Math.max(max, parseInt(m[2], 10))
+      }
+      mintMax.set(domain, max)
+    }
+    const next = mintMax.get(domain) + 1
+    mintMax.set(domain, next)
+    return `D-${domain}-${String(next).padStart(3, '0')}`
+  }
   const targetSets = new Map() // entry → Set(域)（跨文件清理时排除目标文件）
   for (const entry of batch) {
     const domains = resolveDomains(entry, idx)
     targetSets.set(entry, new Set(domains))
+    // 号决策（2026-10-14-decision-global-id-epoch）：同变更同段存量（全域文件扫描，号或原编号匹配）
+    // 复用其号——legacy 段保持局部形态（不补原编号不改前缀，存量零触碰）；epoch 段原编号随版本更新；
+    // 无匹配 → 发号域=首域（resolveDomains 已 sanitize）批内 max+1，扇出多文件同一号（单一身份）。
+    let reuse = null
+    for (const d of allDomains) {
+      const st = loadDomain(d)
+      reuse = st.sections.find(s => sameDecisionNumber(s, entry)) || null
+      if (reuse) break
+    }
+    const sectionNumber = reuse ? reuse.number : mintFor(domains[0])
+    const originId = reuse && !reuse.origin ? null : `${entry.number}@v${entry.version}`
     for (const d of domains) {
       const st = loadDomain(d)
-      const res = applyEntryToSections(st.sections, entry, headHash)
+      const res = applyEntryToSections(st.sections, entry, headHash, sectionNumber, originId)
       if (res) {
         st.dirty = true
-        written.push({ file: `decisions/${d}.md`, id: entry.id, action: res.action })
+        written.push({ file: `decisions/${d}.md`, id: `${sectionNumber}@v${entry.version}`, action: res.action })
       }
     }
+    allDomains = [...new Set([...allDomains, ...domains])]
   }
 
-  // 跨文件清理：同变更同号 ≤ 新版本的旧段散落其他域文件时移除（同变更同号全局只留最高
-  // 版本/目标文件）；他者变更的同号段不参与（共存，坑 distill-cross-change-supersede）
-  let onDisk = []
-  try { onDisk = readdirSync(decisionsDir).filter(f => f.endsWith('.md')).map(f => f.replace(/\.md$/, '')) } catch { /* 刚创建，走 store */ }
-  const allDomains = [...new Set([...onDisk, ...store.keys()])]
+  // 跨文件清理：同变更同段（号或原编号匹配）≤ 新版本的旧段散落其他域文件时移除（同变更同段
+  // 全局只留最高版本/目标文件）；他者变更的同号段不参与（共存，坑 distill-cross-change-supersede）
   for (const entry of batch) {
     const targets = targetSets.get(entry)
     for (const d of allDomains) {
       if (targets.has(d)) continue
       const st = loadDomain(d)
-      const removed = st.sections.filter(s => s.number === entry.number && s.version <= entry.version && (s.change || null) === (entry.change || null))
+      const removed = st.sections.filter(s => s.version <= entry.version && sameDecisionNumber(s, entry))
       if (removed.length === 0) continue
       st.sections = st.sections.filter(s => !removed.includes(s))
       st.dirty = true

package/src/decision-redomain.js

@@ -0,0 +1,148 @@
+/**
+ * decision-redomain.js — 决策条目跨域迁移（2026-10-15-decision-redomain）
+ *
+ * 背景：模块路径 glob 匹配失效（2026-10-15-module-path-glob-match）导致消费仓历史决策
+ * 大量落 decisions/unmapped.md（平台仓 442 条实证）——匹配器修复止增量后，存量需机器
+ * 通道清偿。redomain.js 只管 fr/ 条目；本模块为 decisions/ 面的孪生实现，复用
+ * decision-distill 参数化底座（splitKnowledgeSections/joinKnowledgeFile/syncIndexRoutingLines）。
+ *
+ * 与 FR 版的形态差异：
+ *   - 段头 `## D-xxx@vN 标题`（全局号/局部号双形态混存）——默认 sectionRegex 即此格式；
+ *     id = `<number>@v<version>`（迁域不换号，字段行内「原编号」等机器行随段整体搬）。
+ *   - 跨变更同号合法共存（D 号是变更内局部序号）——冲突键 = id + 变更（目标域已有
+ *     同 id 同变更段 = 迁移语义不明，跳该段并报告，不覆盖）。
+ *   - 路由行形态与 fr 不同（`- <域>|decision|决策 → [decisions/<域>.md]`）——syncIndexRoutingLines
+ *     默认参数即 decisions 面。
+ *
+ * 幂等：重跑同批——源域已无该段 → 0 条（或 anchor/byChange 无命中报错，与 FR 版同款）。
+ */
+import { existsSync, readFileSync, unlinkSync } from 'fs'
+import { join } from 'path'
+import { splitKnowledgeSections, joinKnowledgeFile, syncIndexRoutingLines } from './decision-distill.js'
+import { writeAtomicSync } from './fs-atomic.js'
+
+const DECISION_HEADER_RE = /^## (D-(?:[A-Za-z0-9_\-\u4e00-\u9fff]+-)?\d+)@v(\d+)\s*(.*)$/
+
+/** 目标域文件头（与 decision-distill 落域文件既有头逐字同款——平台真实库实测形态） */
+function newDomainPreamble(domain) {
+  return [
+    `# 决策知识 — ${domain}`,
+    '',
+    '> decision-distill 从变更 decisions.md 幂等提炼（「最近确认」= 归档时 HEAD）。条目字段行为 docs-check 机械解析契约，勿手改。',
+    '',
+  ]
+}
+
+/** 段 → {id, number, version, title, change}（id=number@version 即迁域不换号的身份） */
+function sectionMeta(s) {
+  const m = DECISION_HEADER_RE.exec(s.lines[0] || '')
+  if (!m) return null
+  const id = `${m[1]}@v${m[2]}`
+  const cm = s.lines.find((l) => /^变更[：:]/.test(l)) || s.lines.find((l) => /^来源[：:]/.test(l))
+  const change = cm ? cm.replace(/^(变更|来源)[：:]\s*/, '').trim() || null : null
+  return { id, number: m[1], version: parseInt(m[2], 10), title: (m[3] || '').trim(), change }
+}
+
+function normalizeDomainArg(v) {
+  return String(v ?? '').trim().replace(/^decisions\//i, '').replace(/\.md$/i, '').trim()
+}
+
+/** 干跑预览：列出将迁移条目，不落盘（anchor/byChange 同执行侧过滤） */
+export function planDecisionRedomain({ knowledgeRoot, from, to, anchors = null, byChange = null }) {
+  from = normalizeDomainArg(from)
+  to = normalizeDomainArg(to)
+  if (!from || !to) throw new Error('用法：--from <源域> --to <目标域>（域名可带 decisions/ 前缀与 .md 后缀）')
+  if (from === to) throw new Error('源域与目标域相同')
+  const dir = join(knowledgeRoot, 'decisions')
+  const fromPath = join(dir, `${from}.md`)
+  if (!existsSync(fromPath)) throw new Error(`源域文件不存在：decisions/${from}.md`)
+  const parsed = splitKnowledgeSections(readFileSync(fromPath, 'utf8'))
+  const anchorSet = Array.isArray(anchors) && anchors.length > 0 ? new Set(anchors) : null
+  const entries = []
+  for (const s of parsed.sections) {
+    const meta = sectionMeta(s)
+    if (!meta) continue
+    if (anchorSet && !anchorSet.has(meta.id)) continue
+    if (byChange && meta.change !== byChange) continue
+    entries.push(meta)
+  }
+  if (entries.length === 0) {
+    throw new Error(anchorSet
+      ? `anchor 未命中（${[...anchorSet].join('、')} 不在 decisions/${from}.md）`
+      : byChange ? `「变更：${byChange}」条目在 decisions/${from}.md 无命中` : `decisions/${from}.md 无决策条目段`)
+  }
+  return {
+    entries,
+    targetExists: existsSync(join(dir, `${to}.md`)),
+    sourceWillDelete: parsed.sections.length - entries.length === 0,
+  }
+}
+
+/** 执行迁移（纯文件手术——段字节整体搬运，id/机器行零改写） */
+export function redomainDecisionEntries({ knowledgeRoot, from, to, anchors = null, byChange = null }) {
+  from = normalizeDomainArg(from)
+  to = normalizeDomainArg(to)
+  if (!from || !to) throw new Error('用法：--from <源域> --to <目标域>')
+  if (from === to) throw new Error('源域与目标域相同')
+  const dir = join(knowledgeRoot, 'decisions')
+  const fromPath = join(dir, `${from}.md`)
+  const toPath = join(dir, `${to}.md`)
+  if (!existsSync(fromPath)) throw new Error(`源域文件不存在：decisions/${from}.md`)
+
+  const fromParsed = splitKnowledgeSections(readFileSync(fromPath, 'utf8'))
+  const anchorSet = Array.isArray(anchors) && anchors.length > 0 ? new Set(anchors) : null
+  const targetCreated = !existsSync(toPath)
+  const toParsed = targetCreated
+    ? { preamble: newDomainPreamble(to), sections: [] }
+    : splitKnowledgeSections(readFileSync(toPath, 'utf8'))
+
+  const moving = []
+  const staying = []
+  const skippedConflicts = []
+  const movedKeys = new Set() // 批内双键（id|change）：同批重复段第二条跳过（2026-10-15 平台存量实证幂等残留）
+  for (const s of fromParsed.sections) {
+    const meta = sectionMeta(s)
+    if (!meta) { staying.push(s); continue } // 非条目段（说明/杂项）留守
+    if (anchorSet && !anchorSet.has(meta.id)) { staying.push(s); continue }
+    if (byChange && meta.change !== byChange) { staying.push(s); continue }
+    // 冲突防线：目标域已有同 id + 同变更段（跨变更同号合法共存，双键才冲突）
+    const key = `${meta.id}|${meta.change || ''}`
+    const clash = movedKeys.has(key) || toParsed.sections.some((t) => {
+      const tm = sectionMeta(t)
+      return tm && `${tm.id}|${tm.change || ''}` === key
+    })
+    if (clash) { skippedConflicts.push(meta.id); staying.push(s); continue }
+    movedKeys.add(key)
+    moving.push({ meta, section: s })
+  }
+  if (moving.length === 0 && skippedConflicts.length === 0) {
+    throw new Error(anchorSet
+      ? `anchor 未命中（${[...anchorSet].join('、')} 不在 decisions/${from}.md）`
+      : byChange ? `「变更：${byChange}」条目在 decisions/${from}.md 无命中` : `decisions/${from}.md 无决策条目段`)
+  }
+  if (anchorSet && skippedConflicts.length + moving.length !== anchorSet.size) {
+    const got = new Set([...moving.map((m) => m.meta.id), ...skippedConflicts])
+    const miss = [...anchorSet].filter((a) => !got.has(a))
+    if (miss.length > 0) throw new Error(`anchor 未命中：${miss.join('、')}（不在 decisions/${from}.md）`)
+  }
+
+  toParsed.sections.push(...moving.map((m) => m.section))
+  writeAtomicSync(toPath, joinKnowledgeFile(toParsed.preamble, toParsed.sections))
+  const sourceDeleted = staying.length === 0
+  if (sourceDeleted) unlinkSync(fromPath)
+  else writeAtomicSync(fromPath, joinKnowledgeFile(fromParsed.preamble, staying))
+
+  // INDEX 路由行：decisions 面默认参数（幂等；缺席行补上）
+  const indexPath = join(knowledgeRoot, 'INDEX.md')
+  const before = existsSync(indexPath) ? readFileSync(indexPath, 'utf8') : ''
+  try { syncIndexRoutingLines(knowledgeRoot) } catch { /* INDEX 缺席/同步失败不拦迁移 */ }
+  const after = existsSync(indexPath) ? readFileSync(indexPath, 'utf8') : ''
+
+  return {
+    moved: moving.map((m) => ({ id: m.meta.id, title: m.meta.title })),
+    skippedConflicts,
+    sourceDeleted,
+    targetCreated,
+    indexLineAdded: after !== before,
+  }
+}

package/src/decision-renumber.js

@@ -0,0 +1,157 @@
+/**
+ * decision-renumber.js — 存量决策号一次性迁移（2026-10-14-decision-legacy-renumber）。
+ *
+ * 背景：epoch 全局化（2026-10-14-decision-global-id-epoch）落地后新蒸馏条目自动发全局号，但存量
+ * 701 条 legacy 局部号节段无跨变更承接机制、不会自然退役。用户裁决一次性迁移（翻「存量不回填」
+ * 旧案——fr-index D-007 是设计取舍非技术禁忌，翻案理由随本变更蒸馏留痕）。epoch 读面（双形态解析/
+ * 原编号字段/originId 匹配）已就位——迁移产物所有消费方零改动即认识。
+ *
+ * 纯函数两段（CLI 层 src/stages/knowledge.js case 'renumber' 负责 fs 与原子写）：
+ *   planRenumber(knowledgeRoot)——扫描全部域文件产出迁移计划：
+ *     · legacy 节段（局部号标题 D-\d+ 且无原编号字段）按「文件字母序 × 节段序」发号
+ *       D-<域>-NNN（域=所在文件名去 .md；NNN=该域全域既有 epoch 号 max+1 起批内递增）；
+ *     · fanout 组（同变更同号同版本跨文件副本）单一身份——全组共用一号，号域=字母序首文件域；
+ *     · 无变更行条目不分组（同号无变更 ≠ 同一决策——backend.md 双 D-001@v1 无变更行实证是
+ *       两条不同决策），逐节独立发号；
+ *     · epoch 形态节段（全局号标题或原编号在场）零触碰——幂等判定面。
+ *   applyRenumberPlan(contentByFile, plan)——按计划重写：标题行旧 id → 新全局号、
+ *   「原编号：<旧号>」插入变更行后（无变更行则状态行后，再退标题行后）、其余行逐字节保留、
+ *   节段次序不变；joinKnowledgeFile 复用既有归一落盘形态。
+ */
+import { readFileSync, readdirSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { splitKnowledgeSections, joinKnowledgeFile } from './decision-distill.js'
+
+const EPOCH_NUMBER_RE = /^D-[A-Za-z0-9_\-\u4e00-\u9fff]+-\d+$/
+const LOCAL_NUMBER_RE = /^D-\d+$/
+
+/** 扫描 decisions 域文件集（files 元素含 splitKnowledgeSections 产物，零写盘） */
+function scanDomainFiles(knowledgeRoot) {
+  const decisionsDir = join(knowledgeRoot, 'decisions')
+  const files = []
+  if (!existsSync(decisionsDir)) return files
+  for (const f of readdirSync(decisionsDir).sort()) {
+    if (!f.endsWith('.md')) continue
+    const content = readFileSync(join(decisionsDir, f), 'utf8')
+    const { preamble, sections } = splitKnowledgeSections(content)
+    files.push({ file: `decisions/${f}`, domain: f.replace(/\.md$/, ''), content, preamble, sections })
+  }
+  return files
+}
+
+/**
+ * 纯函数（只读扫描）：产出迁移计划。
+ * @param {string} knowledgeRoot knowledge 目录
+ * @returns {{ files: Array<{file, domain, content, ops: Array<{secIdx, fromId, toNumber}>}>,
+ *   stats: { legacySections, fanoutGroups, fanoutCopies, mintedNumbers, noChangeEntries, untouchedEpoch, perDomainStart: object } }}
+ *   perDomainStart = 各发号域的起始号（既有 epoch max+1）；ops 为空的文件也保留（content 供 CLI 指纹校验）
+ */
+export function planRenumber(knowledgeRoot) {
+  const files = scanDomainFiles(knowledgeRoot)
+  // 各域既有 epoch 号 max（发号起点——不与已发号冲突）
+  const domainMax = new Map()
+  let untouchedEpoch = 0
+  for (const { sections } of files) {
+    for (const s of sections) {
+      const m = /^D-([A-Za-z0-9_\-\u4e00-\u9fff]+)-(\d+)$/.exec(s.number)
+      if (m) domainMax.set(m[1], Math.max(domainMax.get(m[1]) || 0, parseInt(m[2], 10)))
+    }
+  }
+  const isLegacy = (s) => LOCAL_NUMBER_RE.test(s.number) && !s.origin && !EPOCH_NUMBER_RE.test(s.number)
+  for (const { sections } of files) for (const s of sections) if (!isLegacy(s)) untouchedEpoch++
+  // fanout 分组：同变更（非空）同号同版本跨文件 → 单一身份（组号=字母序首文件域——files 已按文件名排序）
+  const groupKeyOf = (s) => `${s.change}#${s.number}@v${s.version}`
+  const groups = new Map()
+  files.forEach((f) => f.sections.forEach((s) => {
+    if (!isLegacy(s) || !s.change) return
+    const k = groupKeyOf(s)
+    if (!groups.has(k)) groups.set(k, { domain: f.domain, members: [] })
+    groups.get(k).members.push({ file: f.file, secIdx: f.sections.indexOf(s) })
+  }))
+  const fanoutGroups = [...groups.values()].filter((g) => g.members.length >= 2)
+  const fanoutCopies = fanoutGroups.reduce((a, g) => a + g.members.length, 0)
+  // 组号预分配（确定性：组键排序）
+  const minted = new Map()
+  const nextFor = (domain) => {
+    const cur = Math.max(domainMax.get(domain) || 0, minted.get(domain) || 0) + 1
+    minted.set(domain, cur)
+    return `D-${domain}-${String(cur).padStart(3, '0')}`
+  }
+  const groupNumber = new Map()
+  for (const k of [...groups.keys()].sort()) {
+    const g = groups.get(k)
+    if (g.members.length >= 2) groupNumber.set(k, nextFor(g.domain))
+  }
+  // 逐文件逐节段：组员复用组号，其余 legacy 独立发号（域=所在文件域）
+  const perFileOps = new Map()
+  let legacySections = 0
+  let mintedNumbers = 0
+  let noChangeEntries = 0
+  for (const f of files) {
+    const ops = []
+    f.sections.forEach((s, si) => {
+      if (!isLegacy(s)) return
+      legacySections++
+      if (!s.change) noChangeEntries++
+      const fromId = `${s.number}@v${s.version}`
+      let toNumber
+      if (s.change && groups.get(groupKeyOf(s))?.members.length >= 2) {
+        toNumber = groupNumber.get(groupKeyOf(s))
+      } else {
+        toNumber = nextFor(f.domain)
+        mintedNumbers++
+      }
+      ops.push({ secIdx: si, fromId, toNumber })
+    })
+    perFileOps.set(f.file, ops)
+  }
+  mintedNumbers += groupNumber.size
+  const perDomainStart = {}
+  for (const d of new Set([...files.map((f) => f.domain), ...domainMax.keys(), ...minted.keys()])) {
+    perDomainStart[d] = (domainMax.get(d) || 0) + 1
+  }
+  return {
+    files: files.map((f) => ({ file: f.file, domain: f.domain, content: f.content, ops: perFileOps.get(f.file) || [] })),
+    stats: { legacySections, fanoutGroups: fanoutGroups.length, fanoutCopies, mintedNumbers, noChangeEntries, untouchedEpoch, perDomainStart },
+  }
+}
+
+/**
+ * 纯函数（零 fs）：按计划重写。contentByFile 为计划时点内容（CLI 层先做指纹校验防他侧写入被覆盖）。
+ * @param {Map<string,string>} contentByFile file → 全文
+ * @param {object} plan planRenumber 产物
+ * @returns {Map<string,string>} 仅有 op 的 file → 重写后全文
+ */
+export function applyRenumberPlan(contentByFile, plan) {
+  const out = new Map()
+  for (const fe of plan.files) {
+    if (!fe.ops || fe.ops.length === 0) continue
+    const content = contentByFile.get(fe.file)
+    if (content == null) continue
+    const { preamble, sections } = splitKnowledgeSections(content)
+    const byIdx = new Map(fe.ops.map((o) => [o.secIdx, o]))
+    for (let i = 0; i < sections.length; i++) {
+      const op = byIdx.get(i)
+      if (!op) continue
+      const s = sections[i]
+      // 标题行：首个旧 id 出现即节头 id（其余行不动）
+      s.lines[0] = s.lines[0].replace(op.fromId, `${op.toNumber}@v${s.version}`)
+      // 原编号行：变更行后 > 状态行后 > 标题行后（不破「文件：紧跟锚点」行序红线）
+      let at = 1
+      const vi = s.lines.findIndex((l) => /^变更[：:]/.test(l))
+      if (vi > -1) at = vi + 1
+      else {
+        const si = s.lines.findIndex((l) => /^状态[：:]/.test(l))
+        if (si > -1) at = si + 1
+      }
+      s.lines.splice(at, 0, `原编号：${op.fromId}`)
+      s.id = `${op.toNumber}@v${s.version}`
+      s.number = op.toNumber
+      s.origin = op.fromId
+    }
+    out.set(fe.file, joinKnowledgeFile(preamble, sections))
+  }
+  return out
+}
+
+export default { planRenumber, applyRenumberPlan }

package/src/design-facts.js

@@ -26,7 +26,7 @@ import { join, relative } from 'node:path'
 import { parseDecisions } from './decision-distill.js'
 import { parseFileChangeListDetailed } from './change-list.js'
 import { parseDesignCoverageByRepo, parseRepoRegistry } from './stages/plan-postcheck.js'
-import { parseModuleMapSimple } from './modules.js'
+import { modulePathMatches, parseModuleMapSimple } from './modules.js'
 
 // ---------------------------------------------------------------------------
 // 条目解析（distill parseDecisions 的同源镜像，R-01）
@@ -173,7 +173,7 @@ export function deriveActualModules(filePaths, prefixPairs) {
     const t = String(f || '').replace(/\\/g, '/').replace(/\/+$/, '')
     if (!t) continue
     for (const { id, path: p } of prefixPairs) {
-      if (t === p || t.startsWith(p + '/')) { actual.add(id); break }
+      if (modulePathMatches(t, p)) { actual.add(id); break }
     }
   }
   return actual
@@ -387,7 +387,7 @@ export function generateDesignSkeleton({ changeName, decisionsText, author, now
   lines.push('- [ ] frontmatter 字段齐全（author/created_at/scale）')
   lines.push('- [ ] 引用所有当前版本 D-xxx@vN')
   lines.push('- [ ] 涉及生命周期关键词时含「生命周期契约表」或紧邻豁免短语')
-  lines.push('- [ ] UI 原型分级核对（涉前端文件时变更目录应有 prototype-*.html——新生成（定稿＝与实现同方言的真码产物，手绘仅限粗选）或登记复用（复用须按 prototype-<名称>.html 命名，execute 才注入）或跳过原因记入风险登记）')
+  lines.push('- [ ] UI 原型分级核对（涉前端文件时变更目录应有 prototype-*.html——新生成（定稿＝与实现同方言的真码产物，手绘仅限粗选，输出须带素材来源声明：token 源/组件来源/入口位置）或登记复用（复用须按 prototype-<名称>.html 命名，execute 才注入）或跳过原因记入风险登记；本仓形态未在 local.yaml ui_prototype 登记的，收口前补登记）')
   lines.push('- [ ] 不确定的问题标注「⚠️ 自审存疑」')
   lines.push('')