sillyspec 3.28.9 → 3.28.11

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'
 
 // ---------------------------------------------------------------------------
@@ -331,7 +332,8 @@ export function generateDesignSkeleton({ changeName, decisionsText, author, now
   lines.push('')
   lines.push('| 操作 | 文件路径 | 说明 |')
   lines.push('|---|---|---|')
-  lines.push('<!-- 示例行（替换为实际清单后删除本注释）：| 新增 | src/xxx/NewFile.java | 说明（含对外字段时交代 producer→consumer 数据流） | -->')
+  lines.push('<!-- 示例行（替换为实际清单后删除本注释）：| 新增 | NEW:src/xxx/NewFile.java | 说明（含对外字段时交代 producer→consumer 数据流） | -->')
+  lines.push('<!-- 路径存在性核验铁律：计划新建的文件路径必须带 NEW: 前缀（如上例），已有文件写仓根相对正斜杠路径——末步 --done 门禁逐一核验存在性，无前缀的新建路径按 design_file_ref_invalid 拦截返工（2026-09-17 用户反馈⑥-①，写作期即提示） -->')
   lines.push('')
 
   lines.push('## 接口定义')
@@ -423,25 +425,99 @@ 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} 前缀`,
+          })
+        }
+      }
     }
-    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
+
+    // 坑 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}`)
+    }
+
+    // 跨仓注册表读侧口径 = <cwd>/.sillyspec/local.yaml（与 execute MultiRepoContext /
+    // register-repo 写侧一致，parseRepoRegistry 自带 CRLF 容差）——有段头/无段头两分支
+    // 共用（task-05 / FR-10 上移：无段头分支也要做跨仓注册路径前缀命中判定）
+    let registry = null
+    const localYamlPath = join(cwd, '.sillyspec', 'local.yaml')
+    if (existsSync(localYamlPath)) {
+      try { registry = parseRepoRegistry(readFileSync(localYamlPath, 'utf8')) } catch { registry = null }
+    }
+
+    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} 前缀`,
-        })
+      // task-05 / FR-10 无段头缺口：清单行含跨仓注册路径（注册值/basename 前缀命中）时不按
+      // 主仓根打 design_file_ref_invalid 逼 NEW: 前缀（跨仓既有文件被逼声明计划新建=语义撒谎，
+      // 坑 design-file-ref-cross-repo-blind 同族的无段头形态），降 warning 提示补段头——补
+      // 「## <repo> 仓变更」段头后该段按仓根核验，真幻觉路径仍会在仓根核验下暴露（只消除
+      // 假红、不引入假绿）。纯主仓行（无前缀命中）走原主仓根核验，行为零变化。
+      const crossPrefixes = []
+      if (registry) {
+        for (const [repoKey, rootRaw] of registry) {
+          const root = String(rootRaw || '').replace(/\\/g, '/').replace(/\/+$/, '')
+          if (!root) continue
+          const bn = root.split('/').pop()
+          crossPrefixes.push({ repoKey, prefixes: bn && bn !== root ? [root, bn] : [root] })
+        }
+      }
+      const hitCrossRepo = (rawPath) => {
+        const n = String(rawPath || '').trim().replace(/\\/g, '/')
+        if (!n) return null
+        for (const c of crossPrefixes) {
+          for (const pre of c.prefixes) {
+            if (n === pre || n.startsWith(pre + '/')) return c.repoKey
+          }
+        }
+        return null
+      }
+      const mainPaths = []
+      for (const e of entries) {
+        const hit = hitCrossRepo(e.path)
+        if (hit) {
+          warnings.push(`design 清单无仓变更段头且该行疑似跨仓 ${hit} 仓路径：${e.path}——补「## ${hit} 仓变更」段头后按该仓根核验（暂不按主仓根核验/逼 NEW: 前缀）`)
+        } else {
+          mainPaths.push(e.path)
+        }
+      }
+      checkAgainstRoot(cwd, mainPaths, '主仓')
+      return { ok: errors.length === 0, errors, warnings }
+    }
+
+    // 有段头：逐段按其仓根核验。
+    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/docs-check.js

@@ -117,12 +117,15 @@ export function createHeadReader(projectRoot, ref = 'HEAD') {
  * 纯位置锚 `file.js:123?`（2026-09-11 用户实证 docs gate 误伤：跨文件引用+反话论述——锚 A
  * 文件而行内反引号 token 全是 B 概念，层 2 必失败，被迫删行号绕开）：`?` 显式声明本锚只做
  * 定位不做关键词断言，层 1（存在性+行界）照校——论述语境锚的一等语法，替代行号化绕开。
- * 文件段展开循环形（D-006，2026-09-08-docs-fix-capability）：普通段可选 + 零或多个「闭合括号段+普通段」
- * 迭代——支持 Next.js 路由组 (dashboard) 等括号路径；markdown 链接 [t](foo.js:12) 在 `(` 处括号段
- * 要求 `)` 先于 `:` 闭合而失败，回落 foo.js:12 零回归；嵌套 ((x)) 部分提取（与旧行为一致）。
- * ⚠ 不用原子序列 (?:A+|B+)+——经典嵌套量词 ReDoS（Grill 实证 n=30 长 token 73.8s），
- * 展开循环每次迭代必含括号段 → 划分唯一 → 线性。 */
-const REF_RE = /(?:repo:\/\/([A-Za-z0-9_.\-]+)\/)?([A-Za-z0-9_.\-\/]*(?:\([A-Za-z0-9_.\-\/]+\)[A-Za-z0-9_.\-\/]*)*\.(?:js|mjs|cjs|ts|tsx|jsx|py|java|go)):(\d+)(?:-(\d+))?(\?)?/g
+ * 文件段展开循环形（D-006，2026-09-08-docs-fix-capability；圆/方并列 2026-09-17-docs-bracket-reanchor）：
+ * 普通段可选 + 零或多个「闭合括号段（圆/方同权）+普通段」迭代——Next.js 路由组 (dashboard) 与
+ * 动态路由 [id]/[cid] 一等公民（D-001：完整开闭同形括号对并列，[ ] 不进普通段字符类）；markdown
+ * 链接 [t](foo.js:12) 的 [t] 匹配方括号段后遇 `(` 截止——后续圆括号段要求 `)` 先于 `:` 闭合、
+ * 扩展名组要求 `.` 均失败，回溯放弃 [t] 段回落提取 foo.js:12（与圆括号段同族回落，零回归）；嵌套
+ * ((x)) 与 [[x]]/[[...slug]] 内容含 `(`/`[` 不属括号段字符类 → 段不成立，部分提取残段（与旧正则
+ * 逐字节一致）。⚠ 不用原子序列 (?:A+|B+)+——经典嵌套量词 ReDoS（Grill 实证 n=30 长 token 73.8s），
+ * 展开循环每次迭代必含完整开闭同形括号对 → 划分唯一 → 线性。 */
+const REF_RE = /(?:repo:\/\/([A-Za-z0-9_.\-]+)\/)?([A-Za-z0-9_.\-\/]*(?:(?:\([A-Za-z0-9_.\-\/]+\)|\[[A-Za-z0-9_.\-\/]+\])[A-Za-z0-9_.\-\/]*)*\.(?:js|mjs|cjs|ts|tsx|jsx|py|java|go)):(\d+)(?:-(\d+))?(\?)?/g
 
 /** 缺省扫描范围：docs/ + .sillyspec/docs/（scan/modules 产物同是文档，失效即该暴露；2026-08-16 用户裁决改缺省，见 doc-consistency-debt.md §八）
  * + .sillyspec/changes/ + .sillyspec/knowledge/（P1-1，noai-ir-roadmap §4：最活跃、最易产生
@@ -167,11 +170,12 @@ export class DocsCheckConfigError extends Error {}
 /**
  * 符号锚正则（P1-2，noai-ir-roadmap §4）：`file.js::symbol` 形态——校验时解析符号定义行，
  * 天然免疫行号漂移（重锚从「每次代码移动」降为「仅改名时」）。文件段与 REF_RE 同款（含
- * repo:// 跨仓前缀与括号路径组展开），`::` 后只认 ASCII 标识符（自然语言/中文括注不触发，
- * QUICKLOG file-notes 的 `path::注` 约定因注解非标识符而天然互斥）。与 REF_RE 互斥：
- * `::ident` 无数字不匹配行号式；`file.js:12` 无 `::` 不匹配符号式。
+ * repo:// 跨仓前缀与括号路径组展开；2026-09-17-docs-bracket-reanchor 起圆/方括号段并列
+ * 同权——动态路由 app/[lang]/layout.tsx 类路径可符号锚），`::` 后只认 ASCII 标识符（自然语言/
+ * 中文括注不触发，QUICKLOG file-notes 的 `path::注` 约定因注解非标识符而天然互斥）。
+ * 与 REF_RE 互斥：`::ident` 无数字不匹配行号式；`file.js:12` 无 `::` 不匹配符号式。
  */
-const SYMBOL_REF_RE = /(?:repo:\/\/([A-Za-z0-9_.\-]+)\/)?([A-Za-z0-9_.\-\/]*(?:\([A-Za-z0-9_.\-\/]+\)[A-Za-z0-9_.\-\/]*)*\.(?:js|mjs|cjs|ts|tsx|jsx|py|java|go))::([A-Za-z_$][A-Za-z0-9_$]*)/g
+const SYMBOL_REF_RE = /(?:repo:\/\/([A-Za-z0-9_.\-]+)\/)?([A-Za-z0-9_.\-\/]*(?:(?:\([A-Za-z0-9_.\-\/]+\)|\[[A-Za-z0-9_.\-\/]+\])[A-Za-z0-9_.\-\/]*)*\.(?:js|mjs|cjs|ts|tsx|jsx|py|java|go))::([A-Za-z_$][A-Za-z0-9_$]*)/g
 
 /**
  * 符号定义行定位（与 classifyFix 的 defRe 同款形态，单一判定口径）：function/const/let/

package/src/docs-debt.js

@@ -363,8 +363,13 @@ export function renderDecisionTouchFacts(touches) {
  * @returns {{ root: string, changedFiles: string[] }} root = 实际 git 锚（computeDocsDebt 的 projectRoot 同值）
  */
 export function collectExecuteChangedFiles({ specBase, changeName, cwd, projectRoot } = {}) {
-  const wtRoot = specBase ? join(specBase, '.runtime', 'worktrees', changeName || '') : null
-  const root = projectRoot || (wtRoot && changeName && existsSync(wtRoot) ? wtRoot : cwd) || process.cwd()
+  // 双候选 worktree 根（坑 platform-dual-root-fourth-consumer，2026-09-16 hunt 实证）：平台模式
+  // specBase=specRoot 时主仓 worktree 在项目侧 <cwd>/.sillyspec——单查 specBase 必落空 → root 退
+  // cwd → 收进的是主仓脏集而非 worktree 交付集，docs-debt 事实面错。对齐 contract-matrix 双候选。
+  const wtCandidates = [...new Set([specBase, join(cwd || process.cwd(), '.sillyspec')].filter(Boolean))]
+    .map(b => join(b, '.runtime', 'worktrees', changeName || ''))
+  const wtRoot = changeName ? (wtCandidates.find(p => existsSync(p)) || null) : null
+  const root = projectRoot || (wtRoot ? wtRoot : cwd) || process.cwd()
   const changed = new Set()
   const statusRes = safeGit(root, ['status', '--porcelain'], { trim: false })
   if (!statusRes.error && statusRes.value) {

package/src/docs-gate.js

@@ -16,8 +16,16 @@
  * 远端 origin/main 已合入的失效消化/新增不会回流本地基线——出现「基线 371 < origin/main
  * 实测 379、本地 current 379」时 ratchet 拦 379>371，但本次推送零增量（不劣于远端）——
  * ratchet 本质=拦增量，被陈旧基线破坏成拦存量。修复：current > baseline 分支先实测
- * origin/main 树（临时 detach worktree 跑 runDocsCheck），current ≤ 实测值即放行 + 提示
- * 重锚；实测失败/无远端 ref fail-open 回原拦。快路径（current ≤ baseline）零成本零变化。
+ * origin/main 树（临时 detach worktree 跑 runDocsCheck），current ≤ 实测值即放行；实测
+ * 失败/无远端 ref fail-open 回原拦。快路径（current ≤ baseline）零成本零变化。
+ *
+ * 陈旧分支自动重锚（2026-09-17-docs-bracket-reanchor，D-002@v1）：走到该分支即已实付
+ * 远端实测成本验证「本次不劣于远端」——已验证事实自动回流基线：口径守卫通过即
+ * writeBaseline(current) + 消息披露（陈旧提示出现一次即消失，棘轮只紧不松：新基线 =
+ * current ≤ 远端实测，每一分增量都有实测背书）。守卫只拦 checkOpts 一次性覆盖（paths/
+ * skip/keywordAssert/crossRepoRoots 四键——异口径计数写盘会错调基线），不拦 local.yaml
+ * 持久口径（measure 与 current 恒同读该配置，读写同源自洽）；首次立线 fail-closed 不变
+ * （无基线仍须显式 --init-baseline，自动重锚仅限基线已存在的陈旧分支）。
  */
 import { readFileSync, writeFileSync, existsSync, mkdtempSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
@@ -138,12 +146,19 @@ export async function measureRemoteBaselineCount(projectRoot, remoteRefs = ['ori
  * IO 入口：跑一次 gate。
  * @param {{ projectRoot: string, specBase: string, initBaseline?: boolean }} opts
  *   projectRoot 源码仓根（docs check 锚）；specBase .sillyspec 根（基线文件所在）
- * @param {object} checkOpts 透传 runDocsCheck（paths/skip/keywordAssert 覆盖；缺省读 local.yaml）
+ * @param {object} checkOpts 透传 runDocsCheck（paths/skip/keywordAssert/crossRepoRoots 覆盖；缺省
+ *   读 local.yaml）——四键任一显式传入即触发陈旧分支口径守卫（不自动重锚，见头注）
  * @returns {Promise<{ exitCode: 0|1|2, ok: boolean, current: number, baseline: number|null,
- *                     delta: number|null, message: string, inited: boolean }>}
+ *                     delta: number|null, message: string, inited: boolean,
+ *                     reanchored: boolean }>} reanchored：陈旧分支自动重锚 true（baseline 返
+ *   新值 = current），其余分支缺省 false
  */
 export async function runDocsGate(opts = {}, checkOpts = {}) {
   const { projectRoot, specBase, initBaseline = false } = opts;
+  // 口径守卫：checkOpts 一次性子集/异口径覆盖时计数口径 ≠ 持久口径，写盘会错调基线——
+  // 陈旧分支不自动重锚（against 不算守卫键：与 --init-baseline --against 同写提交树
+  // 实测值语义一致，不新增口径）。不拦 local.yaml 持久口径（measure 与 current 恒同读）
+  const scopeGuarded = !!(checkOpts.paths || checkOpts.skip || checkOpts.keywordAssert != null || checkOpts.crossRepoRoots);
   let result;
   try {
     const cfg = readDocsCheckConfig(projectRoot);
@@ -159,7 +174,7 @@ export async function runDocsGate(opts = {}, checkOpts = {}) {
     });
   } catch (e) {
     if (e instanceof DocsCheckConfigError) {
-      return { exitCode: 2, ok: false, current: null, baseline: null, delta: null, originCount: null, message: `docs gate 配置错误：${e.message}`, inited: false };
+      return { exitCode: 2, ok: false, current: null, baseline: null, delta: null, originCount: null, message: `docs gate 配置错误：${e.message}`, inited: false, reanchored: false };
     }
     throw e;
   }
@@ -167,7 +182,7 @@ export async function runDocsGate(opts = {}, checkOpts = {}) {
 
   if (initBaseline) {
     writeBaseline(specBase, current);
-    return { exitCode: 0, ok: true, current, baseline: current, delta: 0, originCount: null, message: `📌 docs gate: 基线已初始化为当前实测 ${current} 处失效（${baselineDisplay(specBase)}）`, inited: true };
+    return { exitCode: 0, ok: true, current, baseline: current, delta: 0, originCount: null, message: `📌 docs gate: 基线已初始化为当前实测 ${current} 处失效（${baselineDisplay(specBase)}）`, inited: true, reanchored: false };
   }
 
   const baseline = readBaseline(specBase);
@@ -175,27 +190,39 @@ export async function runDocsGate(opts = {}, checkOpts = {}) {
     return {
       exitCode: 2, ok: false, current, baseline: null, delta: null, originCount: null,
       message: `❌ docs gate: 无基线文件（${baselineDisplay(specBase)}）。首次使用先跑 sillyspec docs gate --init-baseline（以当前实测数立基线，存量既往不咎只拦增量）`,
-      inited: false,
+      inited: false, reanchored: false,
     };
   }
   if (Number.isNaN(baseline)) {
-    return { exitCode: 2, ok: false, current, baseline: null, delta: null, originCount: null, message: `❌ docs gate: 基线文件损坏（非非负整数），手工修正或 --init-baseline 重置`, inited: false };
+    return { exitCode: 2, ok: false, current, baseline: null, delta: null, originCount: null, message: `❌ docs gate: 基线文件损坏（非非负整数），手工修正或 --init-baseline 重置`, inited: false, reanchored: false };
   }
   const v = evaluateRatchet({ current, baseline });
   if (v.ok) {
     // 快路径（current ≤ baseline）：原路零变化——不触远端实测（零 git 成本零行为漂移）
-    return { exitCode: 0, ok: true, current, baseline, delta: v.delta, originCount: null, message: v.message, inited: false };
+    return { exitCode: 0, ok: true, current, baseline, delta: v.delta, originCount: null, message: v.message, inited: false, reanchored: false };
   }
   // 坑 docs-gate-stale-baseline（ql-20260915-004）：current > baseline 时 origin 实测兜底——
   // ratchet 本质=拦增量；基线是静态快照，远端已合入的失效增长不回流基线会造成「未劣于远端
-  // 也被拦」的假拦。实测 origin/main 树：current ≤ 实测值 = 本次不劣于远端 → 放行 + 提示
-  // 重锚；无远端 ref / 实测失败 fail-open 回原拦；current > 实测值 = 真增量劣于远端 → 拦。
+  // 也被拦」的假拦。实测 origin/main 树：current ≤ 实测值 = 本次不劣于远端 → 放行 + 自动
+  // 重锚落盘（D-002@v1；口径守卫命中时不写盘、维持手动重锚建议）；无远端 ref / 实测失败
+  // fail-open 回原拦；current > 实测值 = 真增量劣于远端 → 拦。
   const measured = await measureRemoteBaselineCount(projectRoot);
   if (measured.originCount !== null && current <= measured.originCount) {
+    if (scopeGuarded) {
+      // 守卫：checkOpts 一次性覆盖（异口径计数）——基线文件不动，维持手动 --init-baseline 建议文案
+      return {
+        exitCode: 0, ok: true, current, baseline, delta: v.delta, originCount: measured.originCount,
+        message: `⚠️ docs gate: 基线陈旧：基线 ${baseline} < ${measured.ref} 实测 ${measured.originCount}，本次 ${current} 处失效未劣于远端不拦——建议 sillyspec docs gate --init-baseline 重锚锁定（以当前实测 ${current} 立线，存量既往不咎只拦增量）`,
+        inited: false, reanchored: false,
+      };
+    }
+    // 自动重锚：已实付实测成本验证「本次不劣于远端」——事实回流基线，同态第二次跑走快路径
+    //（陈旧提示与远端实测各只发生一次）；新基线 = current ≤ 远端实测，棘轮只紧不松
+    writeBaseline(specBase, current);
     return {
-      exitCode: 0, ok: true, current, baseline, delta: v.delta, originCount: measured.originCount,
-      message: `⚠️ docs gate: 基线陈旧：基线 ${baseline} < ${measured.ref} 实测 ${measured.originCount}，本次 ${current} 处失效未劣于远端不拦——建议 sillyspec docs gate --init-baseline 重锚锁定（以当前实测 ${current} 立线，存量既往不咎只拦增量）`,
-      inited: false,
+      exitCode: 0, ok: true, current, baseline: current, delta: v.delta, originCount: measured.originCount,
+      message: `⚠️ docs gate: 基线陈旧：基线 ${baseline} < ${measured.ref} 实测 ${measured.originCount}，本次 ${current} 处失效未劣于远端不拦——📌 已自动重锚 基线 ${baseline}→${current}（实测不劣于远端，已落盘锁定；棘轮只紧不松）`,
+      inited: false, reanchored: true,
     };
   }
   const remoteNote = measured.originCount !== null
@@ -204,6 +231,6 @@ export async function runDocsGate(opts = {}, checkOpts = {}) {
   return {
     exitCode: 1, ok: false, current, baseline, delta: v.delta, originCount: measured.originCount,
     message: `❌ docs gate: ${current} 处失效 > 基线 ${baseline}（新增 ${v.delta} 处）${remoteNote}，拦截。修掉新增引用或显式 --init-baseline 重置基线（需你确认存量合法）`,
-    inited: false,
+    inited: false, reanchored: false,
   };
 }

package/src/endpoint-extractor.js

@@ -24,6 +24,46 @@ function lineOfIndex(content, index) {
   return content.slice(0, index).split('\n').length
 }
 
+/**
+ * 注释掩码（坑 endpoint-extractor-selfdoc-noise，2026-09-16 E 变更 verify 实证）：JS/Java 的
+ * // 与 /* *\/ 注释区替换为等长空格（换行保留）——注释里的 `app.use("/api", router)`、
+ * `router.get("/api/xxx")`、`@GetMapping("/x")` 文档示例不再被全文正则当真路由（探针5 曾报
+ * 「GET /api/path、GET /api unused」假 advisory）。字符串字面量（' " `）原样保留（真路由在
+ * 字符串里）；正则字面量按字符串近似处理（端点正则里出现路由字符串形态极罕见，误掩概率低）。
+ * 保长度 = 索引/行号零漂移，lineOfIndex 与全部既有正则兼容。
+ * @param {string} content
+ * @returns {string} 等长掩码后内容
+ */
+function stripCommentsKeepLength(content) {
+  const src = String(content || '')
+  const out = src.split('')
+  let st = 'normal' // normal | block | sq | dq | tick
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i], n = src[i + 1]
+    if (st === 'normal') {
+      if (c === '/' && n === '/') {
+        // 行注释：掩到行尾（保留换行符本身）
+        let j = i
+        while (j < src.length && src[j] !== '\n') { out[j] = ' '; j++ }
+        i = j - 1
+      } else if (c === '/' && n === '*') {
+        out[i] = ' '; out[i + 1] = ' '
+        st = 'block'; i++
+      } else if (c === "'") st = 'sq'
+      else if (c === '"') st = 'dq'
+      else if (c === '`') st = 'tick'
+    } else if (st === 'block') {
+      if (c === '*' && n === '/') { out[i] = ' '; out[i + 1] = ' '; st = 'normal'; i++ }
+      else if (c !== '\n') out[i] = ' '
+    } else {
+      // 字符串内：转义跳过；闭合引号回 normal（内容原样保留）
+      if (c === '\\') i++
+      else if ((st === 'sq' && c === "'") || (st === 'dq' && c === '"') || (st === 'tick' && c === '`')) st = 'normal'
+    }
+  }
+  return out.join('')
+}
+
 /**
  * 从单个文件提取 FastAPI router 端点
  * 支持 APIRouter(prefix=...) 和 @router.get/post/put/delete/patch("/path")
@@ -73,7 +113,13 @@ export function extractFastApiEndpoints(filePath) {
  * @returns {Array<{ method: string, path: string, source: string, line: number }>}
  */
 export function extractExpressEndpoints(filePath) {
-  const content = readFileSync(filePath, 'utf8')
+  const rawContent = readFileSync(filePath, 'utf8')
+  // 注释掩码（坑 endpoint-extractor-selfdoc-noise，2026-09-16 E 变更 verify 实证：本模块自身
+  // JSDoc 示例 `app.use("/api", router)` / `router.get("/api/xxx")` 被全文正则当真路由——
+  // 探针5 报「GET /api/path、GET /api unused」假 advisory，agent 逐条裁定纯耗损）。掩码保长度
+  // 替换注释区为空格（换行保留）：字符串字面量不动（真路由在字符串里），索引/行号零漂移，
+  // 下游 lineOfIndex/正则全兼容。
+  const content = stripCommentsKeepLength(rawContent)
   const lines = content.split('\n')
   const endpoints = []
 
@@ -116,7 +162,9 @@ export function extractExpressEndpoints(filePath) {
  * @returns {Array<{ method: string, path: string, source: string, line: number }>}
  */
 export function extractSpringEndpoints(filePath) {
-  const content = readFileSync(filePath, 'utf8')
+  // 注释掩码同 Express（坑 endpoint-extractor-selfdoc-noise；Java 与 JS 注释语法同族 // /* */
+  // ——掩码器共用。注解本体不在注释内，掩码零影响；注释里的 @GetMapping 示例不再入面）
+  const content = stripCommentsKeepLength(readFileSync(filePath, 'utf8'))
   const lines = content.split('\n')
   const endpoints = []
 

package/src/foreign-declared.js

@@ -45,23 +45,32 @@ function getMainDirtySet(cwd) {
  * 变更 worktree 活性速查（.runtime/worktrees/<change>/meta.json）。
  * isolated=true：有存活隔离 worktree（meta 在、非 in-place、worktreePath 目录在）——
  * 其 WIP 在 worktree 内主仓 porcelain 不可见，整份 design 声明按在途处理。
- * @returns {Map<string, { isolated: boolean }>|null} null = 读取失败（fail-closed）
+ * 双根扫描（坑 platform-dual-root-fourth-consumer，2026-09-16 hunt 实证）：平台模式
+ * specBase=specRoot 下只挂跨仓 worktree，主仓 worktree 在项目侧 <cwd>/.sillyspec——单扫
+ * specBase 会把主仓 worktree 变更误判 stale → 其声明失效 → 文件被误归属当前变更（③类
+ * 噪音/误扣）。specBase 与 cwd 项目侧两目录都扫，按变更名合并（specBase 先入）。
+ * @returns {Map<string, { isolated: boolean }>|null} null = 两目录均读取失败（fail-closed）
  */
-function loadWorktreeLiveness(specBase) {
+export function loadWorktreeLiveness(specBase, cwd) {
   const map = new Map()
-  try {
-    const dir = join(specBase, '.runtime', 'worktrees')
-    for (const e of readdirSync(dir, { withFileTypes: true })) {
-      if (!e.isDirectory()) continue
-      try {
-        const meta = JSON.parse(readFileSync(join(dir, e.name, 'meta.json'), 'utf8'))
-        const isolated = Boolean(meta && meta.mode !== 'in-place-fallback'
-          && meta.worktreePath && existsSync(meta.worktreePath))
-        map.set(meta.changeName || e.name, { isolated })
-      } catch { /* 单条损坏跳过（该变更走主仓 dirty 判定） */ }
-    }
-  } catch { return null }
-  return map
+  const roots = [...new Set([specBase, join(cwd || process.cwd(), '.sillyspec')].filter(Boolean))]
+  let anyDirOk = false
+  for (const base of roots) {
+    try {
+      const dir = join(base, '.runtime', 'worktrees')
+      for (const e of readdirSync(dir, { withFileTypes: true })) {
+        if (!e.isDirectory()) continue
+        try {
+          const meta = JSON.parse(readFileSync(join(dir, e.name, 'meta.json'), 'utf8'))
+          const isolated = Boolean(meta && meta.mode !== 'in-place-fallback'
+            && meta.worktreePath && existsSync(meta.worktreePath))
+          map.set(meta.changeName || e.name, { isolated })
+        } catch { /* 单条损坏跳过（该变更走主仓 dirty 判定） */ }
+      }
+      anyDirOk = true
+    } catch { /* 该根不存在/不可读 → 试下一根 */ }
+  }
+  return anyDirOk ? map : null
 }
 
 /**
@@ -74,7 +83,7 @@ function loadWorktreeLiveness(specBase) {
 function filterStaleForeignDeclarations(foreign, cwd, specBase) {
   if (foreign.size === 0) return
   const dirty = getMainDirtySet(cwd)
-  const worktrees = loadWorktreeLiveness(specBase)
+  const worktrees = loadWorktreeLiveness(specBase, cwd)
   if (dirty === null && worktrees === null) return // 两个事实源全失败 → 原样保留
   for (const [file, owners] of [...foreign.entries()]) {
     const live = owners.filter(owner => {

package/src/hooks/worktree-guard.js

@@ -308,6 +308,8 @@ export {
   matchReadonlyWhitelist as _matchReadonlyWhitelistForTest,
   matchDangerBlacklist as _matchDangerBlacklistForTest,
   isSingleCommandReadonly as _isSingleCommandReadonlyForTest,
+  analyzeCrossRepoCd as _analyzeCrossRepoCdForTest,
+  CROSS_REPO_TEST_RE as _CROSS_REPO_TEST_REForTest,
 };
 /**
  * 从 sillyspec.db 读取 currentStage（直读 DB，task-10 废 gate-status.json 后为唯一来源）
@@ -834,6 +836,56 @@ export function shouldBlockWrite(filePath, cwd) {
   }
 }
 
+/**
+ * 跨仓命令锚点感知（known-issues 2026-09-16 登记「worktree 隔离期跨仓命令锚定错位」兑现）：
+ * EHS 三仓形态（主仓 + repos 注册兄弟仓）两处摩擦——①worktree 内 `cd ../<注册仓>` 解析到
+ * `.sillyspec/.runtime/worktrees/` 存储目录而非真实兄弟仓（锚点错位，静默跑错地方）；②
+ * verify 等非 execute/quick 阶段从主仓跑 `cd ../注册仓 && npx eslint` 属合法只读跨仓操作，
+ * 但 cd 不在只读白名单 → 整条进 stage 门禁拦截。
+ * 处置：①worktree cwd 本就全放行——不拦，只 stderr 纠偏留痕（真实兄弟仓路径）；②从严放行
+ * （cd 目标命中 repos 注册根 + 其余片段全部测试/lint 类 + 危险黑名单不沾），写类/混合维持
+ * 原判 fail-closed。
+ */
+const CROSS_REPO_TEST_RE = /^(?:npm (?:test|run test[\w:.-]*)|npx (?:eslint|tsc|jest|vitest|mocha|stylelint|prettier)(?:\s|$)|node --test)/i
+
+/**
+ * 解析复合命令中的 cd 目标并比对 repos 注册仓根。
+ * @param {string} command 原始命令
+ * @param {string} callerCwd 调用方 cwd（相对 cd 目标的解析基准之一）
+ * @param {string} projectRoot 主仓根（worktree 形态下的正确锚点基准）
+ * @param {boolean} inWorktree 调用方是否在 worktree 内（决定 ../ 的解析基准）
+ * @returns {{hits: Array<{key:string,repoRoot:string,resolved:string,target:string}>, segments: string[]}|null}
+ *   无 cd 段 / 无 repos 注册 / 无命中 → null
+ */
+function analyzeCrossRepoCd(command, callerCwd, projectRoot, inWorktree) {
+  const segments = splitCommandParts(command)
+  const cdTargets = []
+  for (const seg of segments) {
+    const m = seg.match(/^cd\s+([^\s&|;]+)/i)
+    if (m) cdTargets.push(m[1])
+  }
+  if (cdTargets.length === 0) return null
+  const repos = loadLocalConfig(projectRoot).repos
+  if (!repos || typeof repos !== 'object') return null
+  const hits = []
+  for (const t of cdTargets) {
+    // 双基准：shell 实际解析（callerCwd——worktree 内 ../ 即存储目录错位形态）与意图解析
+    // （worktree 形态按主仓根、主仓 cwd 即 shell 本身）。注册命中按意图基准；纠偏提示按
+    // 「shell 解析落在 worktree 存储目录」判定。
+    const shellResolved = path.isAbsolute(t) ? t : path.resolve(callerCwd, t)
+    const intended = path.isAbsolute(t) ? t : path.resolve(inWorktree ? projectRoot : callerCwd, t)
+    for (const [key, raw] of Object.entries(repos)) {
+      if (typeof raw !== 'string' || !raw) continue
+      const repoRoot = path.isAbsolute(raw) ? raw : path.resolve(projectRoot, raw)
+      if (intended === repoRoot || isPathInside(intended, repoRoot)) {
+        hits.push({ key, repoRoot, resolved: intended, shellResolved, target: t })
+        break
+      }
+    }
+  }
+  return hits.length > 0 ? { hits, segments } : null
+}
+
 /**
  * 判断 Bash 命令是否应被拦截
  * @param {string} command - Bash 命令字符串
@@ -846,8 +898,19 @@ function shouldBlockBash(command, cwd) {
   const callerCwd = cwd || process.cwd()
   const projectRoot = findProjectRoot(callerCwd)
 
-  // cwd 在 worktree 内 → 全部放行
-  if (isInsideRegisteredWorktree(callerCwd, projectRoot)) return { blocked: false }
+  // cwd 在 worktree 内 → 全部放行（跨仓锚点纠偏留痕：../注册仓 在 worktree 内解析到
+  // worktrees 存储目录——不拦只纠正，known-issues③）
+  if (isInsideRegisteredWorktree(callerCwd, projectRoot)) {
+    try {
+      const xr = analyzeCrossRepoCd(command, callerCwd, projectRoot, true)
+      for (const h of (xr && xr.hits) || []) {
+        if (isInsideWorktreeStorage(h.shellResolved, projectRoot)) {
+          console.error(`[sillyspec hook] ℹ️ 跨仓锚点纠偏：cd ${h.target} 在 worktree 内实际会解析到 ${h.shellResolved}（worktrees 存储目录，非真实兄弟仓）。注册仓 ${h.key} 的真实路径：${h.repoRoot}——跨仓测试/构建请改用真实路径。`)
+        }
+      }
+    } catch { /* 纠偏 fail-soft：解析异常不影响放行 */ }
+    return { blocked: false }
+  }
 
   // 阶段门禁（直读 sillyspec.db）
   const stage = readCurrentStage(projectRoot) || '(none)'
@@ -857,6 +920,16 @@ function shouldBlockBash(command, cwd) {
     const localConfig = loadLocalConfig(projectRoot)
     const extraReadonly = localConfig.worktreeHook?.readonlyCommands || localConfig['worktree-hook']?.readonlyCommands || []
     if (matchReadonlyWhitelist(command, extraReadonly)) return { blocked: false }
+    // 跨仓注册仓测试类放行（known-issues③）：verify 等阶段从主仓跑兄弟仓测试/lint 是合法
+    // 只读操作。从严三条件：cd 目标命中 repos 注册根 + 其余片段全部测试/lint 类 + 危险
+    // 黑名单不沾——写类/混合命令维持 stage 门禁原判（fail-closed）。
+    if (!matchDangerBlacklist(command)) {
+      const xr = analyzeCrossRepoCd(command, callerCwd, projectRoot, false)
+      if (xr && xr.segments.every(seg => /^cd\s+/i.test(seg) || CROSS_REPO_TEST_RE.test(seg))) {
+        console.error(`[sillyspec hook] 放行依据 = 跨仓注册仓（${xr.hits.map(h => h.key).join('、')}）测试/lint 类命令（known-issues③ 锚点感知，其余片段全测试类+黑名单不沾）`)
+        return { blocked: false }
+      }
+    }
     return {
       blocked: true,
       reason: buildStageHint(stage)