sillyspec 3.28.9 → 3.28.10

package/package.json

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

package/src/change-list.js

@@ -168,6 +168,37 @@ function looksLikePath(p) {
  */
 const INCIDENTAL_RE = /顺带修复|附带修复|顺带|drive-?by|incidental/i
 
+/**
+ * 从清单子段标题 / 路径前缀解析跨仓 repoKey（scope-audit-cross-repo-blindness 改进点 2，
+ * 2026-09-15）：多仓变更 design 清单按「main 仓 / sub-xxx / spdemo」分段书写，主仓跑
+ * scope-audit 时这些条目不是主仓路径，须识别出来标注「跨仓（本表不含）」而非恒「计划未动」。
+ *
+ * 两种书写形态：
+ *   ① 子段标题含注册 repoKey（`### sub-grid-security`、`### sub-grid-security 新增文件`、
+ *      `### spdemo 仓`）——标题 token 化后含 key，或以 key 开头且带「仓/仓库」后缀；
+ *   ② 路径 cell 显式前缀 `cross-repo:<repo-key>:`（_module-map.yaml 同款约定）。
+ * 只认调用方传入的注册表 repoKeys（local.yaml repos 段）——未注册的 key 不剥前缀不标仓，
+ * fail-closed 防把普通路径误判跨仓。repoKeys 缺省 null → 全部按主仓解析（零回归）。
+ */
+function detectRepoFromSubsection(title, repoKeys) {
+  if (!Array.isArray(repoKeys) || repoKeys.length === 0) return null
+  const tokens = String(title || '').split(/[\s（）()：:，,、/\\]+/)
+  for (const k of repoKeys) {
+    if (tokens.includes(k)) return k
+    if (new RegExp(`^${k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\s*仓|\\s*仓库)$`).test(String(title || '').trim())) return k
+  }
+  return null
+}
+
+/** `cross-repo:<key>:` 前缀拆分（key 须在注册表内）；无前缀/未注册 → null */
+function splitCrossRepoPrefix(rawPath, repoKeys) {
+  if (!Array.isArray(repoKeys) || repoKeys.length === 0) return null
+  const m = String(rawPath || '').match(/^cross-repo:([A-Za-z0-9_.\-]+):(.*)$/)
+  if (!m) return null
+  if (!repoKeys.includes(m[1])) return null
+  return { repo: m[1], path: m[2].trim() }
+}
+
 /**
  * 从 design.md 解析文件变更清单（含 incidental 标记）。兼容两种真实写法：
  *   ① 表格：`| 操作 | 文件路径 | 说明 |`（brainstorm 模板默认）
@@ -175,13 +206,15 @@ const INCIDENTAL_RE = /顺带修复|附带修复|顺带|drive-?by|incidental/i
  * 表头列顺序自适应（定位「文件/路径/file/path」列，列顺序写反时不会把操作名当路径）；
  * 忽略 `.sillyspec/`（keepSillyspecDocs=true 时保留 `.sillyspec/docs/`）与占位符（`—`/`-`/`N/A`/`无`）；「不修改/暂缓」子段下的路径会被排除；
  * CRLF 容错。incidental 嗅探：表格非路径列（说明列）+ 路径 cell 原始值（剥注释前的括号内容）+ 列表项原文。
+ * repoKeys 传入时识别跨仓子段 / `cross-repo:` 前缀（detectRepoFromSubsection），命中的条目
+ * repo 字段携带 repoKey（默认 null = 主仓）——scope-audit 计划侧跨仓标注的数据源。
  *
  * 内核函数：parseFileChangeList（Set 包装，向后兼容）与 parseFileChangeListDetailed 共用，
  * 单一真相源，避免两处各自重写清单解析漂移。
  * @param {string} designMdPath - design.md 文件路径
- * @returns {Array<{ path: string, operation: string|null, incidental: boolean }>}（顺序按首次出现，exclude 子段移除）
+ * @returns {Array<{ path: string, operation: string|null, incidental: boolean, repo: string|null }>}（顺序按首次出现，exclude 子段移除）
  */
-function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false } = {}) {
+function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false, repoKeys = null } = {}) {
   if (!designMdPath || !existsSync(designMdPath)) return []
 
   const content = readFileSync(designMdPath, 'utf8').replace(/\r\n/g, '\n')
@@ -202,10 +235,11 @@ function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false } = {}
   let opColIdx = -1             // 操作列下标（表头扫描后定位；-1 = 无操作列 → operation=null）
   let listMode = 'include'      // include | exclude（分类列表子段）
   let currentOp = null          // 分类列表子标题推导的 operation（表格模式不用）
-  const entries = new Map()     // path -> { path, operation, incidental }（exclude 子段 delete）
+  let currentRepo = null        // 分类列表子标题推导的跨仓 repoKey（detectRepoFromSubsection）
+  const entries = new Map()     // path -> { path, operation, incidental, repo }（exclude 子段 delete）
 
   for (const line of lines) {
-    // 分类列表子标题：### 新增文件 / ### 修改文件 / ### 不修改文件
+    // 分类列表子标题：### 新增文件 / ### 修改文件 / ### 不修改文件 / ### sub-grid-security（跨仓段）
     const subHeader = line.match(/^###\s+(.+?)\s*$/)
     if (subHeader) {
       // ⚠️ EXCLUDE 优先：「### 不修改文件」含「修改」二字，会被 classifySubsectionOp 误匹配。
@@ -213,9 +247,13 @@ function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false } = {}
       if (EXCLUDE_SUBSECTION_RE.test(subHeader[1])) {
         listMode = 'exclude'
         currentOp = null
+        currentRepo = null
       } else {
         listMode = 'include'
         currentOp = classifySubsectionOp(subHeader[1])
+        // 跨仓段识别（scope-audit-cross-repo-blindness 改进点 2）：子段标题含注册 repoKey
+        // 或以「<key> 仓/仓库」收尾 → 其下条目标 repo；不含 key 的普通操作子段 → 回主仓。
+        currentRepo = detectRepoFromSubsection(subHeader[1], repoKeys)
       }
       continue
     }
@@ -237,7 +275,12 @@ function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false } = {}
         continue
       }
 
-      const filePath = normalizePath(cells[pathColIdx] || '')
+      const filePathRaw = normalizePath(cells[pathColIdx] || '')
+      // 跨仓显式前缀（scope-audit-cross-repo-blindness 改进点 2）：`cross-repo:<key>:` 剥前缀
+      // 标 repo；无前缀/未注册 key → 按当前子段 repo（缺省主仓 null）
+      const crossRepo = splitCrossRepoPrefix(filePathRaw, repoKeys)
+      const filePath = crossRepo ? crossRepo.path : filePathRaw
+      const entryRepo = crossRepo ? crossRepo.repo : currentRepo
       // 列定位兜底：取到纯操作词（表头未命中且列顺序异常）→ 跳过，避免把「修改」当路径
       if (/^(新增|修改|删除|重命名|new|modify|update|delete|create|rename)$/i.test(filePath)) continue
       if (isPlaceholder(filePath) || (filePath.startsWith('.sillyspec/') && !(keepSillyspecDocs && filePath.startsWith('.sillyspec/docs/')))) continue
@@ -252,29 +295,37 @@ function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false } = {}
       // 校验器）。拆分符：+ / ／ / | / 、 / ; / ；——每个 token 独立过校验入表；单路径零变化。
       const pathTokens = splitCombinedPaths(filePath)
       if (listMode === 'exclude') { for (const t of pathTokens) entries.delete(t); continue }
-      for (const t of pathTokens) entries.set(t, { path: t, operation, incidental })
+      for (const t of pathTokens) entries.set(t, { path: t, operation, incidental, repo: entryRepo })
       continue
     }
 
     // 分类列表项：`- path` / `- \`path\``
     const listItem = line.match(/^\s*-\s+(.+)/)
     if (listItem) {
-      // 坑 brainstorm-gate-agent-unavailable-and-list-path-parse 坑2：列表项「路径：描述」
-      // 整行当路径 existsSync 假阴性（文件存在却报幻觉路径）——剥首个中/英冒号及之后描述。
-      // 仅列表分支剥、且冒号前段须 looksLikePath：normalizePath 全局剥会毁 Windows 绝对路径
-      // （C:\...），列表项是仓根相对路径无盘符，安全。
+      // 跨仓显式前缀（改进点 2，同表格分支口径）须先于「路径：描述」剥离判——
+      // `cross-repo:<key>:<path>` 的首个冒号在 key 段内，先剥描述会把整条砍成 `cross-repo`。
+      const preCross = splitCrossRepoPrefix(normalizePath(listItem[1]), repoKeys)
       let rawItem = listItem[1]
-      const colonIdx = rawItem.search(/[：:]/)
-      if (colonIdx > 0) {
-        const head = rawItem.slice(0, colonIdx).trim()
-        if (looksLikePath(head)) rawItem = head
+      if (!preCross) {
+        // 坑 brainstorm-gate-agent-unavailable-and-list-path-parse 坑2：列表项「路径：描述」
+        // 整行当路径 existsSync 假阴性（文件存在却报幻觉路径）——剥首个中/英冒号及之后描述。
+        // 仅列表分支剥、且冒号前段须 looksLikePath：normalizePath 全局剥会毁 Windows 绝对路径
+        // （C:\...），列表项是仓根相对路径无盘符，安全。
+        const colonIdx = rawItem.search(/[：:]/)
+        if (colonIdx > 0) {
+          const head = rawItem.slice(0, colonIdx).trim()
+          if (looksLikePath(head)) rawItem = head
+        }
       }
-      const filePath = normalizePath(rawItem)
+      const itemNorm = normalizePath(rawItem)
+      const itemCross = preCross || splitCrossRepoPrefix(itemNorm, repoKeys)
+      const filePath = itemCross ? itemCross.path : itemNorm
+      const itemRepo = itemCross ? itemCross.repo : currentRepo
       if (isPlaceholder(filePath) || (filePath.startsWith('.sillyspec/') && !(keepSillyspecDocs && filePath.startsWith('.sillyspec/docs/')))) continue
       if (!looksLikePath(filePath)) continue // 脏描述兜底
       const incidental = INCIDENTAL_RE.test(listItem[1])
       if (listMode === 'exclude') { entries.delete(filePath); continue }
-      entries.set(filePath, { path: filePath, operation: currentOp, incidental })
+      entries.set(filePath, { path: filePath, operation: currentOp, incidental, repo: itemRepo })
     }
   }
 
@@ -285,8 +336,8 @@ function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false } = {}
  * 从 design.md 解析文件变更清单（路径集合，向后兼容）。
  * @param {string} designMdPath - design.md 文件路径
  * @param {string} designMdPath - design.md 文件路径
- * @param {{ keepSillyspecDocs?: boolean }} [opts] - keepSillyspecDocs=true 时保留 `.sillyspec/docs/`（dogfood 模块文档=交付物，apply gate 需识别；默认 false 跳过全部 .sillyspec/ 保持 fileCount 判档不变）
- * @returns {Set<string>} 文件路径集合（相对路径，如 "src/worktree.js"）
+ * @param {{ keepSillyspecDocs?: boolean, repoKeys?: string[]|null }} [opts] - keepSillyspecDocs=true 时保留 `.sillyspec/docs/`（dogfood 模块文档=交付物，apply gate 需识别；默认 false 跳过全部 .sillyspec/ 保持 fileCount 判档不变）；repoKeys=注册仓 key 清单（local.yaml repos 段）时识别跨仓子段 / `cross-repo:` 前缀
+ * @returns {Set<string>} 文件路径集合（相对路径，如 "src/worktree.js"；跨仓前缀已剥）
  */
 export function parseFileChangeList(designMdPath, opts) {
   return new Set(_parseFileListDetailed(designMdPath, opts).map(e => e.path))
@@ -296,9 +347,11 @@ export function parseFileChangeList(designMdPath, opts) {
  * 从 design.md 解析文件变更清单（含 operation + incidental 标记）。
  * operation 供 verify 删除探针对账（声明「新增/修改」却整文件删除 = 高风险）；
  * incidental 供 assess allowed_paths 豁免。
+ * repo（跨仓标注，scope-audit-cross-repo-blindness 改进点 2）：命中注册跨仓子段标题或
+ * `cross-repo:<key>:` 前缀的条目标 repoKey，否则 null（= 主仓）。
  * @param {string} designMdPath - design.md 文件路径
- * @param {{ keepSillyspecDocs?: boolean }} [opts] - 同 parseFileChangeList
- * @returns {Array<{ path: string, operation: string|null, incidental: boolean }>}
+ * @param {{ keepSillyspecDocs?: boolean, repoKeys?: string[]|null }} [opts] - 同 parseFileChangeList
+ * @returns {Array<{ path: string, operation: string|null, incidental: boolean, repo: string|null }>}
  */
 export function parseFileChangeListDetailed(designMdPath, opts) {
   return _parseFileListDetailed(designMdPath, opts)

package/src/config-schema.js

@@ -128,6 +128,14 @@ export const LOCAL_YAML_SCHEMA = {
         { path: 'known_failures', type: 'array', optional: true, status: 'live', readers: ['extractKnownFailures (src/verify-postcheck.js)'], desc: '失败行模式列表（匹配测试输出失败行）。', example: 'tests/some-old-test' },
       ],
     },
+    {
+      id: 'verify_precedents',
+      title: '等效验证先例库',
+      note: '标准测试/构建命令在本仓不可用（框架硬编码 skip、依赖外部基础设施等）时，登记已验证的等效验证口径，verify prompt 自动注入提示复用（2026-09-15 EHS 实证：mvn test 被框架 parent pom 硬编码 surefire skip，等效口径第二次靠 agent 翻旧 verify-result 正文续命——先例只活在散文里换 agent 即断档）。',
+      keys: [
+        { path: 'verify_precedents', type: 'array', optional: true, status: 'live', readers: ['parseVerifyPrecedents (src/run/prompt.js)'], desc: '等效验证先例对象数组（id/standard_command/reason/equivalent/established_by/notes）。verify 阶段 prompt 与 test_strategy 预检提示同挂点注入；行动指引=把等效命令配进 commands.test 照常全量实测对账，而非只靠 test_strategy: skip 放行。', example: '- id: mvn-test-surefire-skip\n  standard_command: mvn test\n  reason: parent pom 硬编码 surefire skip=true\n  equivalent: dependency:build-classpath + javac + JUnitCore 直跑\n  established_by: 2026-08-26-building-area-ledger' },
+      ],
+    },
     {
       id: 'worktree-hook',
       title: 'worktree-guard 扩展',
@@ -136,6 +144,14 @@ export const LOCAL_YAML_SCHEMA = {
         { path: 'worktree-hook.readonlyCommands', type: 'array', optional: true, status: 'live', readers: ['loadLocalConfig (src/hooks/worktree-guard.js)'], desc: '额外放行的只读命令名列表（如 rg/fd），绕过 worktree-guard 写操作拦截。', example: 'rg' },
       ],
     },
+    {
+      id: 'worktree',
+      title: 'worktree 生成物供给',
+      note: 'gitignore 生成物（如构建期产出的 src/build-id.ts）不在 git 树也不进 untracked overlay（ls-files --others --exclude-standard 尊重 .gitignore），worktree 缺失致构建炸 Failed to load url——create 期按本清单从主仓复制供给（2026-09-15-worktree-dual-truth-gates 坑③，D-003@v1）。块列表或 inline flow 数组均可解析。',
+      keys: [
+        { path: 'worktree.supplyFiles', type: 'array', optional: true, status: 'live', readers: ['readSupplyFilesConfig + _supplyGeneratedFiles (src/worktree.js — create step 5.9 供给步)'], desc: '随 worktree create 从主仓复制的生成物清单：精确路径或 glob（* 单层 / ** 多层），相对仓根。展开上限 200 文件超出截断警告；实供清单记 meta.supplyFiles；缺省 [] = 供给步空转零行为变化。', example: 'src/build-id.ts' },
+      ],
+    },
     {
       id: 'auto_mode',
       title: '变更规模自动分类',
@@ -343,12 +359,26 @@ semantic_guard:
 known_failures:
   - tests/some-old-stable-failure
 
+# ── 等效验证先例库（标准测试/构建命令在本仓不可用时的既有替代口径；verify prompt 自动注入）──
+verify_precedents:
+  - id: standard-test-command-blocked
+    standard_command: mvn test
+    reason: 框架 parent pom 硬编码 surefire skip=true，-D 覆盖无效
+    equivalent: mvn dependency:build-classpath + javac + JUnitCore 直跑
+    established_by: <确立该等效口径的变更名>
+
 # ── worktree-guard 只读命令扩展（execute worktree 隔离期内放行额外只读命令）──
 worktree-hook:
   readonlyCommands:
     - rg
     - fd
 
+# ── worktree 生成物供给（gitignore 生成物不随 git 树/untracked overlay 进 worktree，create 期从主仓复制）──
+# 精确路径或 glob（* 单层 / ** 多层），相对仓根；展开上限 200 文件超出截断警告；缺省不供给零行为变化。
+# worktree:
+#   supplyFiles:
+#     - src/build-id.ts
+
 # ── 变更规模自动分类（sillyspec run auto 时按需求描述强制 quick/full；正则数组，i 大小写无关）──
 auto_mode:
   force_full_patterns:

package/src/contract-matrix.js

@@ -9,9 +9,10 @@
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs'
-import { join, resolve, basename, dirname, relative } from 'path'
+import { join, resolve, basename, dirname, relative, isAbsolute } from 'path'
 import { gitQuiet } from './git-helper.js'
 import { splitOwnVsForeignDiffFiles } from './foreign-declared.js'
+import { parseFileChangeListDetailed } from './change-list.js'
 import {
   scanBackendEndpoints,
   scanFrontendApiCalls,
@@ -19,7 +20,7 @@ import {
   normalizePath,
   diffApiParity,
 } from './endpoint-extractor.js'
-import { parseTaskContracts } from './stages/plan-postcheck.js'
+import { parseTaskContracts, parseRepoRegistry, parseAllowedPaths } from './stages/plan-postcheck.js'
 
 // ─── 关键词检测 ─────────────────────────────────────────────────────────
 
@@ -382,7 +383,9 @@ export function _readWorktreeMeta(specBase, scanRoot, changeName) {
   for (const metaPath of candidates) {
     try {
       if (!existsSync(metaPath)) continue
-      const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
+      // BOM 容错（worktree.js:283 同坑）：Windows 编辑器写入的 UTF-8 BOM 会让 JSON.parse
+      // 失败——双候选下会静默跳根，先剥 BOM 再解析
+      const meta = JSON.parse(String(readFileSync(metaPath, 'utf8')).replace(/^\uFEFF/, ''))
       const gitDir = (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath))
         ? meta.worktreePath : scanRoot
       return { meta, gitDir }
@@ -559,6 +562,74 @@ export function verifyApiParity(specBase, scanRoot, runtimeRoot, changeName = nu
     frontendCalls = scanFrontendApiCalls(frontendRoot)
   }
 
+  // ── 跨仓前端调用并集（坑 probe5-cross-repo-frontend-blind，2026-09-15 EHS 生产实证：三端
+  // 全栈变更的前端在兄弟仓（cross-repo: 前缀声明），主仓 change-diff 永远不含它们 → 报告
+  // 「0 frontend calls」假象、本变更端点全落 unused、契约对账只能靠人工逐条对齐 11 端点）。
+  // 声明源双取：task 卡 allowed_paths 的 cross-repo:<key>: 前缀 + design 清单跨仓条目
+  // （change-list repoKeys 解析，与探针 1 清单同源）；仓根经 local.yaml repos 注册表解析
+  // （resolveCrossRepoDeclarations 同款）。各仓根扫前端调用并按「该仓声明文件集」收窄后并入
+  // frontendCalls——「探针已知口径限制」注记从人肉兜底变机器对账。fail-soft：仓未注册/
+  // 不可达 → crossRepoNotes 一行注记不炸整体；无跨仓声明/无注册表零行为（存量单仓流不受影响）。
+  const crossRepoNotes = []
+  if (changeName && specBase) {
+    try {
+      const declaredByRepo = {}
+      const addDecl = (repo, p) => {
+        const n = String(p || '').trim().replace(/^\.\//, '').replace(/\\/g, '/')
+        if (repo && n) (declaredByRepo[repo] = declaredByRepo[repo] || new Set()).add(n)
+      }
+      // 源1：task 卡 allowed_paths 的 cross-repo:<key>: 前缀（与 _module-map.yaml 约定一致）——
+      // 不按注册表过滤：未注册 key 也要现身「未注册」注记（漏登记可见，而非静默消失）
+      const tasksDir = join(specBase, 'changes', changeName, 'tasks')
+      if (existsSync(tasksDir)) {
+        for (const f of readdirSync(tasksDir)) {
+          if (!/^task-\d+\.md$/.test(f)) continue
+          try {
+            for (const p of parseAllowedPaths(readFileSync(join(tasksDir, f), 'utf8'))) {
+              const m = String(p).match(/^cross-repo:([A-Za-z0-9_.\-]+):(.*)$/)
+              if (m) addDecl(m[1], m[2])
+            }
+          } catch { /* 单卡读取失败不拖垮 */ }
+        }
+      }
+      const registry = parseRepoRegistry(existsSync(join(specBase, 'local.yaml')) ? readFileSync(join(specBase, 'local.yaml'), 'utf8') : '')
+      // 源2：design.md 文件清单跨仓子段/前缀（change-list repoKeys 解析需注册表在——
+      // 注册表空时源2 不可判跨仓，跳过；源1 已保证未注册声明仍可见）。注意
+      // parseFileChangeListDetailed 吃文件路径非文本（内部 existsSync+readFileSync）。
+      if (registry.size > 0) {
+        const designPath = join(specBase, 'changes', changeName, 'design.md')
+        if (existsSync(designPath)) {
+          for (const e of parseFileChangeListDetailed(designPath, { repoKeys: [...registry.keys()] })) {
+            if (e.repo) addDecl(e.repo, e.path)
+          }
+        }
+      }
+      for (const [key, declared] of Object.entries(declaredByRepo)) {
+        const raw = registry.get(key)
+        if (!raw) {
+          crossRepoNotes.push(`repo「${key}」未在 local.yaml repos 注册——该仓前端调用未进对账（register-repo 登记后自动并入）`)
+          continue
+        }
+        const repoRoot = isAbsolute(raw) ? raw : resolve(scanRoot, raw)
+        if (!existsSync(repoRoot)) {
+          crossRepoNotes.push(`repo「${key}」注册路径不可达：${repoRoot}——该仓前端调用未进对账`)
+          continue
+        }
+        const calls = scanFrontendApiCalls(repoRoot).filter(c => {
+          // source 是绝对路径且 Windows 反斜杠形态——与主仓 change-diff 过滤同款手工归一
+          // （normalizePath 是 URL 路径归一器，不碰反斜杠，此处不能用）
+          const src = String(c.source || '').replace(/\\/g, '/')
+          return [...declared].some(dp => src === dp || src.endsWith('/' + dp) || dp.endsWith('/' + src))
+        })
+        if (calls.length > 0) frontendCalls.push(...calls)
+        crossRepoNotes.push(`repo「${key}」@ ${repoRoot}：${calls.length} 前端调用（跨仓声明 ${declared.size} 文件收窄）`)
+        frontendScope += ` + cross-repo:${key}(${calls.length})`
+      }
+    } catch (e) {
+      crossRepoNotes.push(`跨仓前端扫描失败（fail-soft 跳过）：${e && e.message ? e.message : e}`)
+    }
+  }
+
   // ── 挂载前缀收集（坑 endpoints-mount-prefix-gap，2026-08-31 用户实证）：endpoints 提取的是
   // 「router 自身前缀 + 装饰器路径」，不含挂载点前缀（main.py 的 include_router(prefix=)/app.use
   // 与 router 文件分离，静态扫描不做导入图关联）→ 前端全路径调用（/api/xxx）对不上欠前缀端点
@@ -575,6 +646,14 @@ export function verifyApiParity(specBase, scanRoot, runtimeRoot, changeName = nu
     const key = `${u.method} ${u.path}`
     return liveKeys.has(key) || liveEndpoints.length === 0
   })
+  // unused 分层（坑 probe5-unused-stock-noise，2026-09-15 EHS 生产实证：490 个 unused 全是
+  // urgent 等他模块存量端点——全仓 live 扫描 × 本变更对账的口径噪音刷屏）。本变更相关 =
+  // contract artifact 端点集内（本变更换的端点漏配才是真信号）；存量其余折叠计数。无
+  // artifact（非契约流）回退全列零回归。
+  const artifactKeys = new Set(allProviderEndpoints.map(e => `${e.method} ${e.path}`))
+  const hasArtifacts = allProviderEndpoints.length > 0
+  const unusedChangeRelevant = hasArtifacts ? narrowedUnused.filter(u => artifactKeys.has(`${u.method} ${u.path}`)) : narrowedUnused
+  const unusedStockCount = narrowedUnused.length - unusedChangeRelevant.length
 
   const ok = missingBackend.length === 0
   const liveRootSummary = liveByRoot.map(r => `${r.label} ${r.endpoints.length}`).join(' + ')
@@ -583,11 +662,11 @@ export function verifyApiParity(specBase, scanRoot, runtimeRoot, changeName = nu
     : `❌ API parity check failed: ${missingBackend.length} frontend calls have no matching backend endpoint [scope: ${frontendScope}]`
 
   if (narrowedUnused.length > 0) {
-    summary += ` | ${narrowedUnused.length} backend endpoints unused by frontend`
+    summary += ` | ${unusedChangeRelevant.length} backend endpoints unused by frontend${unusedStockCount > 0 ? ` (+${unusedStockCount} stock noise collapsed)` : ''}`
   }
   if (prefixAlignedCount > 0) {
     summary += ` | ${prefixAlignedCount} calls matched after mount-prefix alignment (artifact paths exclude include_router/app.use prefixes)`
   }
 
-  return { ok, missingBackend, unusedBackend: narrowedUnused, summary, backendCount: mergedProviderEndpoints.length, frontendCount: frontendCalls.length, prefixAlignedCount, scanRoots: liveByRoot.map(r => r.root) }
+  return { ok, missingBackend, unusedBackend: narrowedUnused, unusedChangeRelevant, unusedStockCount, crossRepoNotes, summary, backendCount: mergedProviderEndpoints.length, frontendCount: frontendCalls.length, prefixAlignedCount, scanRoots: liveByRoot.map(r => r.root) }
 }

package/src/cross-repo-reconcile.js

@@ -0,0 +1,134 @@
+/**
+ * cross-repo-reconcile.js — 跨仓 task 卡 target_files 的 per-repo 对账（零环新模块）。
+ *
+ * 坑 cross-repo-reconcile-blindness（2026-09-15 复盘实证：三端变更的对账表只有主仓机器可见，
+ * 22 个跨仓文件在归档表全标「计划未动」、探针5 报「0 frontend calls」，跨仓全靠人工到对应仓
+ * 解释）：reconcileTargetFiles 主链按 D-004 把跨仓卡从声明侧剔除——主仓 actual 永远对不上跨仓
+ * 声明，剔除本身正确；但「留待后续分期」一直没有兑现，跨仓侧零机器可见性。
+ *
+ * 本模块兑现该分期：对每张跨仓卡声明的 repo key，读 local.yaml repos 注册表解析仓根，在**该仓**
+ * 取 actual（diff HEAD~1..HEAD ∪ status porcelain untracked，与 resolveVerifyChangedFiles 跨仓
+ * 分支同源口径），按主仓同款三类差集对账（matched / missing / undeclared + 脚手架软桶）。
+ *
+ * 定位与边界（与主仓对账的差异，显式声明防误读）：
+ * - **advisory 不阻断**：跨仓 diff 锚点是 HEAD~1..HEAD 最近提交窗口（多 task 同仓时只反映最近
+ *   一笔，精确范围要 task 卡 base/head 锡点——verify-postcheck:1119 先例同款限制），锚点脆弱期
+ *   （已 commit 多笔 / 全在 working-tree）会产②类假信号，故只报告不翻转 verify 状态。
+ * - 仓未注册 / 路径不可达 / 非 git 仓 → 该 repo degraded 一行说明，不炸整体。
+ * - 不 import verify-postcheck（后者 import 本模块，反向成环）；路径归一/大小写折叠与主仓
+ *   normalizeReconcilePath/pathKey 同口径本地实现，注释锚定不漂移。
+ */
+import { existsSync, readFileSync } from 'fs'
+import { join, isAbsolute, resolve } from 'path'
+import { gitQuiet } from './git-helper.js'
+import { parseRepoRegistry } from './stages/plan-postcheck.js'
+import { filterDeliverableFiles, classifyToolScaffold } from './worktree-apply.js'
+
+// 与 verify-postcheck normalizeReconcilePath 同口径（本地实现防环）：剥 ./ 前缀、反斜杠归一
+function normalizeRepoPath(p) {
+  return String(p || '').trim().replace(/^\.\//, '').replace(/\\/g, '/')
+}
+
+// 与 verify-postcheck reconcileTargetFiles 的 foldCase 同口径：win32/darwin 文件系统大小写
+// 不敏感，两形指同一文件；Linux 保持敏感
+const foldCase = process.platform === 'win32' || process.platform === 'darwin'
+const pathKey = (p) => {
+  const n = normalizeRepoPath(p)
+  return foldCase ? n.toLowerCase() : n
+}
+
+// 与 verify-postcheck parsePorcelainFilePaths 同口径（本地实现防环）：剥 XY 状态列、rename 取
+// -> 后新路径、剥包裹引号、反斜杠归一
+function parsePorcelain(raw) {
+  return String(raw || '').split('\n')
+    .map(l => l.slice(3).trim())
+    .map(p => (p.includes(' -> ') ? p.slice(p.lastIndexOf(' -> ') + 4) : p).trim())
+    .map(p => p.replace(/^"|"$/g, ''))
+    .map(p => p.replace(/\\/g, '/'))
+    .filter(Boolean)
+}
+
+/**
+ * 跨仓声明对账。declarationsByRepo 由声明侧收集（collectDeclaredTargetFiles 跨仓卡分支）：
+ * `{ [repoKey]: Array<{task, path, isNew}> }`——path 相对该仓根（跨仓卡口径）。
+ *
+ * @param {{ specBase: string, cwd: string, declarationsByRepo: Record<string, Array<{task:string,path:string,isNew:boolean}>> }} args
+ * @returns {Array<{repo:string, repoPath:string|null, declaredCount:number, actualCount:number,
+ *   matched:string[], missing:Array<{task:string,path:string,isNew?:boolean}>,
+ *   undeclared:string[], scaffoldCount:number, degradedReason:string|null}>}
+ *   每 repo 一项；degradedReason 非空时 matched/missing/undeclared 为空数组（该仓无结论）。
+ */
+export function reconcileCrossRepoDeclarations({ specBase, cwd, declarationsByRepo }) {
+  const results = []
+  const repos = declarationsByRepo && typeof declarationsByRepo === 'object' ? Object.keys(declarationsByRepo) : []
+  if (repos.length === 0) return results
+
+  let registry = new Map()
+  try {
+    const yamlPath = join(specBase || '', 'local.yaml')
+    if (specBase && existsSync(yamlPath)) {
+      registry = parseRepoRegistry(readFileSync(yamlPath, 'utf8'))
+    }
+  } catch { /* local.yaml 不可读 → 空注册表，各 repo 落「未注册」degraded */ }
+
+  for (const repoKey of repos) {
+    const declarations = declarationsByRepo[repoKey] || []
+    const base = { repo: repoKey, repoPath: null, declaredCount: declarations.length, actualCount: 0,
+      matched: [], missing: [], undeclared: [], scaffoldCount: 0, degradedReason: null }
+
+    const rawPath = registry.get(repoKey)
+    if (!rawPath) {
+      results.push({ ...base, degradedReason: `repo key「${repoKey}」未在 local.yaml repos 注册——跨仓对账不可达，请人工到对应仓核对` })
+      continue
+    }
+    const repoPath = isAbsolute(rawPath) ? rawPath : resolve(cwd, rawPath)
+    base.repoPath = repoPath
+    if (!existsSync(repoPath)) {
+      results.push({ ...base, degradedReason: `注册路径不可达：${repoPath}` })
+      continue
+    }
+
+    // actual 双源（resolveVerifyChangedFiles 跨仓分支同源）：已提交窗口 + working-tree 未提交
+    const union = new Set()
+    let anySource = false
+    const diffOut = gitQuiet(repoPath, ['diff', '--name-only', 'HEAD~1..HEAD'], { timeout: 30 * 1000 })
+    if (diffOut !== null) {
+      anySource = true
+      for (const f of String(diffOut).split('\n')) {
+        const n = normalizeRepoPath(f)
+        if (n) union.add(n)
+      }
+    }
+    const statusOut = gitQuiet(repoPath, ['status', '--porcelain', '--untracked-files=all'], { timeout: 30 * 1000, trim: false })
+    if (statusOut !== null) {
+      anySource = true
+      for (const f of parsePorcelain(statusOut)) union.add(f)
+    }
+    if (!anySource) {
+      results.push({ ...base, degradedReason: '该仓 git 不可用/非仓库（diff 与 status 双失败）' })
+      continue
+    }
+
+    const actualFiles = [...new Set(filterDeliverableFiles([...union]).filter(Boolean))].sort()
+    base.actualCount = actualFiles.length
+    const actualKeySet = new Set(actualFiles.map(pathKey))
+    const declaredPaths = [...new Set(declarations.map(d => d.path))].sort()
+    const declaredKeySet = new Set(declaredPaths.map(pathKey))
+    for (const path of declaredPaths) {
+      if (actualKeySet.has(pathKey(path))) base.matched.push(path)
+    }
+    for (const d of declarations) {
+      if (!actualKeySet.has(pathKey(d.path))) {
+        base.missing.push(d.isNew ? { task: d.task, path: d.path, isNew: true } : { task: d.task, path: d.path })
+      }
+    }
+    // 脚手架软桶（主仓 reconcileTargetFiles 同口径）：工具/平台设施文件不进③类逐条清单
+    for (const path of actualFiles) {
+      if (declaredKeySet.has(pathKey(path))) continue
+      if (classifyToolScaffold(path)) { base.scaffoldCount++; continue }
+      base.undeclared.push(path)
+    }
+    results.push(base)
+  }
+  return results
+}

package/src/design-facts.js

@@ -25,6 +25,7 @@ import { existsSync, readFileSync, readdirSync } from 'node:fs'
 import { join } 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'
 
 // ---------------------------------------------------------------------------
@@ -423,25 +424,63 @@ export function validateDesignFileList({ changeDir, cwd } = {}) {
     if (!existsSync(designPath)) {
       return { ok: true, errors, warnings: ['design 清单核验跳过：design.md 不存在'] }
     }
-    const entries = parseFileChangeListDetailed(designPath, { keepSillyspecDocs: true })
-    if (!Array.isArray(entries) || entries.length === 0) {
-      return { ok: true, errors, warnings: ['design 清单核验跳过：design.md 无文件变更清单段（small 变更可无清单）'] }
+
+    // 单段存在性核验内核：NEW:/glob/占位符口径与原实现一致，仅把「根」参数化
+    const checkAgainstRoot = (root, rawPaths, repoLabel) => {
+      for (const raw of rawPaths) {
+        const rawPath = String(raw || '').trim()
+        if (!rawPath) continue
+        if (rawPath.startsWith('NEW:')) continue // 计划新建豁免（与 validateTargetFiles 同语义）
+        if (rawPath.includes('*') || rawPath.includes('?')) {
+          warnings.push(`design 清单条目含 glob 字符跳过存在性核验：${rawPath}`)
+          continue
+        }
+        const normalized = stripPathPlaceholders(rawPath)
+        if (!normalized || normalized === '.') continue
+        if (!existsSync(join(root, normalized))) {
+          errors.push({
+            path: rawPath,
+            message: `design_file_ref_invalid：文件变更清单条目「${rawPath}」在${repoLabel}（${root}）下不存在且无 NEW: 前缀（幻觉路径/书写错误）——修正路径，或计划新建的文件改为 NEW:${rawPath} 前缀`,
+          })
+        }
+      }
+    }
+
+    // 坑 design-file-ref-cross-repo-blind（2026-09-15 wp 会话实证，41 条误报）：存在性核验
+    // 此前恒以主仓 cwd 为根——design §6 按仓分段（D-014）下的跨仓「修改」条目（如
+    // sub-grid-security 的 src/common/router.js）在其自己仓里明明存在，却被逼标 NEW: 前缀
+    // 过 gate（标「修改」的既有文件被迫声明为计划新建，语义撒谎）。对齐
+    // validateDesignFileCoverage 的分段口径：复用 parseDesignCoverageByRepo 按 `## <repo>
+    // 仓变更` 段头切分，main 段核主仓根，跨仓段核 local.yaml repos: 注册根；无段头时
+    // 整章归 main（原行为零回归）。
+    const { byRepo, hasSegmentHeader, malformedHeaders } = parseDesignCoverageByRepo(designPath)
+    for (const h of malformedHeaders) {
+      warnings.push(`design 清单疑似仓变更段头格式异常（该段文件可能被记到上一段仓，覆盖对账会点名）：${h}`)
     }
-    for (const e of entries) {
-      const raw = String((e && e.path) || '').trim()
-      if (!raw) continue
-      if (raw.startsWith('NEW:')) continue // 计划新建豁免（与 validateTargetFiles 同语义）
-      if (raw.includes('*') || raw.includes('?')) {
-        warnings.push(`design 清单条目含 glob 字符跳过存在性核验：${raw}`)
-        continue
+
+    if (!hasSegmentHeader) {
+      const entries = parseFileChangeListDetailed(designPath, { keepSillyspecDocs: true })
+      if (!Array.isArray(entries) || entries.length === 0) {
+        return { ok: true, errors, warnings: [...warnings, 'design 清单核验跳过：design.md 无文件变更清单段（small 变更可无清单）'] }
       }
-      const normalized = stripPathPlaceholders(raw)
-      if (!normalized || normalized === '.') continue
-      if (!existsSync(join(cwd, normalized))) {
-        errors.push({
-          path: raw,
-          message: `design_file_ref_invalid：文件变更清单条目「${raw}」既不存在也无 NEW: 前缀（幻觉路径/书写错误）——修正路径，或计划新建的文件改为 NEW:${raw} 前缀`,
-        })
+      checkAgainstRoot(cwd, entries.map(e => e.path), '主仓')
+      return { ok: errors.length === 0, errors, warnings }
+    }
+
+    // 有段头：逐段按其仓根核验。跨仓注册表读侧口径 = <cwd>/.sillyspec/local.yaml
+    // （与 execute MultiRepoContext / register-repo 写侧一致，parseRepoRegistry 自带 CRLF 容差）
+    let registry = null
+    const localYamlPath = join(cwd, '.sillyspec', 'local.yaml')
+    if (existsSync(localYamlPath)) {
+      try { registry = parseRepoRegistry(readFileSync(localYamlPath, 'utf8')) } catch { registry = null }
+    }
+    for (const [repo, paths] of byRepo) {
+      if (repo === 'main') {
+        checkAgainstRoot(cwd, paths, '主仓')
+      } else if (registry && registry.has(repo)) {
+        checkAgainstRoot(registry.get(repo), paths, `${repo} 仓`)
+      } else {
+        warnings.push(`design 清单「${repo} 仓变更」段的 repo 未在 local.yaml repos: 注册，跳过该段存在性核验（execute 启动会 fail-closed 拦截，先跑 sillyspec local register-repo ${repo} <仓根路径>）`)
       }
     }
     return { ok: errors.length === 0, errors, warnings }

package/src/index.js

@@ -4089,7 +4089,14 @@ SillySpec modules — 模块文档管理
           process.exit(1);
         }
         const { resolveLocalYamlWriteTarget } = await import('./config-cat.js');
-        const target = resolveLocalYamlWriteTarget(dir, { specBase: rrSpecBase });
+        // 坑 register-repo-specbase-split-brain（2026-09-15 wp 平台模式会话实证）：specBase
+        // 优先的写候选链在平台模式下命中平台 spec 根 local.yaml，而 repos: 段的全部读侧
+        // （execute MultiRepoContext / worktree-cross / run shared）恒读 <cwd>/.sillyspec/local.yaml
+        // ——注册写进 spec 根 = 死配置，execute 启动 fail-closed 报未注册，agent 只能试出
+        // --spec-dir 指向项目 .sillyspec 才能绕过。修复：默认（无显式 --spec-dir）写目标走
+        // 读侧对齐链（不喂 specBase，cwd 祖先链命中项目 local.yaml，worktree 自动反推主仓）；
+        // 显式 --spec-dir 是用户明示选择，仍尊重。
+        const target = resolveLocalYamlWriteTarget(dir, specDir ? { specBase: rrSpecBase } : {});
         const { registerRepoInLocalYaml } = await import('./local-register.js');
         let rrResult;
         try {
@@ -4101,6 +4108,16 @@ SillySpec modules — 模块文档管理
         const verb = rrResult.replaced ? '已更新（覆盖旧路径）' : '已注册';
         console.log(`✅ repos.${rrKey} ${verb}: ${absRepo.replace(/\\/g, '/')}`);
         console.log(`   写入: ${target.path}${rrResult.fileCreated ? '（新建文件）' : ''}${rrResult.sectionCreated ? '（新建 repos: 段）' : ''}`);
+        // 同坑提醒：平台 spec 根也躺着一份 local.yaml 时，其 repos: 段不生效（读侧只读项目侧）
+        // ——不Dual写（两份各自演化=再分裂），只提示用户那份是死配置可清理
+        if (!specDir && rrSpecBase) {
+          const altYaml = join(rrSpecBase, 'local.yaml');
+          try {
+            if (existsSync(altYaml) && resolve(altYaml) !== resolve(target.path)) {
+              console.warn(`⚠️  平台 spec 根另有一份 local.yaml（${altYaml}）——repos: 注册只在项目 local.yaml 生效（execute 等读侧只读项目侧），spec 根那份的 repos: 段是死配置`);
+            }
+          } catch { /* 提醒失败不影响注册结果 */ }
+        }
         console.log('   查看: sillyspec config cat（真实配置）; main 隐式=主仓不用注册');
         break;
       }