sillyspec 3.32.9 → 3.33.0

package/src/knowledge-graph.js

@@ -21,7 +21,7 @@
 import { existsSync, readFileSync, readdirSync } from 'fs'
 import { join } from 'path'
 import { parseKnowledgeIndex, parseDecisionEntries, anchorFilePaths } from './knowledge-match.js'
-import { parseModuleMapSimple } from './modules.js'
+import { modulePathMatches, parseModuleMapSimple } from './modules.js'
 
 // ── 本体常量（design.md 总体方案 §1 的代码化） ──
 
@@ -103,6 +103,7 @@ export function buildKnowledgeGraph(specRoot) {
 
   // ── ② 决策库（parseDecisionEntries：去重键 file+id+change 跨变更同号不折叠） ──
   const decisionHits = existsSync(join(knowledgeDir, 'INDEX.md')) ? parseDecisionEntries(knowledgeDir) : []
+  const supersedesRefs = []
   for (const h of decisionHits) {
     const id = `decision:${h.file}#${h.id}${h.change ? `@${h.change}` : ''}`
     addNode(id, 'decision', `${h.id} ${h.title || ''}`.trim(), {
@@ -123,17 +124,45 @@ export function buildKnowledgeGraph(specRoot) {
       else addNode(h.change, 'change', h.change)
       addEdge(id, h.change, 'from-change')
     }
-    // supersedes：同域 D-id 解析（「supersedes：无（…）」等非 id 值被正则白名单滤掉；跨变更同号时取同变更优先，再退首个）
-    const supIds = String(h.supersedesText || '').split(/[,，、\s]+/).filter((s) => /^D-\d+@v\d+$/.test(s))
+    // supersedes：同域 D-id 解析（「supersedes：无（…）」等非 id 值被正则白名单滤掉）。目标必须同变更
+    // （「变更：」行一致，含双方均无该行的 legacy 同源）——D 号是变更内局部序号，跨变更同号互不相干；
+    // v2 蒸馏落地时同变更 v1 段已被就地替换，此时无目标即不建边（2026-10-14-supersedes-mislink-and-change-display：
+    // 旧「再退同文件首个」回退几乎必然连到他变更同号条目，实测 33 条误连，回退已除）。epoch 形态段
+    // （2026-10-14-decision-global-id-epoch）id 为全局号——局部号引用经「原编号」字段匹配（originId）。
+    const supIds = String(h.supersedesText || '').split(/[,，、\s]+/).filter((s) => /^D-(?:[A-Za-z0-9_\-\u4e00-\u9fff]+-)?\d+@v\d+$/.test(s))
     for (const sid of supIds) {
-      const target = decisionHits.find((x) => x.id === sid && x.file === h.file && (x.change || '') === (h.change || ''))
-        || decisionHits.find((x) => x.id === sid && x.file === h.file)
+      const target = decisionHits.find((x) => (x.id === sid || x.originId === sid) && x.file === h.file && (x.change || '') === (h.change || ''))
       if (target) {
-        const tid = `decision:${target.file}#${target.id}${target.change ? `@${target.change}` : ''}`
-        addEdge(id, tid, 'supersedes')
+        supersedesRefs.push([id, `decision:${target.file}#${target.id}${target.change ? `@${target.change}` : ''}`])
+        continue
+      }
+      // 幽灵版本节点（2026-10-15-supersedes-ghost-nodes）：同号版本取代是蒸馏就地替换（旧段被删，
+      // 跨文件同谓词同删），自身旧版本引用的目标从不在场——真实库实证 39 条引用 0 条可解析、
+      // 703 决策节点全图仅 1 条 supersedes 边（边体系闲置根因）。合成口径**只限自身版本链**：
+      // sid 基号 === 本条目 id 基号（legacy 同号自链）或 === originId 基号（epoch 原编号自链，
+      // 迁移后真实库 36/36 全为此形态）；跨号/跨变更缺失引用不合成（2026-10-14-supersedes-mislink
+      // 的跨变更误连防护不因幽灵形态复活：为他号凭空铸造节点=误连换皮）。ghost 只带 supersedes
+      // 入边（非孤儿）、不参与 anchors/dangling 面（supersedes 不在悬空检测边型集），impact 闭包
+      // 经传递边自然延伸。
+      const ghostBase = (s) => (/^D-((?:[A-Za-z0-9_\-\u4e00-\u9fff]+-)?\d+)@v\d+$/.exec(String(s || '')) || [])[1]
+      const selfBase = ghostBase(h.id)
+      const originBase = h.originId ? ghostBase(h.originId) : null
+      const sidBase = ghostBase(sid)
+      if ((selfBase && sidBase === selfBase) || (originBase && sidBase === originBase)) {
+        const gid = `decision:${h.file}#${sid}${h.change ? `@${h.change}` : ''}`
+        if (!nodes.has(gid)) {
+          addNode(gid, 'decision', `${sid}（已被 ${h.id} 取代）`, {
+            ghost: true, status: 'superseded', supersededBy: h.id,
+            domain: String(h.file || '').replace(/^decisions\//, '').replace(/\.md$/, ''),
+          })
+        }
+        supersedesRefs.push([id, gid])
       }
     }
   }
+  // 目标节点可能晚于引用者定义（同文件行序）——addEdge 要求两端节点在场，引用者先行遍历会静默丢边；
+  // 边统一在节点面建齐后补挂（2026-10-14-supersedes-mislink-and-change-display 测试实证）
+  for (const [s, t] of supersedesRefs) addEdge(s, t, 'supersedes')
 
   // ── ③ FR 索引（fr/<域>.md：变更/状态/superseded_by/取代链/测试绑定子块） ──
   const frDir = join(knowledgeDir, 'fr')
@@ -244,9 +273,8 @@ export function buildKnowledgeGraph(specRoot) {
         const moduleOf = (p) => {
           const v = posix(p)
           for (const [mid, mp] of modulePathIndex) {
-            // 模块 paths 是目录/glob 语义：剥尾斜杠后按「相等 或 path/ 前缀」匹配
-            const stem = posix(mp).replace(/\/+$/, '')
-            if (v === stem || v.startsWith(stem + '/')) return mid
+            // 模块 paths 目录/glob 语义——modulePathMatches 统一入口（**/*.tsx 等扫描卡形态可命中）
+            if (modulePathMatches(v, mp)) return mid
           }
           return null
         }
@@ -542,6 +570,27 @@ export function graphChangelogDanglings(graph, { existsFn = existsSync } = {}) {
   return out
 }
 
+/** 登记仓前缀（graph 惰性缓存）：<specRoot>/projects/*.yaml 的 name: 字段——本 spec 树管理
+ *  多仓时（register-repo 机制），跨仓交付路径（backend/**、frontend/**…）按前缀归到登记仓名下，
+ *  不再落 _unmapped 大簇（2026-10-15-graph-registry-domain-split：真图 2183 未挂模块文件节点
+ *  实测 1220 为跨仓前缀、421 为本仓 test 面）。无 projects 目录/解析失败 = 空集（fail-soft）。 */
+function registryProjectPrefixes(graph) {
+  if (graph._projPrefixes) return graph._projPrefixes
+  const out = []
+  try {
+    const dir = join(String(graph.root || ''), 'projects')
+    if (existsSync(dir)) {
+      for (const f of readdirSync(dir)) {
+        if (!f.endsWith('.yaml')) continue
+        const m = /^name:\s*([\w-]+)\s*$/m.exec(readFileSync(join(dir, f), 'utf8'))
+        if (m) out.push(m[1])
+      }
+    }
+  } catch { /* projects 缺席/不可读 = 无登记前缀 */ }
+  graph._projPrefixes = out
+  return out
+}
+
 /** 节点 → 簇域（lite 总览聚类键 type×domain；缺省占位防散簇）。 */
 function graphNodeDomain(graph, n) {
   switch (n.type) {
@@ -550,7 +599,20 @@ function graphNodeDomain(graph, n) {
     case 'file': {
       // module-files 精确挂接反查（多挂取最长模块 id——窄域优先）
       const mods = graph.edges.filter((e) => e.type === 'module-files' && e.t === n.id).map((e) => e.s.replace(/^module:/, ''))
-      return mods.sort((a, b) => b.length - a.length)[0] || '_unmapped'
+      if (mods.length > 0) return mods.sort((a, b) => b.length - a.length)[0]
+      // 登记仓前缀归属（2026-10-15-graph-registry-domain-split）：跨仓交付路径按 projects 登记
+      // 名归簇（最长前缀优先、大小写不敏感——登记名 SillyHub vs 路径 sillyhub/ 实证）；本仓
+      // 测试面归 _tests——残余 _unmapped 只剩真无归属面（module-map 覆盖缺口，可行动）
+      const id = String(n.id)
+      const idLower = id.toLowerCase()
+      let best = ''
+      for (const p of registryProjectPrefixes(graph)) {
+        const pl = p.toLowerCase()
+        if (idLower.startsWith(`${pl}/`) && pl.length > best.length) best = p
+      }
+      if (best) return best
+      if (/^(test|tests)\//.test(id)) return '_tests'
+      return '_unmapped'
     }
     case 'module':
       return n.id.replace(/^module:/, '')
@@ -573,12 +635,18 @@ export function graphSummary(graph, { existsFn = existsSync, clustersLimit = 0 }
   const orphans = graphOrphans(graph).length
   const dangling = graphDangling(graph, { existsFn })
   const danglingRefs = dangling.length
+  // 跨仓口径分流（2026-10-15-graph-dangling-crossrepo-split）：知识库集中管理仓、代码分仓存放
+  // 是本体系常态拓扑——跨仓强边锚点（顶级目录本仓不存在）永不可在本仓解析却全数计入 dangling_refs，
+  // 健康数字长期失真（本仓实证 2537 中 2472 为跨仓注记）。主计数与守恒口径不动（消费方零回归），
+  // 增加分流字段：breakdown.cross_repo=跨仓注记数、dangling_refs_local=本仓可行动悬空数。
+  const danglingCrossRepo = dangling.filter((d) => d.crossRepo).length
   // 分强度计数（附加字段——dangling_refs 是两类之和，消费方对账 doctor 时按 breakdown 拆）
   const danglingBreakdown = dangling.reduce((a, d) => {
     if (EDGE_STRENGTH[d.edge.type] === 'strong') a.strong_anchors++
     else if (EDGE_STRENGTH[d.edge.type] === 'medium') a.medium_doc_refs++
     return a
   }, { strong_anchors: 0, medium_doc_refs: 0 })
+  danglingBreakdown.cross_repo = danglingCrossRepo
   const moduleDocGaps = graphModuleDocGaps(graph).length
   const changelogDanglings = graphChangelogDanglings(graph, { existsFn }).length
   // clusters：type×domain 聚簇，representatives 度数 top-5（同度按 id 字典序稳序）
@@ -612,7 +680,10 @@ export function graphSummary(graph, { existsFn = existsSync, clustersLimit = 0 }
     module_doc_gaps: moduleDocGaps,
     changelog_danglings: changelogDanglings,
     dangling_refs: danglingRefs,
-    // dangling_refs 构成（附加字段，向后兼容）：doctor graph-dangling-anchor（强）+ graph-doc-dangling-ref（中）之和
+    // 本仓可行动悬空（附加字段，跨仓口径分流）：dangling_refs − 跨仓注记——治理动作只看这个数
+    dangling_refs_local: danglingRefs - danglingCrossRepo,
+    // dangling_refs 构成（附加字段，向后兼容）：doctor graph-dangling-anchor（强）+ graph-doc-dangling-ref（中）之和；
+    // cross_repo=跨仓注记数（顶级目录本仓不存在——目标活在独立仓，单列不对账）
     dangling_refs_breakdown: danglingBreakdown,
     clusters,
   }
@@ -791,7 +862,7 @@ export function impactFromDecisionsMd(graph, text) {
 // 输出沿知识命令族全 JSON 约定（{ok,...data}）；人类可读摘要行内嵌 summary 字段。
 // ═══════════════════════════════════════════════════════════════
 
-const GRAPH_USAGE = '用法：sillyspec knowledge graph <summary|nodes|dump|neighbors|path|impact|orphans|dangling> [锚点...] [--search <模糊>] [--limit N] [--edges <边型>] [--depth N]；dump 需 --layout'
+const GRAPH_USAGE = '用法：sillyspec knowledge graph <summary|nodes|dump|neighbors|path|impact|orphans|dangling> [锚点...] [--search <模糊>] [--limit N] [--edges <边型>] [--depth N] [--local]；dump 需 --layout；dangling --local 只列本仓悬空（跨仓注记单列不对账）'
 
 export async function cmdKnowledgeGraph(dir, args, opts = {}) {
   const out = (ok, data, error) => console.log(JSON.stringify({ ok, ...(data || {}) , ...(error ? { error } : {}) }, null, 2))
@@ -822,7 +893,7 @@ export async function cmdKnowledgeGraph(dir, args, opts = {}) {
       stats: s,
       summary: [
         `节点 ${s.nodes} · 边 ${s.edges}`,
-        `孤儿 ${s.orphans} · 模块文档缺口 ${s.module_doc_gaps} · changelog 悬空 ${s.changelog_danglings} · 悬空引用 ${s.dangling_refs}`,
+        `孤儿 ${s.orphans} · 模块文档缺口 ${s.module_doc_gaps} · changelog 悬空 ${s.changelog_danglings} · 悬空引用 ${s.dangling_refs}（本仓 ${s.dangling_refs_local} · 跨仓注记 ${s.dangling_refs_breakdown.cross_repo}——目标仓不在本仓，单列不对账）`,
         `簇 ${s.clusters.length} 个（最大 ${s.clusters[0]?.key ?? '—'} × ${s.clusters[0]?.count ?? 0}）`,
       ],
     })
@@ -907,12 +978,18 @@ export async function cmdKnowledgeGraph(dir, args, opts = {}) {
       orphans: list.map((f) => ({ id: f.node.id, type: f.node.type, kind: f.kind })),
     })
   }
-  // dangling
-  const list = graphDangling(graph)
+  // dangling（--local 过滤跨仓注记：治理动作只看本仓可解析面——跨仓目标活在独立仓）
+  const localOnly = args.includes('--local')
+  const allDangling = graphDangling(graph)
+  const crossRepoCount = allDangling.filter((d) => d.crossRepo).length
+  const list = localOnly ? allDangling.filter((d) => !d.crossRepo) : allDangling
   return out(true, {
-    query: { sub },
+    query: { sub, local: localOnly || undefined },
     count: list.length,
-    summary: list.map((d) => `⚠️ ${d.edge.type}（${d.strength}） ${d.edge.s} → ${d.missing}`),
+    summary: list.map((d) => `⚠️ ${d.edge.type}（${d.strength}） ${d.edge.s} → ${d.missing}${d.crossRepo ? ' 〔跨仓注记〕' : ''}`),
     dangling: list.map((d) => ({ edge: d.edge, missing: d.missing, strength: d.strength })),
+    // 口径分流（附加字段）：本仓可行动数 + 跨仓注记数单列不对账；--local 时 count 即本仓数
+    dangling_refs_local: allDangling.length - crossRepoCount,
+    cross_repo: crossRepoCount,
   })
 }

package/src/knowledge-match.js

@@ -61,7 +61,7 @@ function isDecisionRoute(entry) {
   return /^decisions\//.test(String(entry.file || '').replace(/\\/g, '/'))
 }
 
-const DECISION_HEADER_RE = /^##\s+(D-\d+@v\d+)\s*(.*)$/
+const DECISION_HEADER_RE = /^##\s+(D-(?:[A-Za-z0-9_\-\u4e00-\u9fff]+-)?\d+@v\d+)\s*(.*)$/
 const DECISION_FIELD_RE = /^(状态|文件|理由|否决理由|复潮条件|supersedes)\s*[：:]\s*(.*)$/
 // 「锚点：」单独标签精确匹配读入（仿 docs-check.js parseDecisionEntries 先例）——绝不并入
 // DECISION_FIELD_RE：其 else-if 链末尾的 reason 回填（else if (!cur.reason)）会把锚点值
@@ -69,6 +69,12 @@ const DECISION_FIELD_RE = /^(状态|文件|理由|否决理由|复潮条件|supe
 const DECISION_ANCHOR_RE = /^锚点\s*[：:]\s*(.*)$/
 // 变更：单独标签（变更名限定——D-xxx 是变更内局部序号，跨变更同号互不相干，去重键依赖它）
 const DECISION_CHANGE_RE = /^变更\s*[：:]\s*(.*)$/
+// 来源：兜底标签（2026-10-14-decision-id-p2-hardening）：2026-08-24 首修形态残留（后被「变更：」
+// 取代，现存 20 行）——变更行无条件覆盖在前，来源仅补缺（任意行序下变更优先）
+const DECISION_ORIGIN_RE = /^来源\s*[：:]\s*(.*)$/
+// 原编号：溯源标签（2026-10-14-decision-global-id-epoch）：epoch 形态条目的局部号——graph
+// supersedes 经它把「supersedes：D-011@v1」解析到同变更全局号段
+const DECISION_ORIGINID_RE = /^原编号\s*[：:]\s*(.*)$/
 
 /** 「文件：」值切分 + 逐项反斜杠归一 POSIX（与 decision-distill 的 entry.files 契约对齐：
  *  split /[,，、\s]+/ + replace(/\\/g,'/')）。 */
@@ -133,7 +139,7 @@ function parseDecisionFile(filePath, file) {
     const h = line.match(DECISION_HEADER_RE)
     if (h) {
       flush()
-      cur = { file, id: h[1], title: h[2].trim(), status: '', reason: '', revisitWhen: '', files: [], anchor: '', change: '', supersedesText: '' }
+      cur = { file, id: h[1], title: h[2].trim(), status: '', reason: '', revisitWhen: '', files: [], anchor: '', change: '', supersedesText: '', originId: '' }
       continue
     }
     if (!cur) continue
@@ -144,6 +150,10 @@ function parseDecisionFile(filePath, file) {
     // 域文件跨变更同号条目常见（D-xxx 是变更内局部序号），去重键须含变更名否则先到条目遮蔽后来者）
     const c = line.match(DECISION_CHANGE_RE)
     if (c) { cur.change = c[1].trim(); continue }
+    const o = line.match(DECISION_ORIGIN_RE)
+    if (o) { if (!cur.change) cur.change = o[1].trim(); continue }
+    const oi = line.match(DECISION_ORIGINID_RE)
+    if (oi) { cur.originId = oi[1].trim(); continue }
     const f = line.match(DECISION_FIELD_RE)
     if (!f) continue
     const value = f[2].trim()
@@ -170,20 +180,25 @@ function parseDecisionFile(filePath, file) {
 export function parseDecisionEntries(indexDir, indexEntries = null) {
   const routes = (indexEntries || parseKnowledgeIndex(indexDir)).filter(isDecisionRoute)
   const hits = []
+  // 路由行按文件去重单解析（2026-10-14-decision-id-p2-hardening）：多条路由行指向同一域文件只解析
+  // 一次——此前靠条目级折叠兜完全重复，legacy 不折叠后从源头消除重复
+  const parsed = new Set()
   for (const route of routes) {
+    const fileKey = String(route.file || '').replace(/\\/g, '/')
+    if (parsed.has(fileKey)) continue
+    parsed.add(fileKey)
     const filePath = join(indexDir, route.file)
     if (!existsSync(filePath)) continue // 路由行失效（域文件已删）→ 跳过不阻断
     hits.push(...parseDecisionFile(filePath, route.file))
   }
-  // 多条路由行指向同一域文件时按 file+id+变更 去重（完全重复折叠）；键含变更名——
-  // 跨变更同号条目（D-xxx 是变更内局部序号，域文件内同 id 不同变更常见）不再被先到者
-  // 遮蔽（坑 decision-cross-change-id-shadow，2026-09-11 dogfood 实证：runtime.md 七个
-  // D-001@v1 分属七变更，旧键只放行首个——同号 rejected 决策在 {DECISION_HITS} 防复潮
-  // 注入同样被遮蔽）。无「变更：」行的 legacy 条目 change='' 与同号 legacy 条目互折叠
-  // （维持旧行为，不放大历史条目数）。
+  // 带 change 条目按 file+id+change 去重（坑 decision-cross-change-id-shadow，2026-09-11 dogfood 实证：
+  // 域文件跨变更同号条目常见，键须含变更名否则先到遮蔽——runtime.md 七个 D-001@v1 分属七变更）。
+  // 无「变更：/来源：」行的 legacy 条目不再互折叠（2026-10-14-decision-id-p2-hardening：旧互折叠致
+  // 同号 legacy 互相遮蔽——实测 2 条 implemented 条目永久隐身；路由单解析后完全重复已从源头消除）。
   const seen = new Set()
   return hits.filter(h => {
-    const key = `${h.file}#${h.id}#${h.change || ''}`
+    if (!h.change) return true
+    const key = `${h.file}#${h.id}#${h.change}`
     if (seen.has(key)) return false
     seen.add(key)
     return true
@@ -221,6 +236,16 @@ export function matchDecisionsByFiles(indexDir, files) {
   return result
 }
 
+/** 决策展示行变更名限定词（2026-10-14-supersedes-mislink-and-change-display）：D-xxx 是变更内
+ *  局部序号，跨变更同号条目常见（知识库 D-001@v1 ×296、其中 192 条同题）——四处展示面
+ *  （{DECISION_HITS}/轻量道防复潮/knowledge-gate/decision-touch）经本函数统一渲染限定词消歧；
+ *  change 缺失（legacy 无「变更：」行）固定降级「变更未记录」——不编造、不省略。
+ *  单一源防四处文案漂移（与 deathPathNote 同址同规约）。 */
+export function decisionChangeQualifier(change) {
+  const c = String(change || '').trim()
+  return c ? `变更 ${c}` : '变更未记录'
+}
+
 /** 死路注记短句提取（消费方渲染用）：理由里「死路：…」到首个句读为止；无标记时截前 60 字。
  *  单一源供 flow 知识注入段与 complete.js knowledge-gate 回显共用（2026-09-28-knowledge-inject-ranking）。 */
 export function deathPathNote(reason) {

package/src/knowledge-stats.js

@@ -99,6 +99,10 @@ export function buildHitMatrix(knowledgeDir, runtimeDir, { sinceDays = 30 } = {}
 }
 
 // ── FR 索引实验聚合（2026-09-18-fr-index-l1 后续钩子·L3 裁决仪表盘）──
+// L3 已裁决冻结（2026-10-15-fr-chain-l3-adjudication D-001@v1）：证伪三条件全中（承接引用率
+// 1/452≈0% / fr-supersede 窗口 2 次 / fr-duplicate-warning 24 次零候选），条款明文合法结局——
+// 活规格树不建，fr 索引降级保留检索/注入面；本区指标转历史观察，候选视图退役为冻结注记。
+const FR_L3_ADJUDICATED_NOTE = '已裁决（2026-10-15 D-001@v1）：L3 冻结不建，fr 索引保留检索/注入面——本区指标转历史观察（复潮条件见裁决条目）'
 
 /**
  * 聚合 L1 四类 fr-* 遥测事件 + knowledge/fr/ 索引面统计——L3 裁决（design 实验证伪条款）
@@ -314,7 +318,7 @@ export async function cmdKnowledgeStats(dir, args, opts = {}) {
     if (frIndex.present) {
       const e = frIndex.events
       const i = frIndex.index
-      lines.push(`🔬 FR 索引实验（窗口内事件 / 索引面全量——L3 裁决指标，证伪条款见 2026-09-18-fr-index-l1 design）`)
+      lines.push(`🔬 FR 索引实验（窗口内事件 / 索引面全量——L3 裁决指标，证伪条款见 2026-09-18-fr-index-l1 design）｜${FR_L3_ADJUDICATED_NOTE}`)
       lines.push(`  注入 fr-inject ${e.frInject} 次（${e.frInjectChanges} 变更） | 取代链 fr-supersede ${e.frSupersede} 次（${e.frSupersedeChanges} 变更） | 重复拦截 fr-duplicate-warning ${e.frDuplicateWarning} 次（${e.frDuplicateWarningCandidates || e.frDuplicateCandidates || 0} 候选）`)
       lines.push(`  腐烂 suspect fr-rot-suspect ${e.frRotSuspect || 0} 次（${e.frRotSuspectChanges || 0} 变更${e.frRotSuspectByDomain && e.frRotSuspectByDomain.length > 0 ? `，按域 ${e.frRotSuspectByDomain.map(d => `${d.domain}×${d.count}`).join('，')}` : ''}）`)
       if (e.frUnreferenced.length > 0) {
@@ -325,10 +329,8 @@ export async function cmdKnowledgeStats(dir, args, opts = {}) {
       lines.push(`  承接引用率：${frIndex.supersedeRate === null ? '—（索引空）' : `${(frIndex.supersedeRate * 100).toFixed(0)}%（${e.frSupersedeChanges}/${i.sourceChanges}，分子窗口内/分母全量——裁决用大窗口）`}`)
       const cand = frIndex.adjudicationCandidates || []
       if (cand.length > 0) {
-        lines.push('  裁决候选 Top-10（suspect×unref 条目级聚合——候选非裁决，确认无人承接→承接翻链或人工退休）：')
-        for (const c of cand.slice(0, 10)) {
-          lines.push(`    - ${c.id} suspect×${c.suspect} unref×${c.unreferenced}${c.change ? `（来源 ${c.change}）` : ''}`)
-        }
+        // L3 冻结后候选视图退役（数据面 adjudicationCandidates 保留 JSON 可查）——显示冻结注记
+        lines.push(`  裁决候选视图已退役｜${FR_L3_ADJUDICATED_NOTE}`)
       }
     } else {
       lines.push('（FR 索引面不存在——knowledge/fr/ 目录缺失或无条目；归档完整流程变更后此处可查）')
@@ -375,12 +377,12 @@ export async function cmdKnowledgeStats(dir, args, opts = {}) {
 
   lines.push(`遥测计数（窗口内）：注入 ${result.totalInjects} 次 | 归类 ${result.totalClassifies} 次${lastEventAt ? ` | 数据截至 ${lastEventAt.slice(0, 10)}` : ''}`)
 
-  // FR 索引实验（L3 裁决仪表盘——证伪条款出数面；裁决时建议 --since-days 大窗口读全口径）
+  // FR 索引实验（L3 裁决仪表盘——证伪条款出数面；L3 已裁决冻结 2026-10-15，指标转历史观察）
   if (frIndex.present) {
     const e = frIndex.events
     const i = frIndex.index
     lines.push('')
-    lines.push(`🔬 FR 索引实验（窗口内事件 / 索引面全量——L3 裁决指标，证伪条款见 2026-09-18-fr-index-l1 design）`)
+    lines.push(`🔬 FR 索引实验（窗口内事件 / 索引面全量——L3 裁决指标，证伪条款见 2026-09-18-fr-index-l1 design）｜${FR_L3_ADJUDICATED_NOTE}`)
     lines.push(`  注入 fr-inject ${e.frInject} 次（${e.frInjectChanges} 变更） | 取代链 fr-supersede ${e.frSupersede} 次（${e.frSupersedeChanges} 变更） | 重复拦截 fr-duplicate-warning ${e.frDuplicateWarning} 次（${e.frDuplicateCandidates} 候选）`)
     if (e.frUnreferenced.length > 0) {
       const top = e.frUnreferenced.slice(0, 5).map((u) => `${u.domain}×${u.count}`).join('，')
@@ -388,14 +390,11 @@ export async function cmdKnowledgeStats(dir, args, opts = {}) {
     }
     lines.push(`  索引面：${i.entries} 条（active ${i.active} / superseded ${i.superseded}）| 来源变更 ${i.sourceChanges} 个 | 域 ${i.domains.join(', ') || '—'}`)
     lines.push(`  承接引用率：${frIndex.supersedeRate === null ? '—（索引空）' : `${(frIndex.supersedeRate * 100).toFixed(0)}%（${e.frSupersedeChanges}/${i.sourceChanges}，分子窗口内/分母全量——裁决用大窗口）`}`)
-    // 裁决候选视图（2026-10-03-fr-governance-telemetry）：条目级 id 聚合（事件 frIds/ids，帽 20 抽样
-    // 为下界）。候选非裁决——高 suspect 天然来自热文件；处置出口：确认无人承接 → 承接翻链或人工退休。
+    // 裁决候选视图退役（L3 冻结，2026-10-15-fr-chain-l3-adjudication D-001@v1）——数据面
+    // adjudicationCandidates 保留 JSON 可查，显示面只留冻结注记。
     const cand = frIndex.adjudicationCandidates || []
     if (cand.length > 0) {
-      lines.push('  裁决候选 Top-10（suspect×unref 条目级聚合——候选非裁决，确认无人承接→承接翻链或人工退休）：')
-      for (const c of cand.slice(0, 10)) {
-        lines.push(`    - ${c.id} suspect×${c.suspect} unref×${c.unreferenced}${c.change ? `（来源 ${c.change}）` : ''}`)
-      }
+      lines.push(`  裁决候选视图已退役｜${FR_L3_ADJUDICATED_NOTE}`)
     }
   }
 

package/src/knowledge-vector.js

@@ -18,20 +18,65 @@
  *                "change": "2026-09-26-thin-agent-tasks", "score": 0.83 } ] }
  *   anchor = 决策条目 id（## D-xxx@vN）；change = 条目「变更：」字段——同号条目跨变更常见
  *   （runtime.md 七个 D-001@v1 先例），change 在场时消歧；缺省时同号条目全量带回（候选诚实）。
+ *   epoch 注记（2026-10-14-decision-global-id-epoch）：新蒸馏条目 anchor 为全局号形态
+ *   D-<域>-NNN@vN——等值匹配语义不变；平台重建索引窗口内向量召回对新形态条目降级
+ *   （本地词面回退不受影响），重索引后恢复。
  *
  * 降级纪律：任何失败（未连接/开关关闭/网络/404/5xx/超时/响应形态不符）静默降级本地层
  * ——检索是 advisory 面且高频（每方案步 --done），失败刷屏即狼来了；debug 排障可设
  * SILLYSPEC_KNOWLEDGE_VECTOR_DEBUG=1 打单行stderr。
+ *
+ * 开关契约（2026-10-15-vector-capability-autodetect 终态；前身 vector-gate-tighten 缺省关是
+ * 「端点不存在+无发现机制」时代的正确补丁，平台端点落地后 auto 成为诚实缺省）：
+ * 缺省（未写键/auto）跟随平台能力自动探测——能力缓存 .runtime/vector-capability.json
+ * （404→unavailable 重试窗 1h 内跳过；成功→available；按平台 URL 匹配；跨进程持久），
+ * 平台部署端点后最迟 1h 全仓自动启用，消费仓零配置。local.yaml on=强制开跳过探测、
+ * off=强制关（用户逃生阀）；env SILLYSPEC_KNOWLEDGE_VECTOR 同语义强制。
+ * 404 另有进程级死信短路（端点死信不再空转探测）。
  */
-import { readFileSync } from 'fs'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
 import { join, dirname } from 'path'
 import { readPlatformConfig } from './sync.js'
 import { matchByRouting, fallbackByQueryShingles, parseDecisionEntries } from './knowledge-match.js'
 
 const VECTOR_TIMEOUT_MS = 3000
 const ENDPOINT_PATH = '/api/spec/knowledge/vector-search'
+/** 能力缓存重试窗：unavailable 记录 1h 内不再探测（平台部署后最迟 1h 自动启用）。 */
+const CAPABILITY_RETRY_MS = 60 * 60 * 1000
+
+// ── 平台能力探测缓存（2026-10-15-vector-capability-autodetect）────────────────
+// .runtime/ 已 gitignored 且被 daemon spec 上传排除（UPLOAD_EXCLUDE_TOP_BASE），是仓内
+// 机器态的标准落点（knowledge-hits 同款）。写盘全 fail-soft；按平台 URL 匹配（换平台即失效）。
+
+function capabilityCachePath(cwd) {
+  return join(cwd, '.sillyspec', '.runtime', 'vector-capability.json')
+}
+
+function readCapabilityCache(cwd) {
+  try {
+    const obj = JSON.parse(readFileSync(capabilityCachePath(cwd), 'utf-8'))
+    const cfg = readPlatformConfig(cwd)
+    if (!cfg || !cfg.url) return null
+    if (obj.url !== String(cfg.url).replace(/\/+$/, '')) return null // 换平台 → 缓存失效
+    if (typeof obj.available !== 'boolean' || typeof obj.probedAt !== 'number') return null
+    return { available: obj.available, probedAt: obj.probedAt }
+  } catch { /* 无缓存/坏 JSON = 未探测 */ }
+  return null
+}
+
+function writeCapabilityCache(cwd, platformUrl, available) {
+  try {
+    const p = capabilityCachePath(cwd)
+    const cur = readCapabilityCache(cwd)
+    if (cur && cur.available === available && Date.now() - cur.probedAt < CAPABILITY_RETRY_MS) return // 值未变且未过期：零写盘
+    const dir = join(p, '..')
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+    writeFileSync(p, JSON.stringify({ url: platformUrl, available, probedAt: Date.now() }), 'utf-8')
+  } catch { /* 缓存写失败不影响检索本体（fail-soft） */ }
+}
 
-/** local.yaml knowledge.vector_search 开关（行级扫描 knowledge: 段下 vector_search: off）。 */
+/** local.yaml knowledge.vector_search 开关（行级扫描 knowledge: 段下 vector_search 值；
+ *  未写键/无 yaml → null=未表态——2026-10-15-vector-gate-tighten 起缺省关，显式落盘才启用）。 */
 function vectorSwitchFromLocalYaml(cwd) {
   try {
     const lines = readFileSync(join(cwd, '.sillyspec', 'local.yaml'), 'utf-8').split(/\r?\n/)
@@ -43,16 +88,55 @@ function vectorSwitchFromLocalYaml(cwd) {
       const kv = line.match(/^\s+vector_search\s*:\s*(\S+)/)
       if (kv) return kv[1].toLowerCase()
     }
-  } catch { /* 无 local.yaml = 缺省 auto */ }
-  return 'auto'
+  } catch { /* 无 local.yaml = 未表态 */ }
+  return null
 }
 
+/**
+ * 向量层开关（2026-10-15-vector-capability-autodetect 终态契约；前身 2026-10-15-vector-gate-tighten
+ * 缺省关是「端点不存在+无发现机制」时代的正确补丁，端点落地后 auto 成为诚实缺省）：
+ *   env SILLYSPEC_KNOWLEDGE_VECTOR=on|auto → 强制启用；off（其他值保守视为 off）→ 强制关；
+ *   local.yaml knowledge.vector_search: on → 强制启用；off → 强制关（用户显式逃生阀）；
+ *   auto/未写键 → **跟随平台能力自动探测**：读能力缓存（.runtime/vector-capability.json，
+ *   {url,available,probedAt}）——unavailable 未过重试窗（1h）=关，否则乐观试（探测结果由
+ *   platformVectorRecall 落缓存，404→unavailable / 成功→available；跨进程持久）。
+ * 「端点部署本身就是开关」——平台部署后最迟 1h 内全仓自动启用，消费仓零配置。
+ */
 function vectorEnabled(cwd) {
   const env = String(process.env.SILLYSPEC_KNOWLEDGE_VECTOR || '').toLowerCase()
-  if (env === 'off' || env === 'auto') return env === 'auto'
-  return vectorSwitchFromLocalYaml(cwd) !== 'off'
+  if (env === 'on' || env === 'auto') return true
+  if (env) return false
+  const sw = vectorSwitchFromLocalYaml(cwd)
+  if (sw === 'off') return false
+  if (sw === 'on') return true
+  // absent/auto → 能力缓存判定（无平台配置=没得探测=关）
+  if (!readPlatformConfig(cwd)) return false
+  const cap = readCapabilityCache(cwd)
+  if (cap && !cap.available && Date.now() - cap.probedAt < CAPABILITY_RETRY_MS) return false
+  return true
 }
 
+/**
+ * 向量能力提示（2026-10-15-vector-capability-autodetect 语义随迁；前身 vector-switch-discoverability
+ * 的「未开请配置」提示随缺省 auto 退役——auto 模式下没有可执行配置，提示转为信息性）：
+ * 仅当 auto 模式（无显式键/键=auto）且能力缓存记 unavailable 时给一行信息——「平台部署后
+ * 自动启用，无需本仓配置」。强制关（yaml off/env off=用户显式选择）与已启用 → ''（零噪音）。
+ * 平台未连接 → ''。
+ */
+export function vectorSwitchHint(cwd) {
+  if (!readPlatformConfig(cwd)) return ''
+  if (vectorEnabled(cwd)) return ''
+  const cap = readCapabilityCache(cwd)
+  if (cap && !cap.available) {
+    return `ℹ️ 平台向量语义检索未就绪（自动探测缓存生效中）——平台部署 vector-search 端点后最迟 1 小时内本仓自动启用，无需配置`
+  }
+  return ''
+}
+
+/** 404 死信端点（进程级，按平台 URL 记）：端点未实现=今天真实平台状态，标记后本进程不再
+ *  对同 URL 空转探测（CLI 短进程生命周期天然重置；测试各用独立端口互不污染）。 */
+const vectorDeadEndpoints = new Set()
+
 /**
  * 平台向量召回（纯 HTTP 层）。未连接/失败/形态不符 → null（调用方降级）。
  * @returns {Promise<{results: Array<{spec_path: string, anchor: string, score: number}>}|null>}
@@ -60,19 +144,26 @@ function vectorEnabled(cwd) {
 export async function platformVectorRecall({ cwd, query, limit = 10, timeoutMs = VECTOR_TIMEOUT_MS }) {
   const cfg = readPlatformConfig(cwd)
   if (!cfg || !cfg.url || !cfg.token) return null
+  const base = String(cfg.url).replace(/\/+$/, '')
+  if (vectorDeadEndpoints.has(base)) return null
   const q = String(query || '').trim().slice(0, 4000)
   if (!q) return null
   try {
-    const res = await fetch(`${String(cfg.url).replace(/\/+$/, '')}${ENDPOINT_PATH}`, {
+    const res = await fetch(`${base}${ENDPOINT_PATH}`, {
       method: 'POST',
       headers: { Authorization: `Bearer ${cfg.token}`, 'Content-Type': 'application/json' },
       body: JSON.stringify({ query: q, limit }),
       signal: AbortSignal.timeout(timeoutMs),
     })
     if (!res.ok) {
+      if (res.status === 404) {
+        vectorDeadEndpoints.add(base) // 端点未实现——本进程短路后续探测
+        writeCapabilityCache(cwd, base, false) // 跨进程持久：重试窗内不再探测（平台部署后自动启用）
+      }
       if (process.env.SILLYSPEC_KNOWLEDGE_VECTOR_DEBUG) console.error(`[knowledge-vector] ${res.status} ${ENDPOINT_PATH}——降级本地`)
       return null
     }
+    writeCapabilityCache(cwd, base, true) // 端点在场——缓存 available（后续进程零探测直用）
     const body = await res.json().catch(() => null)
     const results = body && Array.isArray(body.results)
       ? body.results.filter((r) => r && typeof r.spec_path === 'string' && typeof r.anchor === 'string')

package/src/machine-interface.js

@@ -187,10 +187,25 @@ export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot, s
     // 各 spawn 2 个 git 进程（gate execute 一次省 ≈ 60-200ms on Windows）。
     const sharedEvidence = stage === 'execute' ? checkExecuteCodeEvidence(cwd, changeName) : undefined;
 
+    // ── gate 预检实况注入（2026-10-14-gate-verify-apiface-preflight FR-01~FR-03）：facts.apiFace
+    // 唯一生产者是 run verify --done 收尾前置 backfill（run/gates.js），gate 路径不回填且 --init
+    // 刻意不落键 → 锚点核对 parseSet 空/旧 → design接口表# 锚点恒空指（平台 6 轮 gate 实证）。
+    // 此处以同一解析器实况解析 design.md 经 context 注入 validator（与 --done backfill 产物同形
+    // 同源，零落盘守 D-002 只读契约）；design.md 缺失/不可读 helper 返 null、解析异常 fail-soft
+    // ——两种态都不注入，退回 facts 口径（现状行为；评审 P1：空面注入会覆写有效 facts 反致误阻断）。──
+    let apiFaceLive = null;
+    if (stage === 'verify') {
+      try {
+        const { computeApiFaceFromDesign } = await import('./verify-probes.js');
+        apiFaceLive = computeApiFaceFromDesign(join(specRoot, 'changes', changeName, 'design.md'));
+      } catch { /* fail-soft：不注入退回 facts 口径 */ }
+    }
+
     // ── a. artifacts：阶段产物校验（全部阶段）──
     const r = runValidators(stage, cwd, changeName, {
       projectName: progress.project,
       specRoot,
+      ...(apiFaceLive ? { apiFaceLive } : {}),
       ...(sharedEvidence ? { evidence: sharedEvidence } : {}),
     });
     checks.push({
@@ -752,10 +767,21 @@ export async function runDerive(facet, changeName, { cwd, specBase, runtimeRoot,
 
       // ── d. artifacts：当前阶段产物校验 ──
       // runValidators 需要 stage：用 progress.currentStage（若为空串则校验器内部处理）。
+      // verify 阶段同款实况注入（2026-10-14-gate-verify-apiface-preflight）：与 runGate 同因——
+      // facts.apiFace 唯一生产者是 --done backfill，derive 不回填 → 锚点核对恒空指；零落盘 +
+      // fail-soft（缺失返 null/异常两态都不注入退回 facts 口径），守 D-002 只读契约。
       case 'artifacts': {
+        let apiFaceLive = null;
+        if (currentStage === 'verify') {
+          try {
+            const { computeApiFaceFromDesign } = await import('./verify-probes.js');
+            apiFaceLive = computeApiFaceFromDesign(join(specRoot, 'changes', changeName, 'design.md'));
+          } catch { /* fail-soft：不注入退回 facts 口径 */ }
+        }
         const r = runValidators(currentStage, cwd, changeName, {
           projectName: progress.project,
           specRoot,
+          ...(apiFaceLive ? { apiFaceLive } : {}),
         });
         data = { ok: r.ok, errors: r.errors, warnings: r.warnings };
         ok = r.ok;

package/src/module-impact.js

@@ -14,6 +14,7 @@
  * 归属分类同一套 module-map 前缀匹配，仅输入来源不同。
  */
 import { existsSync, readFileSync, readdirSync, writeFileSync } from 'fs'
+import { modulePathMatches } from './modules.js'
 import { join } from 'path'
 import { resolveVerifyChangedFiles } from './verify-postcheck.js'
 import { resolveSpecDir } from './run/shared.js'
@@ -87,11 +88,7 @@ function classifyFile(posixPath, modulePaths) {
   for (const [moduleId, paths] of modulePaths) {
     for (const p of paths) {
       // 目录条目以 / 结尾 → 前缀匹配；文件条目 → 精确或子路径（与模块上下文索引读侧口径一致）
-      if (p.endsWith('/')) {
-        if (posixPath.startsWith(p)) return moduleId
-      } else if (posixPath === p || posixPath.startsWith(p + '/')) {
-        return moduleId
-      }
+      if (modulePathMatches(posixPath, p)) return moduleId
     }
   }
   return null

package/src/modules.js

@@ -2,6 +2,37 @@ import { existsSync, readdirSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { gitQuiet } from './git-helper.js';
 import { nowWallClock } from './datetime.js';
+import { globMatch } from './change-list.js';
+
+/**
+ * 模块 paths 条目 × 文件路径 的统一归属判定（2026-10-15-module-path-glob-match）。
+ *
+ * 背景：sillyspec-scan 生成的 module-map（消费仓）大量使用 glob 形态 paths——
+ * `app/modules/daemon/**`、`frontend/src/components/daemon/*.tsx`、多段通配与文件通配的
+ * 组合（`**` 与 `*.tsx` 同串）、括号路径等（平台仓实测 146 条）——而历史各消费点只做朴素
+ * `file === p || startsWith(p + '/')`，glob 条目恒不命中（恰好只有精确文件路径能命中），
+ * 导致消费仓全链路域路由失效：交付文件匹配不上模块 → 三级兜底全灭 → FR 铸伪域
+ * （auto-backend 等）、决策落 unmapped。
+ *
+ * 语义（本仓无 glob map 时与旧各点逐字等价——零回归）：
+ *   - 尾部 `/` 的目录条目：startsWith（旧 module-impact 目录分支语义）
+ *   - 其余条目：相等 或 `p/` 前缀（旧 fr-index/ceremony-tier 等语义）
+ *   - 含 `*`/`?` 的 glob 条目：追加 globMatch（双星跨零或多段、单星段内、单问号单字符；
+ *     change-list.js 既有完备实现单一源复用）
+ * @param {string} filePath 仓根相对文件路径（含反斜杠容忍）
+ * @param {string} rawPattern module-map 的 paths/core_files 条目
+ * @returns {boolean}
+ */
+export function modulePathMatches(filePath, rawPattern) {
+  const f = String(filePath || '').replace(/\\/g, '/');
+  const raw = String(rawPattern || '').replace(/\\/g, '/');
+  if (!f || !raw) return false;
+  if (raw.endsWith('/')) return f.startsWith(raw);
+  const p = raw.replace(/\/+$/, '');
+  if (!p) return false;
+  if (f === p || f.startsWith(p + '/')) return true;
+  return globMatch(f, p);
+}
 
 
 /**