sillyspec 3.32.10 → 3.33.0

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('')
 

package/src/docs-debt.js

@@ -13,7 +13,7 @@
 import { existsSync, readFileSync, readdirSync, realpathSync } from 'node:fs'
 import { join, relative } from 'node:path'
 import { safeGit } from './git-helper.js'
-import { parseModuleMapSimple } from './modules.js'
+import { modulePathMatches, parseModuleMapSimple } from './modules.js'
 import { runDocsCheck, readDocsCheckConfig, parseDecisionEntries, anchorFilePath } from './docs-check.js'
 import { decisionChangeQualifier } from './knowledge-match.js'
 
@@ -55,9 +55,9 @@ export function matchFilesToModules(changedFiles, moduleIndex, opts = {}) {
 
   for (const f of changedFiles) {
     let matched = null
-    // 一级：paths/core_files 前缀或字面量命中
+    // 一级：paths/core_files 前缀或字面量命中（含 glob 形态——modulePathMatches 统一入口）
     for (const [id, ps] of modulePaths) {
-      if (ps.some(p => p === f || f.startsWith(p.replace(/\/$/, '') + '/') || p.startsWith(f.split('/')[0] + '/') && p === f)) {
+      if (ps.some((p) => modulePathMatches(f, p))) {
         matched = id; break
       }
     }

package/src/flow-parity.js

@@ -19,12 +19,14 @@
  *    命中模块变更索引机械回写（sidecar 优先、幂等）、start 注入面欠账事实行（提示前移）。
  */
 import { existsSync, readFileSync, writeFileSync, readdirSync } from 'node:fs'
+import { modulePathMatches } from './modules.js'
 import { join, relative } from 'node:path'
 import { createHash } from 'node:crypto'
 import { execFileSync } from 'node:child_process'
 import { splitOwnVsForeignDiffFiles, commitAttributionForChange, isForeignByCommit, parseChangeNamesFromSubject } from './foreign-declared.js'
 import { collectModuleMaps, normalizeMapPath } from './module-resolve.js'
 import { computeDocsDebt } from './docs-debt.js'
+import { anchorBackfillCandidate } from './decision-distill.js'
 import { writeAtomicSync } from './fs-atomic.js'
 import { normalizePath } from './change-list.js'
 import { readV2SectionAnswer } from './flow-review.js'
@@ -72,7 +74,7 @@ export function reconcileModuleDocs({ cwd, specBase, ownFiles, committedRaw }) {
         .map((pp) => (map.prefix + normalizeMapPath(pp)).replace(/\/+$/, ''))
         .filter(Boolean)
       if (effs.length === 0) continue
-      const hitFiles = deliverables.filter((f) => effs.some((e) => f === e || f.startsWith(e + '/')))
+      const hitFiles = deliverables.filter((f) => effs.some((e) => modulePathMatches(f, e)))
       if (hitFiles.length === 0) continue
       hits++
       const docRel = entry.doc ? `docs/${map.project}/${String(entry.doc).replace(/^\/+/, '')}` : null
@@ -93,7 +95,7 @@ export function reconcileModuleDocs({ cwd, specBase, ownFiles, committedRaw }) {
       for (const pp of entry.paths || []) allPaths.push((map.prefix + normalizeMapPath(pp)).replace(/\/+$/, ''))
     }
   }
-  const isCovered = (f) => allPaths.some((pp) => pp && (f === pp || f.startsWith(pp + '/')))
+  const isCovered = (f) => allPaths.some((pp) => pp && modulePathMatches(f, pp))
   const uncoveredMap = new Map()
   for (const f of deliverables) {
     if (isCovered(f)) continue
@@ -316,6 +318,11 @@ export function harvestSlot4Decision({ changeDir, change }) {
     answer = readV2SectionAnswer(dText, risksSec.heading, DESIGN_QUESTIONS)
   }
   if (!answer || /^不适用/.test(answer)) return { harvested: false, reason: '槽4 空/不适用' }
+  // 锚点自动回填（2026-10-15-decision-anchor-backfill 收割端）：风险段作答文本恰含一个
+  // 路径 token → 写入 - 锚点：行（源 decisions.md 是真相源，蒸馏自然带上、人可改）；
+  // 0/多候选不写（蒸馏端渲染时还会再兜底一次同款判定）。单一源 anchorBackfillCandidate。
+  const anchorCand = anchorBackfillCandidate(answer)
+  const anchorLine = anchorCand ? [`- 锚点：${anchorCand}`] : []
   const text = [
     '---',
     `author: flow-machine-draft`,
@@ -328,6 +335,7 @@ export function harvestSlot4Decision({ changeDir, change }) {
     `## D-001@v1: 设计期风险与放弃方案（底稿）`,
     `- 类型：process`,
     `- 状态：confirmed`,
+    ...anchorLine,
     // 类型/状态字段（2026-09-26-slot4-distill-fix）：蒸馏链入选要 status∈{confirmed|accepted|rejected}
     // 且 type∈七类白名单，字段解析只认 `- 字段：值` 列表行形态——此前收割条目零字段致永不入选，
     // 「随蒸馏链进 knowledge」断链（thin-agent-tasks 教训留档归档而 knowledge 零落地的实证）。

package/src/flow.js

@@ -1138,7 +1138,7 @@ export async function cmdFlowStart({ change, input, title: titleFlag = null, thi
     `   ②③断点 agent 自主跳过。`,
     `   随时可查进度：sillyspec flow status --change ${change}`,
     ...(detectUiTouch(input)
-      ? [...buildUiGuidanceLines(), '']
+      ? [...buildUiGuidanceLines(specBase), '']
       : []),
     ``,
     `【协议调用 2/2（干完后）】sillyspec flow done --change ${change}`,

package/src/forensics.js

@@ -0,0 +1,236 @@
+/**
+ * forensics.js — 会话取证证据包装配 + 取证任务书渲染（2026-10-15-session-forensics）
+ *
+ * 定位：`sillyspec diagnose --change <名>` 的只读装配面。对照 obra/superpowers
+ * diagnosing-superpowers 的取证形态做 SillySpec 原生版——分工沿本仓哲学：
+ * CLI 装配机械事实（证据包六面），agent 做语义判断（按任务书读 transcript、出
+ * path:line 证据报告）。全程零写入：证据源全是事后读取的静态文件，单源缺失/
+ * 损坏 fail-soft 空清单+注记，不抛错不阻断（取证要容忍现场变动）。
+ *
+ * 数据源（全部既有，零新格式）：
+ *   - 变更目录 / 归档目录（flow-state.yaml 身份面、review 轮次文件）
+ *   - <runtimeRoot>/agent-session-log.json（run 命令登记的会话日志路径，
+ *     按 change_key 精确相等过滤——登记面唯一键，无子串误命中面）
+ *   - <runtimeRoot>/friction-ledger.json（readFrictionLedger 既有 API）
+ *   - <runtimeRoot>/verify-runs/<时间戳目录>/test-result.json（mtime 近序取前 N）
+ *
+ * 红线：零内容枚举——任务书六维度是结构骨架（CLI 自有任务书面集合，同
+ * review_probes scope 判例），不是内容词表；CLI 不解析 transcript 本体
+ * （三 harness 格式 × 演化泥潭，解读交给 agent）。
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import yaml from 'js-yaml'
+import { readFrictionLedger } from './friction-ledger.js'
+
+/** verify-runs 证据默认截断数（近序 N 条，防大仓 runtime 灌爆输出；模块内常量——导出即死码债） */
+const VERIFY_RUNS_LIMIT = 3
+
+/** 读 JSON 文件，失败/不存在返回 null（fail-soft 取证立场）。 */
+function readJsonSafe(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/** 读 YAML 文件，失败/不存在返回 null。 */
+function readYamlSafe(path) {
+  try {
+    return yaml.load(readFileSync(path, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 装配证据包六面。纯读函数，零写入。
+ * @param {{ specBase: string, runtimeRoot: string, changeName: string, verifyRunsLimit?: number }} p
+ * @returns {{ identity: object, agentLogs: object[], friction: object[], verifyRuns: object[], reviews: object[], warnings: string[] }}
+ */
+export function assembleForensicsPack({ specBase, runtimeRoot, changeName, verifyRunsLimit = VERIFY_RUNS_LIMIT }) {
+  const warnings = []
+  const changeDir = join(specBase, 'changes', changeName)
+  const archivedDir = join(specBase, 'changes', 'archive', changeName)
+
+  // ① 变更身份（active / archived / missing + flow-state 态）
+  const identity = { changeName, status: 'missing', changeDir: null, archivedDir: null, tier: null, substeps: null }
+  if (existsSync(changeDir)) {
+    identity.status = 'active'
+    identity.changeDir = changeDir
+  } else if (existsSync(archivedDir)) {
+    identity.status = 'archived'
+    identity.changeDir = archivedDir
+    identity.archivedDir = archivedDir
+    warnings.push('变更已归档——证据包从归档目录读取，transcript 仍按登记路径取')
+  }
+  const flowStatePath = identity.changeDir ? join(identity.changeDir, 'flow-state.yaml') : null
+  if (flowStatePath && existsSync(flowStatePath)) {
+    const fs_ = readYamlSafe(flowStatePath)
+    if (fs_ && typeof fs_ === 'object') {
+      identity.tier = fs_.tier ?? null
+      identity.substeps = fs_.substeps && typeof fs_.substeps === 'object' ? fs_.substeps : null
+    } else {
+      warnings.push(`flow-state.yaml 解析失败（${flowStatePath}）——身份面降级`)
+    }
+  } else {
+    warnings.push('无 flow 态（archive 件或无 flow-state.yaml）')
+  }
+
+  // ② agent 会话日志（change_key 精确相等——登记面唯一键）
+  const registryPath = join(runtimeRoot, 'agent-session-log.json')
+  const registry = readJsonSafe(registryPath)
+  let agentLogs = []
+  if (registry && Array.isArray(registry.entries)) {
+    agentLogs = registry.entries.filter((e) => e && typeof e === 'object' && e.change_key === changeName)
+  } else {
+    warnings.push(`会话日志登记缺失或不可解析（${registryPath}）——本机未跑过 run 命令或登记面损坏`)
+  }
+
+  // ③ 摩擦账本（readFrictionLedger 容错：缺文件/坏 JSON → []）
+  const friction = readFrictionLedger(runtimeRoot).filter((e) => e.change === changeName)
+
+  // ④ verify-runs（mtime 近序，同 mtime 路径字典序破平；截断前 N）
+  //    fail-soft：runsRoot 为普通文件/权限损坏形态时 readdirSync 抛 ENOTDIR——捕获降级，不阻断取证。
+  const runsRoot = join(runtimeRoot, 'verify-runs')
+  const verifyRuns = []
+  if (existsSync(runsRoot)) {
+    let runEntries = []
+    try {
+      runEntries = readdirSync(runsRoot, { withFileTypes: true })
+    } catch {
+      warnings.push(`verify-runs 不可读（非目录或损坏形态，${runsRoot}）——降级为空`)
+    }
+    const dirs = runEntries
+      .filter((d) => d.isDirectory())
+      .map((d) => join(runsRoot, d.name))
+    const withTime = dirs
+      .map((dir) => {
+        try {
+          return { dir, mtimeMs: statSync(dir).mtimeMs }
+        } catch {
+          return null
+        }
+      })
+      .filter(Boolean)
+      .sort((a, b) => (b.mtimeMs - a.mtimeMs) || (a.dir < b.dir ? -1 : a.dir > b.dir ? 1 : 0))
+    for (const { dir, mtimeMs } of withTime.slice(0, Math.max(1, verifyRunsLimit))) {
+      const resultPath = join(dir, 'test-result.json')
+      verifyRuns.push({
+        dir,
+        resultPath: existsSync(resultPath) ? resultPath : null,
+        mtimeIso: new Date(mtimeMs).toISOString(),
+      })
+    }
+  } else {
+    warnings.push(`无 verify-runs 目录（${runsRoot}）——本变更未跑过收口实测或 runtime 已清理`)
+  }
+
+  // ⑤ 评审轮次（review.json + superseded-*，mtime 近序；目录损坏形态同上降级）
+  const reviews = []
+  if (identity.changeDir && existsSync(identity.changeDir)) {
+    let reviewFiles = []
+    try {
+      reviewFiles = readdirSync(identity.changeDir).filter((f) => /^review\.json(\.superseded-.+)?$/.test(f))
+    } catch {
+      warnings.push(`变更目录不可读（${identity.changeDir}）——评审轮次面降级为空`)
+    }
+    for (const f of reviewFiles) {
+      const p = join(identity.changeDir, f)
+      let mtimeIso = null
+      try {
+        mtimeIso = new Date(statSync(p).mtimeMs).toISOString()
+      } catch { /* 文件刚被删——列名不留 mtime */ }
+      reviews.push({ file: p, superseded: f !== 'review.json', mtimeIso })
+    }
+    reviews.sort((a, b) => (b.mtimeIso || '').localeCompare(a.mtimeIso || ''))
+  } else {
+    warnings.push('变更目录不存在——评审轮次面为空')
+  }
+
+  return { identity, agentLogs, friction, verifyRuns, reviews, warnings }
+}
+
+/**
+ * 渲染取证任务书（markdown）。六维度是结构骨架不是封闭清单；四纪律钉死
+ * diagnosing-superpowers 的核心铁律（path:line 锚、唯一可写产物、先读本体、时间盒）。
+ * @param {{ identity: object, agentLogs: object[], friction: object[], verifyRuns: object[], reviews: object[], warnings: string[] }} pack
+ * @returns {string}
+ */
+export function renderForensicsTaskbook(pack) {
+  const { identity, agentLogs, friction, verifyRuns, reviews, warnings } = pack
+  const lines = []
+  lines.push(`# 会话取证任务书 — ${identity.changeName}`)
+  lines.push('')
+  lines.push(`【角色】你是取证分析员（干净上下文）——还原这个会话里实际发生了什么，拿证据说话，不替流程辩护也不替人辩护。报告读者是「要决定下一步怎么办的人」。`)
+  lines.push('')
+  lines.push('## 证据包（CLI 装配的机械事实——先读这些文件本体，再下结论）')
+  lines.push('')
+  lines.push(`- 变更身份：status=${identity.status}｜tier=${identity.tier ?? '无'}｜目录=${identity.changeDir ?? '（不存在）'}`)
+  lines.push(`- agent 会话日志（${agentLogs.length} 条，change_key=${identity.changeName} 精确过滤）：`)
+  for (const e of agentLogs) {
+    lines.push(`  - [${e.harness}/${e.format ?? '?'}] ${e.log_path}（session=${e.session_id ?? '?'}${e.exists === false ? '，⚠️ 文件不在场' : ''}）`)
+  }
+  if (agentLogs.length === 0) lines.push('  - （零命中——本机未登记过本变更的会话日志）')
+  lines.push(`- 摩擦账本（${friction.length} 条）：${friction.map((e) => JSON.stringify(e.counts ?? {})).join(' / ') || '（无）'}`)
+  lines.push(`- verify-runs（近 ${verifyRuns.length} 次）：`)
+  for (const r of verifyRuns) lines.push(`  - ${r.resultPath ?? r.dir + '（无 test-result.json）'} @ ${r.mtimeIso}`)
+  lines.push(`- 评审轮次（${reviews.length} 份，含 superseded）：`)
+  for (const r of reviews) lines.push(`  - ${r.file}${r.superseded ? '（superseded——前轮评审结论，对比两轮可还原修复轨迹）' : ''}`)
+  if (warnings.length) {
+    lines.push(`- 降级注记：${warnings.join('；')}`)
+  }
+  lines.push('')
+  lines.push('## 分析维度（结构骨架——常见失事面，不是封闭清单：证据指向维度外时照报，报告允许增设章节）')
+  lines.push('')
+  lines.push('1. **时间线重建**：这个会话按时间实际做了什么（步骤推进/等待/回滚/中断点）。')
+  lines.push('2. **计划遵从**：做的是计划内的事吗？偏离处有没有留痕（决策/账本/提交消息）？')
+  lines.push('3. **重复工作**：有没有同一件事做两遍（重派/重审/重跑）？根因是什么？')
+  lines.push('4. **停等与重试**：哪里停等了用户/子代理？重试了几次？是否有可避免的空转？')
+  lines.push('5. **成本与轮次**：轮次/token 花在哪了（读文件长尾？全量重验？）？')
+  lines.push('6. **门禁摩擦**：gate 回滚/评审打回/实测失败的完整链条与最终清偿方式。')
+  lines.push('')
+  lines.push('## 取证纪律')
+  lines.push('')
+  lines.push('1. **每条 finding 必须带 `path:line` 锚，无锚不成立**——锚指向证据包列出的文件或其内容（行号取自你实际读到的文件）。')
+  lines.push('2. **唯一可写产物是 `diagnosis-report.md`**（写在变更目录）——禁止修改任何其他文件、禁止 git 操作。固定章节：`## 问题陈述` / `## 时间线` / `## Findings`（分维度）/ `## 无法证实面`（证据不足的疑点如实列，不脑补）。')
+  lines.push('3. **先读证据包列出的文件本体再下结论，禁止全量扫读仓**——矛盾经常藏在交叉处，定向读那一处。')
+  lines.push('4. **时间盒收敛**：结论存疑时定向补证；连续扩面仍零结论 = 基于已读材料收敛，把疑点写进「无法证实面」。')
+  lines.push('')
+  lines.push('【无子代理通道时】主会话按本任务书自行分析即可，如实标注执行方式；有子代理通道时按维度分派并行分析、汇总时逐条核对锚点。')
+  lines.push('')
+  return lines.join('\n')
+}
+
+/**
+ * 命令入口：sillyspec diagnose --change <名> [--detect] [--json]
+ * 只读零写入；--detect 先透传 agent-session-log 现场探测（不落盘语义随既有 cmdAgentLog）。
+ * @param {string[]} args - filteredArgs.slice(1)（'diagnose' 之后）
+ * @param {{ json?: boolean, cwd?: string, specDir?: string|null }} opts
+ */
+export async function cmdForensics(args, { json = false, cwd = process.cwd(), specDir = null } = {}) {
+  const changeIdx = args.indexOf('--change')
+  const changeName = changeIdx >= 0 && args[changeIdx + 1] && !String(args[changeIdx + 1]).startsWith('--') ? args[changeIdx + 1] : null
+  if (!changeName) {
+    console.error('用法: sillyspec diagnose --change <名> [--detect] [--json] [--spec-dir <路径>]')
+    console.error('  只读装配会话取证证据包 + 取证任务书（path:line 铁律；唯一可写产物是变更目录的 diagnosis-report.md，由执行任务书的 agent 产出）')
+    process.exit(2)
+  }
+  const specBase = specDir || join(cwd, '.sillyspec')
+  const runtimeRoot = join(specBase, '.runtime')
+
+  if (args.includes('--detect')) {
+    const { cmdAgentLog } = await import('./agent-session-log.js')
+    await cmdAgentLog(['--detect'], { json: false, cwd, specDir })
+  }
+
+  const pack = assembleForensicsPack({ specBase, runtimeRoot, changeName })
+  const taskbook = renderForensicsTaskbook(pack)
+
+  if (json || args.includes('--json')) {
+    console.log(JSON.stringify({ ...pack, taskbook }))
+    return
+  }
+  console.log(taskbook.trimEnd())
+}

package/src/fr-index.js

@@ -18,6 +18,7 @@
  */
 
 import { readChangeTrace, upsertFrBindings, applySupersededToEntryLines, testAnchorFile, resolveTestFileRel } from './test-bindings.js'
+import { modulePathMatches } from './modules.js'
 import { suggestDomainFromFiles, snapDomainToDictionary } from './knowledge-digest.js'
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'fs';
 import { basename, dirname, join } from 'path';
@@ -250,7 +251,7 @@ export function matchedModuleIds(moduleIndex, filePath) {
   const hits = [];
   for (const [modId, mod] of Object.entries(moduleIndex)) {
     const paths = (mod && Array.isArray(mod.paths)) ? mod.paths : [];
-    if (paths.some((pp) => filePath === pp || filePath.startsWith(pp.endsWith('/') ? pp : pp + '/'))) {
+    if (paths.some((pp) => modulePathMatches(filePath, pp))) {
       hits.push(modId);
     }
   }

package/src/index.js

@@ -100,6 +100,8 @@ SillySpec CLI — 规范驱动开发工具包
                                       变更合成时间线（事件流 × tasks.md × git 提交锚三源真实留痕渲染；活跃/归档变更均可）
   sillyspec dispatch <probe | hint>       SillyHub 派发能力探测 + 策略生成（agent 调用桥，仅渲染不执行 tool）
   sillyspec agent-log [--detect] [--json]  本地 agent 会话日志查询/现场探测（run 命令自动上报平台 POST /api/agent-logs 并本地留底）
+  sillyspec diagnose --change <名> [--detect] [--json]
+                                      会话取证：只读装配证据包（flow 态/会话日志/摩擦账本/verify-runs/评审轮次）+ 取证任务书（path:line 铁律；报告由执行任务书的 agent 产出）
 
   sillyspec workflow check <name> [--project <p>] [--change <c>] [--json] [--save]
                                       全局 workflow 校验（--save 归档到 .sillyspec/.runtime/workflow-runs/）
@@ -3390,11 +3392,34 @@ ${generated.length} 个骨架已就绪——逐节把 <!--TODO--> 替换为语
         // --by-change（坑 fr-domain-suggest-typo-and-no-split-migration 缺陷2）：unmapped 等
         // 混合池按「变更：<名>」字段分批迁移——整域迁移会错置大部分条目，来源变更才是分批键。
         const byChangeD = flag('--by-change')
-        if (!fromD || !toD) { fail('用法: sillyspec tests --redomain --from <源域> --to <目标域> [--anchor <FR-id>] [--by-change <变更名>] [--write]\n  域名可带 fr/ 前缀与 .md 后缀（fr/auto-backend ≍ auto-backend.md ≍ auto-backend）'); break }
+        if (!fromD || !toD) { fail('用法: sillyspec tests --redomain --from <源域> --to <目标域> [--anchor <FR-id>] [--by-change <变更名>] [--decisions] [--write]\n  --decisions 切 decisions/ 面（默认 fr/ 面）；域名可带前缀与 .md 后缀（fr/auto-backend ≍ auto-backend.md ≍ auto-backend）'); break }
         // 多 --anchor 收集
         const anchorList = []
         for (let i = 0; i < filteredArgs.length - 1; i++) if (filteredArgs[i] === '--anchor') anchorList.push(filteredArgs[i + 1])
+        // --decisions（2026-10-15-decision-redomain）：切 decisions/ 面的孪生迁移实现——
+        // 同 flag 族（--from/--to/--anchor/--by-change/--write），段字节整体搬运、迁域不换号、
+        // 跨变更同号不冲突（双键防）；平台仓 unmapped 442 条存量清偿的机器通道。
+        const useDecisions = has('--decisions')
         try {
+          if (useDecisions) {
+            const { planDecisionRedomain, redomainDecisionEntries } = await import('./decision-redomain.js')
+            if (!has('--write')) {
+              const plan = planDecisionRedomain({ knowledgeRoot, from: fromD, to: toD, anchors: anchorList.length ? anchorList : null, byChange: byChangeD || null })
+              console.log(`🔧 决策域迁移预览（--write 落盘）：decisions/${fromD}.md → decisions/${toD}.md，${plan.entries.length} 条${byChangeD ? `（仅「变更：${byChangeD}」）` : ''}`)
+              for (const e of plan.entries.slice(0, 10)) console.log(`   ${e.id} ${e.title}`)
+              if (plan.entries.length > 10) console.log(`   … 共 ${plan.entries.length} 条`)
+              console.log(`   目标域文件${plan.targetExists ? '在场' : '将新建'}；源域${plan.sourceWillDelete ? '将删空壳' : '保留余条'}；ID 不变（身份保持）`)
+              break
+            }
+            const r = redomainDecisionEntries({ knowledgeRoot, from: fromD, to: toD, anchors: anchorList.length ? anchorList : null, byChange: byChangeD || null })
+            console.log(`✅ 决策域迁移完成：${r.moved.length} 条 decisions/${fromD}.md → decisions/${toD}.md（ID 不变${byChangeD ? `，仅「变更：${byChangeD}」` : ''}）`)
+            for (const m of r.moved.slice(0, 10)) console.log(`   ${m.id} ${m.title}`)
+            if (r.skippedConflicts.length > 0) console.log(`   ⚠️ 目标域同 id 同变更段冲突跳过 ${r.skippedConflicts.length} 条（${r.skippedConflicts.slice(0, 5).join('、')}）`)
+            if (r.sourceDeleted) console.log(`   源域空壳已删：decisions/${fromD}.md`)
+            if (r.targetCreated) console.log(`   目标域文件新建：decisions/${toD}.md`)
+            if (r.indexLineAdded) console.log(`   INDEX 路由行已补：${toD}`)
+            break
+          }
           if (!has('--write')) {
             // 预览与落盘同口径透传 byChange（坑 redomain-plan-preview-by-change-ignored，
             // 2026-10-02 实证：76338b4d 收编在途工作时此行漏透传——预览列整域、落盘只迁
@@ -4107,6 +4132,14 @@ SillySpec worktree — git worktree 隔离管理
       await cmdAgentLog(filteredArgs.slice(1), { json, cwd: dir, specDir });
       break;
     }
+    case 'diagnose': {
+      // 会话取证（2026-10-15-session-forensics）：只读装配证据包六面（flow 态/会话日志/摩擦账本/
+      // verify-runs/评审轮次/任务书）+ 取证任务书（path:line 铁律，唯一可写产物 diagnosis-report.md
+      // 由执行任务书的 agent 产出）。零状态写入，不进 run 状态机——诊断是随时可调用的查询动作。
+      const { cmdForensics } = await import('./forensics.js');
+      await cmdForensics(filteredArgs.slice(1), { json, cwd: dir, specDir });
+      break;
+    }
     case 'patch-reanchor': {
       // 收口留痕锚点回写（2026-10-12-close-trace-freeze-integrity FR-03）：worktree 内收口的
       // change-patch.json 记 worktree 本地 SHA，apply 重放回主仓后悬空——按提交主题归属推导

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 的代码化） ──
 
@@ -273,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
         }

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);
+}
 
 
 /**

package/src/run/gates.js

@@ -224,7 +224,7 @@ export function warnMissingUiPrototype(stageName, changeName, currentStepName, s
   const design = readFileSync(designPath, 'utf8')
   const feExts = [...new Set((design.match(/\.(vue|svelte|astro|tsx|jsx|css|scss|sass|less|styl|html)\b/gi) || []).map(s => s.replace('.', '').toLowerCase()))]
   if (feExts.length === 0) return
-  console.warn(`   ⚠️ design.md 命中前端文件类型（${feExts.join('/')}）但变更目录无 prototype-*.html——轻微样式改动可忽略；布局/交互流程级变化应补原型（sillyspec run brainstorm --reopen 回到「分段展示设计」，或直接让 agent 补生成；已有可复跑 HTML 原型则登记复用：复制进变更目录并命名 prototype-<名称>.html，execute 按此命名注入）`)
+  console.warn(`   ⚠️ design.md 命中前端文件类型（${feExts.join('/')}）但变更目录无 prototype-*.html——轻微样式改动可忽略；布局/交互流程级变化应补原型（sillyspec run brainstorm --reopen 回到「分段展示设计」，或直接让 agent 补生成；已有可复跑 HTML 原型则登记复用：复制进变更目录并命名 prototype-<名称>.html，execute 按此命名注入；本仓形态未在 local.yaml ui_prototype 登记的，收口前补登记——form: real-code 或 single-html+豁免 ruling）`)
 }
 
 /**
@@ -1397,18 +1397,11 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       //    快照含基线债文件时恒败，agent 被逼范围外清偿或逃生口）。失败输出提及文件 × 本变更
       //    文件集零交集 → 存量债 advisory 降档放行（债非本变更引入，硬拦只是制造范围外功）；
       //    有交集 / 输出无可识别路径（unattributable，纯配置错误类）→ 维持硬拦（保守）。──
-      let lintOwnership = null
-      try {
-        const { triageLintOwnership, resolveVerifyChangedFiles } = await import('../verify-postcheck.js')
-        const lintScopeFiles = (resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase }) || [])
-          .map(f => String(f).replace(/\\/g, '/')).filter(f => !f.startsWith('.sillyspec/'))
-        lintOwnership = triageLintOwnership({ failureFiles: lintCheck.failureFiles || [], changeFiles: lintScopeFiles })
-      } catch { /* 鉴定链异常维持硬拦（保守） */ }
-      if (lintOwnership && lintOwnership.verdict === 'pre-existing') {
-        console.warn('\n⚠️ Verify lint 实测失败，但归属鉴定为 HEAD 存量债（失败提及文件与本变更文件集零交集）——降档 advisory 不阻断 verify 完成：')
-        console.warn(`   存量债文件：${(lintCheck.failureFiles || []).join('、') || '（见上方输出）'}`)
-        console.warn('   处置建议：单独 quick 机械清偿（顺手清债解锁全仓 lint 门），或本变更确认无关时设 SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕）。债随基线存在，与本变更交付无关。')
-      } else {
+      // 2026-10-15-lint-triage-path-unify：判定与文案收敛到 ./lint-ownership.js（与 noAI 质量
+      // 扫描路径同源——原两路径分叉见消费仓坑档案 verify-lint-triage-path-divergence.md）。
+      const { lintOwnershipDowngrade } = await import('./lint-ownership.js')
+      const lintAdvisoryDowngraded = await lintOwnershipDowngrade({ lintCheck, cwd, changeName, specBase })
+      if (!lintAdvisoryDowngraded) {
       console.error('\n❌ verify 阶段被阻断：CLI 亲自实测 lint 失败（agent 的 lint 自报告与实测不符时以实测为准）。')
       if (usedSnapInfo) {
         try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
@@ -1432,7 +1425,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       }
       console.error('   修复后重跑 --done（进度不丢）；确认要跳过实测请设 SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕）。')
       return await rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx, cwd, changeName, platformOpts, { type: 'gate_rollback', detail: 'verify-lint' })
-      } // else（pre-existing 降档分支）结束——维持硬拦分支的 rollback 语义不变
+      } // 硬拦分支结束（降档放行时直接落到后续 parity/删除探针——rollback 语义不变）
     }
     // 契约 parity 对账：扫前端 API 调用 vs execute 提取的 provider endpoint artifact。
     // 接线自 contract-matrix pipeline（verifyApiParity 的 CLI 入口）。

package/src/run/lint-ownership.js

@@ -0,0 +1,37 @@
+/**
+ * lint 归属鉴定降档（共享 helper）——2026-10-15-lint-triage-path-unify。
+ *
+ * 背景（消费仓坑档案 docs/sillyspec/verify-lint-triage-path-divergence.md，2026-10-15
+ * -dsh-engine-acp verify 实证）：降档判定原先只实现在 gates.js 的 verify --done 拦截面；
+ * verify step6「noAI 质量扫描」（verify-quality-scan.js）只做 shouldBlockVerifyLint 二值
+ * 判定直接 throw——同一失败两路径行为分叉（step6 throw / --done 降档）。本模块把判定与
+ * 提示文案收敛为单一来源，两路径同接线。
+ *
+ * 语义（R4-S-F 实证口径，与 gates.js 原内联实现等价）：
+ * - pre-existing（失败提及文件 × 本变更文件集零交集）→ 打印降档 warning，返回 true（放行）；
+ * - owned（有交集）/ unattributable（输出无可识别路径）/ 鉴定链异常 → 返回 false
+ *   （维持硬拦，保守——无法排除本变更责任时宁可拦不可漏）。
+ *
+ * @param {{lintCheck?: {failureFiles?: string[]}, cwd: string, changeName: string, specBase: string, importer?: () => Promise<any>}} input
+ *   importer 可注入（测试用）；缺省动态加载 ../verify-postcheck.js（triageLintOwnership +
+ *   resolveVerifyChangedFiles——运行时 import 避免模块加载环）。
+ * @returns {Promise<boolean>} true=降档放行（advisory），false=维持硬拦。
+ */
+export async function lintOwnershipDowngrade({ lintCheck, cwd, changeName, specBase, importer }) {
+  const load = importer || (async () => import('../verify-postcheck.js'))
+  let lintOwnership = null
+  try {
+    const { triageLintOwnership, resolveVerifyChangedFiles } = await load()
+    const lintScopeFiles = (resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase }) || [])
+      .map((f) => String(f).replace(/\\/g, '/')).filter((f) => !f.startsWith('.sillyspec/'))
+    lintOwnership = triageLintOwnership({ failureFiles: (lintCheck && lintCheck.failureFiles) || [], changeFiles: lintScopeFiles })
+  } catch { /* 鉴定链异常维持硬拦（保守） */ }
+  if (lintOwnership && lintOwnership.verdict === 'pre-existing') {
+    const failureFiles = (lintCheck && lintCheck.failureFiles) || []
+    console.warn('\n⚠️ Verify lint 实测失败，但归属鉴定为 HEAD 存量债（失败提及文件与本变更文件集零交集）——降档 advisory 不阻断 verify 推进：')
+    console.warn(`   存量债文件：${failureFiles.join('、') || '（见上方输出）'}`)
+    console.warn('   处置建议：单独清偿（顺手清债解锁全仓 lint 门），或本变更确认无关时设 SILLYSPEC_VERIFY_LINT_GATE=advisory（审计留痕）。债随基线存在，与本变更交付无关。')
+    return true
+  }
+  return false
+}