sillyspec 3.32.9 → 3.32.10

package/.claude/skills/sillyspec-brainstorm/SKILL.md

@@ -80,8 +80,8 @@ brainstorm 完成时按 design.md frontmatter 的 `scale` 分叉：
 
 brainstorm 在 `tier=independent` 规模下除 design.md 等四件套外，还需产出一个 stage 级 `review.json`，CLI `Stage Review Gate` 硬校验其 schema 与 `docHash` 真实性。
 
-- 路径：`.sillyspec/.runtime/stage-reviews/brainstorm-review-<stage-review-run-id>/review.json`（目录可能不存在需手建；run-id 由该步 `--done` prompt 输出指定）。marker 文件 `.runtime/current-stage-review-run-id-brainstorm-<变更名>`。
-- **run-id / marker 由 CLI 自动生成注入**（review step prompt 渲染时 echo 完整目录路径 + 写 marker；撞 gate 报缺 review.json 时 gate 也 echo 完整路径 + 写 marker）。直接用 CLI 给的路径写 review.json，**勿手算 run-id（必须 `review-` 前缀）、勿手写 marker**。卡住时用 `sillyspec register-stage-review --change <名> --stage brainstorm` 一步生成。
+- 路径：`.sillyspec/.runtime/stage-reviews/brainstorm-<run-id>/review.json`——**目录名 = `brainstorm-` + marker 值原样**（run-id 本身已带 `review-` 前缀：marker 值 `review-2026-10-15-001431` → 目录 `brainstorm-review-2026-10-15-001431`。勿再拼一层 review-，也勿拿 marker 值当完整目录名）。目录可能不存在需手建；run-id 由该步 `--done` prompt 输出指定；marker 文件 `.runtime/current-stage-review-run-id-brainstorm-<变更名>`。
+- **run-id / marker 由 CLI 自动生成注入**（review step prompt 渲染时 echo 完整目录路径 + 写 marker；撞 gate 报缺 review.json 时 gate 也 echo 完整路径 + 写 marker）。直接用 CLI 给的路径写 review.json，**勿手算 run-id、勿手写 marker**。卡住时用 `sillyspec register-stage-review --change <名> --stage brainstorm` 一步生成。
 - 字段（`schemaVersion:1`，`reviewType=design` —— 区别于 execute 的 `acceptance`）：
 
   ```json

package/.claude/skills/sillyspec-execute/SKILL.md

@@ -106,8 +106,8 @@ execute 完成时，每个 task 必须有 `review.json` 且 verdict 通过，否
 
 execute 还有**第二道**独立的 stage 级审查：除逐 task review.json 外，整个 execute 阶段完成还需一个 stage 级 `review.json`（在 "完成确认"/acceptance 步骤产出）。CLI `Stage Review Gate` 硬校验其 schema 与 `docHash` 真实性。
 
-- 路径：`.sillyspec/.runtime/stage-reviews/execute-review-<stage-review-run-id>/review.json`（目录可能不存在需手建；run-id 由该步 `--done` prompt 输出指定）。marker 文件 `.runtime/current-stage-review-run-id-execute-<变更名>`。
-- **run-id / marker 由 CLI 自动生成注入**（review step prompt 渲染时 echo 完整目录路径 + 写 marker；撞 gate 报缺 review.json 时 gate 也 echo 完整路径 + 写 marker）。直接用 CLI 给的路径写 review.json，**勿手算 run-id（必须 `review-` 前缀）、勿手写 marker**。卡住时用 `sillyspec register-stage-review --change <名> --stage execute` 一步生成。
+- 路径：`.sillyspec/.runtime/stage-reviews/execute-<run-id>/review.json`——**目录名 = `execute-` + marker 值原样**（run-id 本身已带 `review-` 前缀：marker 值 `review-2026-10-15-001431` → 目录 `execute-review-2026-10-15-001431`。勿再拼一层 review-，也勿拿 marker 值当完整目录名）。目录可能不存在需手建；run-id 由该步 `--done` prompt 输出指定；marker 文件 `.runtime/current-stage-review-run-id-execute-<变更名>`。
+- **run-id / marker 由 CLI 自动生成注入**（review step prompt 渲染时 echo 完整目录路径 + 写 marker；撞 gate 报缺 review.json 时 gate 也 echo 完整路径 + 写 marker）。直接用 CLI 给的路径写 review.json，**勿手算 run-id、勿手写 marker**。卡住时用 `sillyspec register-stage-review --change <名> --stage execute` 一步生成。
 - 字段（`schemaVersion:1`，`reviewType=acceptance` —— 区别于 brainstorm/plan 的 `"design"`）：
 
   ```json

package/.claude/skills/sillyspec-flow/SKILL.md

@@ -16,7 +16,7 @@ description: 轻量变更（默认快道）——需求明确的小/中改动两
 ### ① flow start（立项 + 锁基线）
 
 ```bash
-sillyspec flow start --change <变更名> --input "<动机与背景>
+sillyspec flow start --change <变更名> --input "<一句中文概括（首行即变更标题）；随后动机与背景
 
 成功标准：
 - <可验证标准>"

package/.claude/skills/sillyspec-plan/SKILL.md

@@ -49,8 +49,8 @@ plan 的步骤是动态的：`generate_plan`（生成分级计划）→ `review_
 
 `review_plan` 步骤在 `tier=independent` 时产出一个 stage 级 `review.json`，CLI `Stage Review Gate` 硬校验其 schema 与 `docHash` 真实性。
 
-- 路径：`.sillyspec/.runtime/stage-reviews/plan-review-<stage-review-run-id>/review.json`（目录可能不存在需手建；run-id 由该步 `--done` prompt 输出指定）。marker 文件 `.runtime/current-stage-review-run-id-plan-<变更名>`。
-- **run-id / marker 由 CLI 自动生成注入**（review step prompt 渲染时 echo 完整目录路径 + 写 marker；撞 gate 报缺 review.json 时 gate 也 echo 完整路径 + 写 marker）。直接用 CLI 给的路径写 review.json，**勿手算 run-id（必须 `review-` 前缀）、勿手写 marker**。卡住时用 `sillyspec register-stage-review --change <名> --stage plan` 一步生成。
+- 路径：`.sillyspec/.runtime/stage-reviews/plan-<run-id>/review.json`——**目录名 = `plan-` + marker 值原样**（run-id 本身已带 `review-` 前缀：marker 值 `review-2026-10-15-001431` → 目录 `plan-review-2026-10-15-001431`。勿再拼一层 review-，也勿拿 marker 值当完整目录名）。目录可能不存在需手建；run-id 由该步 `--done` prompt 输出指定；marker 文件 `.runtime/current-stage-review-run-id-plan-<变更名>`。
+- **run-id / marker 由 CLI 自动生成注入**（review step prompt 渲染时 echo 完整目录路径 + 写 marker；撞 gate 报缺 review.json 时 gate 也 echo 完整路径 + 写 marker）。直接用 CLI 给的路径写 review.json，**勿手算 run-id、勿手写 marker**。卡住时用 `sillyspec register-stage-review --change <名> --stage plan` 一步生成。
 - 字段（`schemaVersion:1`，`reviewType=plan` —— plan 阶段主审查文档是 `plan.md`；execute 阶段才是 `acceptance`）：
 
   ```json

package/AGENTS.md

@@ -16,7 +16,7 @@
 `--input` 过门格式（轻量道首次调用即过，勿靠报错学；引号内换行合法，下例可照抄）：
 
 ```bash
-sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>
+sillyspec flow start --change <YYYY-MM-DD-名> --input "<一句中文概括（首行即变更标题）；随后动机与背景
 
 成功标准：
 - <可验证标准>"

package/assets/command-cards/flow.md

@@ -11,7 +11,7 @@ description: 轻量变更（默认快道）：需求明确的小/中改动两步
 ```bash
 export SILLYSPEC_SESSION_ID=<agent名+任务名>   # 每条命令都带（shell 状态不持久；多会话并行的所有权判定依赖它）
 # ① 立项 + 锁基线（--input 引号内换行合法，可照抄；缺「成功标准」条目会被清晰度门拦下）：
-sillyspec flow start --change <变更名> --input "<动机与背景>
+sillyspec flow start --change <变更名> --input "<一句中文概括（首行即变更标题）；随后动机与背景
 
 成功标准：
 - <可验证标准>"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sillyspec",
-  "version": "3.32.9",
+  "version": "3.32.10",
   "description": "SillySpec CLI — 流程状态机，让 AI 严格按步骤来",
   "icon": "logo.jpg",
   "homepage": "https://sillyspec.ppdmq.top/",

package/src/commit-suggest.js

@@ -17,7 +17,7 @@
  *   C. 阶段产出：changed paths 按路径模式归 scan/brainstorm/plan/execute/archive/knowledge
  */
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
-import { join } from 'path'
+import { join, relative } from 'path'
 import { DatabaseSync } from 'node:sqlite'
 import { gitQuiet, safeGit, stageArchiveArtifacts } from './git-helper.js'
 import { resolveSpecDir } from './run/shared.js'
@@ -117,6 +117,12 @@ export function collectCommitContext({ cwd, specDir = null }) {
   const stat = gitQuiet(cwd, ['diff', 'HEAD', '--stat']) || (changedPaths.length > 0 ? `（${changedPaths.length} 个文件待首提交）` : '')
 
   // ── 来源 A：QUICKLOG（主 quicklog + 各活跃变更归属 quicklog）──
+  // 并行会话噪声锚定（坑 probe-noise-and-commit-suggest-quality 坑B，2026-10-15 消费仓实证：
+  // 归档提交时他并行 quick 会话的 QUICKLOG 新条目（时间窗过滤粗筛通过）把 feat 建议劫持成
+  // 「fix: quick 修复 + 阶段产出」——type 误判 + 凭空 quick 字样。quick 来源现加锚「quicklog
+  // 文件属于本次提交变更集」（porcelain 含 staged/unstaged/untracked）：不在变更集的 quicklog
+  // 条目不参与建议（时间窗保留作首道粗筛，零条目时无建议行为不变）。
+  const changedSet = new Set(changedPaths.map(p => String(p).replace(/\\/g, '/')))
   const quickFiles = []
   try {
     for (const f of readdirSync(join(specBase, 'quicklog'))) {
@@ -133,6 +139,7 @@ export function collectCommitContext({ cwd, specDir = null }) {
   const quickEntries = quickFiles
     .flatMap(file => parseQuicklogEntries(file).map(e => ({ ...e, file })))
     .filter(e => !lastCommitKey || e.time > lastCommitKey)
+    .filter(e => changedSet.has(relative(cwd, e.file).replace(/\\/g, '/')))
     .sort((a, b) => (a.time < b.time ? -1 : 1))
   const doneQuick = quickEntries.filter(e => e.status === '已完成')
 
@@ -155,6 +162,27 @@ export function collectCommitContext({ cwd, specDir = null }) {
     }
   }
 
+  // ── 来源 B2：归档产物任务面（坑 probe-noise-and-commit-suggest-quality 坑B 连带）──
+  // apply 后 tasks.md 移到 changes/archive/<变更>/——来源 B 的 mtime 锚对已提交面恒失效
+  // （任务勾选随 execute 提交走，mtime 早于上次 commit → hasTasks 恒 false → 归档提交被判
+  // fix）。归档目录下 tasks.md 在本次变更集时解析其 [x] 行进 task 面（归档提交的 feat 语义正源）。
+  try {
+    const archDir = join(specBase, 'changes', 'archive')
+    if (existsSync(archDir)) {
+      for (const c of readdirSync(archDir)) {
+        const tp = join(archDir, c, 'tasks.md')
+        try {
+          if (!statSync(tp).isFile()) continue
+        } catch { continue }
+        if (!changedSet.has(relative(cwd, tp).replace(/\\/g, '/'))) continue
+        for (const line of readFileSync(tp, 'utf8').split('\n')) {
+          const m = line.match(/^[-*]\s*\[[xX]\]\s*(task-\d+)\s*[:：]?\s*(.*)/)
+          if (m) checkedTasks.push({ change: c, item: `${m[1]}: ${m[2].trim()}` })
+        }
+      }
+    }
+  } catch { /* 归档扫描失败静默（来源面缺省，行为回退修复前） */ }
+
   // ── 来源 C：阶段产出（changed paths 按模式归类去重）──
   const stageSet = new Set()
   for (const p of changedPaths) {
@@ -195,11 +223,24 @@ export function collectCommitContext({ cwd, specDir = null }) {
       type = 'feat'
       subject = `feat: 变更交付 + quick 修复 ${doneQuick.length} 项`
     } else {
-      type = 'fix'
-      subject = `fix: quick 修复 + 阶段产出`
+      // 纯阶段产出（坑 probe-noise-and-commit-suggest-quality 坑B，2026-10-15 实证：原
+      // 「fix: quick 修复 + 阶段产出」在无任何 quick 证据时凭空捏造 quick 语义且误判 fix——
+      // 无 task 无 quick 的归档/知识面提交按 chore 归档语义建议）
+      type = 'chore'
+      subject = `chore: 阶段产出归档（${stageArtifacts.join('、')}）`
     }
     if (doneQuick.length >= 2 || hasTasks || hasStages) {
-      for (const q of doneQuick) bodyLines.push(`- quick ${q.qlId}: ${q.title}`)
+      // body 与 subject 去重（坑同上：quick ≤2 条时标题已全列 subject，body 原样重复无信息量）
+      const subjectListed = doneQuick.length <= 2 ? new Set(doneQuick.map(q => q.title)) : null
+      for (const q of doneQuick) {
+        // 标题已列 subject 时 body 仍保留 qlId 行（去重不丢审计锚——标题可省，qlId 是
+        // QUICKLOG 对账锚点，既有测试契约钉住 body 含 qlId）
+        if (subjectListed && subjectListed.has(q.title)) {
+          bodyLines.push(`- quick ${q.qlId}（标题见上）`)
+          continue
+        }
+        bodyLines.push(`- quick ${q.qlId}: ${q.title}`)
+      }
     }
     for (const t of checkedTasks) bodyLines.push(`- ${t.change} ${t.item}`)
     for (const s of stageArtifacts) bodyLines.push(`- 阶段产出: ${s}`)

package/src/config-schema.js

@@ -77,6 +77,14 @@ export const LOCAL_YAML_SCHEMA = {
         { path: 'commands.knowledge-gate', type: 'boolean', optional: true, status: 'live', readers: ['completeStep (src/run/complete.js)'], desc: '【2026-09-28-unclear-req-to-brainstorm FR-03/D-004】brainstorm 方案步（提出 2-3 种方案）--done 知识检索命中回显开关——缺省 true=开（对 --output 与 decisions.md 条目跑既有检索匹配器，命中 warn 回显「须 evidence 回应或说明不复潮」不阻断）；false（或 off）关回显，无命中时输出与现状一致。', example: 'false' },
       ],
     },
+    {
+      id: 'knowledge',
+      title: '知识检索（平台向量语义召回）',
+      note: '可选段——缺省（未写整段/auto）跟随平台能力自动探测：端点在场自动启用、未部署缓存 1h 内跳过（部署后自动启用，零配置；2026-10-15-platform-vector-search）。off=显式逃生阀强制关，on=强制开跳过探测。能力缓存落 .runtime/vector-capability.json（gitignored）；提示触点：knowledge search hint 键、flow 注入零命中行（auto 未就绪时信息性提示）。',
+      keys: [
+        { path: 'knowledge.vector_search', type: 'string', optional: true, status: 'live', readers: ['vectorSwitchFromLocalYaml (src/knowledge-vector.js)'], desc: '【2026-10-15-vector-capability-autodetect 终态】平台向量语义召回开关——缺省（未写键/auto）跟随平台能力自动探测：端点在场自动启用、未部署缓存 1h 内跳过（部署后自动启用，零配置）；off=显式逃生阀强制关、on=强制开跳过探测。env SILLYSPEC_KNOWLEDGE_VECTOR=on|auto/off 同语义强制。四层检索第二层：路由 tag 零命中后平台向量召回（语料=knowledge/decisions 条目，词面不相交条目可语义召回）。', example: 'off' },
+      ],
+    },
     {
       id: 'mcp',
       title: 'SillyHub MCP 客户端凭据（派发用）',
@@ -387,6 +395,12 @@ commands:
   # lint_timeout_sec: 600    # commands.lint 超时秒数（缺省 180）
   # knowledge-gate: false    # 方案步 --done 知识检索命中回显开关（缺省 true 开；false 关回显）
 
+# ── 知识检索（平台向量语义召回）──
+# 缺省（未写整段）跟随平台能力自动探测：端点在场自动启用、未部署自动跳过（部署后自动
+# 启用，零配置）。仅显式逃生阀时才需要写：
+# knowledge:
+#   vector_search: off   # 强制关（on=强制开跳过探测）
+
 # ── SillyHub MCP 客户端凭据（派发到 worker 用）──
 # agent 手填，或 sillyspec platform connect 在 mcp 段缺失时同源自动填。
 # 两键齐全才生效；缺则回退环境变量 SILLYHUB_MCP_URL / SILLYHUB_MCP_TOKEN。

package/src/decision-distill.js

@@ -313,10 +313,13 @@ 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)}`)
+  // 原编号（2026-10-14-decision-global-id-epoch）：epoch 形态溯源字段——变更行后/锚点行前
+  // （不破「文件：紧跟锚点」行序红线）；legacy 复用段（originId=null）不渲染，形态零变化
+  if (originId) lines.push(`原编号：${oneLine(originId)}`)
   lines.push(`锚点：${oneLine(entry.anchor) || NOT_RECORDED}`)
   // 文件行（FR-01/D-001@v1）：仅非空渲染——存量条目零迁移，幂等重归档不添空行
   if (entry.files && entry.files.length > 0) lines.push(`文件：${entry.files.join(', ')}`)
@@ -336,12 +339,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 +364,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 +397,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 +421,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 +602,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-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/docs-check.js

@@ -1038,12 +1038,20 @@ export function readDecisionRulesConfig(projectRoot) {
   }
 }
 
-/** 豁免键匹配（本变更范围先支持键匹配，非子串）：规则级 `decisions.<id>.<kind>` 精确命中，
- *  或条目级 `decisions.<id>` 伞形命中（一条豁免该决策全部规则）。无 decisions. 前缀的键不参与。 */
-function isDecisionExempt(knownFailures, entryId, kind) {
-  const ruleKey = `decisions.${entryId}.${kind}`
-  const entryKey = `decisions.${entryId}`
-  return knownFailures.some(k => k === ruleKey || k === entryKey)
+/** 豁免键匹配（键匹配非子串）：域限定键 `decisions.<域>/<id>.<kind>`（规则级精确）与
+ *  `decisions.<域>/<id>`（条目级伞形）——2026-10-14-decision-id-p2-hardening：裸键无域限定，
+ *  一条 decisions.<id> 可静默豁免全库同号条目（D-001@v1 ×296 潜伏面），域限定键收窄命中面；
+ *  裸键 `decisions.<id>[.<kind>]` 保留兼容（消费仓既有配置不失效）。id 与 originId（原编号，
+ *  2026-10-14-decision-legacy-renumber）双匹配——存量迁移后旧号键继续命中。
+ *  无 decisions. 前缀的键不参与。导出（测试面先例 anchorFilePath）。 */
+export function isDecisionExempt(knownFailures, entryId, kind, domain = null, originId = null) {
+  const ids = originId ? [entryId, originId] : [entryId]
+  const keys = []
+  for (const id of ids) {
+    keys.push(`decisions.${id}.${kind}`, `decisions.${id}`)
+    if (domain) keys.push(`decisions.${domain}/${id}.${kind}`, `decisions.${domain}/${id}`)
+  }
+  return knownFailures.some(k => keys.includes(k))
 }
 
 /**
@@ -1051,25 +1059,32 @@ function isDecisionExempt(knownFailures, entryId, kind) {
  * 的写入契约对偶：producer=decision-distill → consumer=本规则族；字段行非列表项，顶层
  * 「状态：/锚点：/最近确认：」标签精确匹配，防误吞正文）。旧格式字段缺失容错为 null。
  * @param {string} md 域文件全文
- * @returns {Array<{ id: string, title: string, status: string|null, anchor: string|null, lastConfirmed: string|null }>}
+ * @returns {Array<{ id: string, title: string, status: string|null, anchor: string|null, lastConfirmed: string|null, change: string|null }>}
  */
 export function parseDecisionEntries(md) {
   const entries = []
   let cur = null
   const flush = () => { if (cur) entries.push(cur) }
   for (const line of String(md || '').replace(/\r\n?/g, '\n').split('\n')) {
-    const h = line.match(/^##\s+(D-\d+)(?:@v(\d+))?\s*(.*)$/)
+    const h = line.match(/^##\s+(D-(?:[A-Za-z0-9_\-\u4e00-\u9fff]+-)?\d+)(?:@v(\d+))?\s*(.*)$/)
     if (h) {
       flush()
       const version = h[2] ? parseInt(h[2], 10) : 1
-      cur = { id: `${h[1]}@v${version}`, title: h[3].trim(), status: null, anchor: null, lastConfirmed: null }
+      cur = { id: `${h[1]}@v${version}`, title: h[3].trim(), status: null, anchor: null, lastConfirmed: null, change: null, originId: null }
       continue
     }
     if (!cur) continue
-    const f = line.match(/^(状态|锚点|最近确认)\s*[：:]\s*(.*)$/)
+    // 变更/来源/原编号：标签读入（变更：2026-10-14-supersedes-mislink-and-change-display 加法字段——
+    // docs-debt 触碰事实行渲染变更名限定词消歧需读入；来源：2026-10-14-decision-id-p2-hardening legacy
+    // 兜底——变更行无条件覆盖在前、来源仅补缺；原编号：2026-10-14-decision-legacy-renumber——存量迁移
+    // 后条目 id 为全局号，消费仓旧豁免键（decisions.D-002@vN）经原编号继续命中；旧条目缺行容错 null）
+    const f = line.match(/^(状态|锚点|最近确认|变更|来源|原编号)\s*[：:]\s*(.*)$/)
     if (!f) continue
     if (f[1] === '状态') cur.status = f[2].trim().split(/[\s（(]/)[0] || null
     else if (f[1] === '锚点') cur.anchor = f[2].trim()
+    else if (f[1] === '变更') cur.change = f[2].trim() || null
+    else if (f[1] === '来源') cur.change = cur.change || (f[2].trim() || null)
+    else if (f[1] === '原编号') cur.originId = f[2].trim() || null
     else cur.lastConfirmed = f[2].trim()
   }
   flush()
@@ -1148,8 +1163,8 @@ export async function runDecisionRules(opts) {
   let implementedTotal = 0
   const treeCache = new Map() // resolveCandidates 全树扫描复用（同 docs check 主链路口径）
 
-  const emit = (id, domain, file, kind, extra, message) => {
-    if (isDecisionExempt(failures, id, kind)) {
+  const emit = (id, domain, file, kind, extra, message, originId = null) => {
+    if (isDecisionExempt(failures, id, kind, domain, originId)) {
       exempted.push({ key: `decisions.${id}.${kind}`, id, kind })
       return
     }
@@ -1169,10 +1184,10 @@ export async function runDecisionRules(opts) {
       // 规则 1：锚点存在性（未记录 → 补录提示；路径不存在 → 失效提示）
       if (!anchorPath) {
         emit(e.id, domain, rel, 'anchor', { anchor: e.anchor || null },
-          `「${e.id}」锚点未记录（${rel}）——旧格式条目，补「锚点：src/…」后可机械校验（advisory）`)
+          `「${e.id}」锚点未记录（${rel}）——旧格式条目，补「锚点：src/…」后可机械校验（advisory）`, e.originId)
       } else if (resolveCandidates(projectRoot, anchorPath, treeCache).length === 0) {
         emit(e.id, domain, rel, 'anchor', { anchor: e.anchor },
-          `「${e.id}」锚点文件不存在：${anchorPath}（${rel}）——决策落点已漂移，人工复核（advisory）`)
+          `「${e.id}」锚点文件不存在：${anchorPath}（${rel}）——决策落点已漂移，人工复核（advisory）`, e.originId)
       }
       // 规则 2：behind 复核（「最近确认」后锚定模块源码前进数超阈值 → 决策待复核；
       // 「最近确认」未记录/域无源码集（无 map 无锚点）→ 无法计算，静默跳过——advisory 不产噪声）
@@ -1185,7 +1200,7 @@ export async function runDecisionRules(opts) {
       const { behind } = computeModuleBehind(domain, e.lastConfirmed, { projectRoot, srcPaths })
       if (behind !== null && behind > threshold) {
         emit(e.id, domain, rel, 'behind', { behind, threshold },
-          `「${e.id}」决策待复核：锚定模块 ${domain} 在最近确认 ${e.lastConfirmed} 后源码已前进 ${behind} commit，超阈值 ${threshold}（${rel}）——复核后更新「最近确认」`)
+          `「${e.id}」决策待复核：锚定模块 ${domain} 在最近确认 ${e.lastConfirmed} 后源码已前进 ${behind} commit，超阈值 ${threshold}（${rel}）——复核后更新「最近确认」`, e.originId)
       }
     }
   }