sillyspec 3.28.10 → 3.28.11

package/src/change-risk-profile.js

@@ -301,6 +301,33 @@ export function detectChangeRisk({ designContent = '', planContent = '', changed
   return { level, triggers, suppressedTriggers, requiredVerification }
 }
 
+// ============ 回执来源分类打标（X-10 / D-002 / D-006，2026-09-17-pass-cap-semantics task-02） ============
+//
+// EHS 实证（D-002）：mvn compile + JUnitCore 纯单测的三条 log 通过了集成回执四条件校验——
+// 单测/编译类回执被当成集成实测。打标口径：只认回执 command 的命令来源声明（quality-scan
+// 记录的命令与 verify_precedents 声明同思想），不解析日志内容猜测（X-10）；未定类默认
+// 'build'（fail-closed 侧：build/unit 回执不构成「集成实测已跑」绿判据，宁可触发封顶要求
+// handover——stage-contract 侧 validatePassEligibility（evaluatePassEligibility 纯函数 +
+// resolveFactsExpected 判定）消费本口径对结论=PASS 封顶；verify-probes producer 侧
+// classifyReceiptCommandSource（facts.integrationRan 判定）与本分类同族口径，两处正则族
+// 保持同步演进）。smoke 冒烟命令族计 cross-layer（D-006 退役判据：批次 C commands.smoke
+// 落地后由 smoke 回执一票判定「集成实测已跑」——起服务冒烟即跨层实测，不得默认 build 误拦金路径）。
+const RECEIPT_SOURCE_CROSS_LAYER_RE = new RegExp([
+  '\\bcurl\\b', '\\bwget\\b', '\\bhttpie\\b', '\\bInvoke-WebRequest\\b', '\\bInvoke-RestMethod\\b',
+  '\\biwr\\b', '\\birm\\b', 'https?://',
+  'spring-boot:run', '\\bjava\\b[^|\\n]*\\s-jar\\b',
+  '\\b(?:npm|pnpm|yarn|bun)\\s+(?:run\\s+)?(?:dev|start|serve|smoke)\\b',
+  '\\bdotnet\\s+run\\b', '\\bflask\\s+run\\b', '\\buvicorn\\b', '\\bgunicorn\\b',
+  '\\b(?:nc|netcat|telnet|socat)\\b',
+].join('|'), 'i')
+const RECEIPT_SOURCE_UNIT_RE = /\bJUnitCore\b|\bnode\s+--test\b|\bmocha\b|\bjest\b|\bvitest\b|\bpytest\b|\bphpunit\b|\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?test\b/i
+function classifyReceiptSourceTag(command) {
+  const cmd = String(command || '')
+  if (RECEIPT_SOURCE_CROSS_LAYER_RE.test(cmd)) return 'cross-layer'
+  if (RECEIPT_SOURCE_UNIT_RE.test(cmd)) return 'unit'
+  return 'build'
+}
+
 /**
  * 检查 verify-result.md 是否包含集成验证证据
  *
@@ -308,6 +335,10 @@ export function detectChangeRisk({ designContent = '', planContent = '', changed
  * CLI 结构化回执文本（如 verify-services.receipt.json 的服务回收回执）——它随 verifyContent
  * 一起参与 literals 匹配，agent 真实起过服务且 CLI 回收过（有回执）时不再依赖其自然语言
  * 措辞恰好含字面词，表述差异不再误拦。
+ *
+ * opts.sourceTag（X-10 / D-006，2026-09-17-pass-cap-semantics task-02）：可选回执来源声明
+ * （'cross-layer' | 'build' | 'unit'），透传给 auditRuntimeReceipt 优先于按 command 就地
+ * 分类；非法值忽略。build/unit 回执不作集成实测绿判据（缺省按 command 分类，未定类 build）。
  */
 export function checkIntegrationEvidence(verifyContent, requiredVerification, opts = {}) {
   const errors = []
@@ -333,7 +364,7 @@ export function checkIntegrationEvidence(verifyContent, requiredVerification, op
     const hasGreen = greenReceipts.length > 0
     if (needsIntegration && !hasGreen) {
       const bad = receiptAudit.filter(a => !a.green)
-      errors.push(`integration-critical 变更无绿回执（${bad.length} 条回执校验不过：${bad.map(a => a.reason).join('；') || '无有效回执'}）——绿判据：log 存在 × mtime ∈ verify 窗口 × 日志无失败签名 × exit 0`)
+      errors.push(`integration-critical 变更无绿回执（${bad.length} 条回执校验不过：${bad.map(a => a.reason).join('；') || '无有效回执'}）——绿判据：log 存在 × mtime ∈ verify 窗口 × 日志无失败签名 × exit 0 × 来源 cross-layer（build/unit 回执不作集成实测判据，D-006）`)
     }
     if (needsLogEvidence && !hasGreen) {
       errors.push('integration-critical 变更的回执未通过一致性校验（Runtime Evidence 等价物）')
@@ -394,9 +425,19 @@ export function checkIntegrationEvidence(verifyContent, requiredVerification, op
  * 单条回执一致性校验（FR-04 绿判据）。噪声剔除：签名行首匹配 + 剔除「0 errors」类良性行
  * （本仓 verify-postcheck.js 测试输出解析先例同款）。fail-soft：校验依赖缺失（opts 无
  * cwd/verifyStartAt）时只核 exitCode 与日志可读性，不假装跑了文件校验。
+ *
+ * opts.sourceTag（X-10 / D-006，2026-09-17-pass-cap-semantics task-02）：可选回执来源声明，
+ * 缺省按回执 command 来源就地分类（classifyReceiptSourceTag），未定类默认 'build'（向后
+ * 兼容的 fail-closed 缺省）；sourceTag ∈ {build, unit} 的回执不作集成实测绿判据（四条件
+ * 全过也只到 non-green，reason 点名来源）——verify-postcheck 不在本调用链上，不受影响。
  */
 function auditRuntimeReceipt(r, opts) {
-  const out = { claim: r && r.claim, logPath: r && r.logPath, green: false, logExists: null, mtimeInWindow: null, failSignatures: 0, exitCode: r && typeof r.exitCode === 'number' ? r.exitCode : null, reason: '' }
+  const out = { claim: r && r.claim, logPath: r && r.logPath, sourceTag: null, green: false, logExists: null, mtimeInWindow: null, failSignatures: 0, exitCode: r && typeof r.exitCode === 'number' ? r.exitCode : null, reason: '' }
+  // 打标依据 = 命令来源声明（不解析日志内容，X-10）：opts.sourceTag 调用方声明源优先，
+  // 否则按回执 command 分类；非法/缺省走分类，未定类默认 build。
+  const declaredSource = opts && typeof opts.sourceTag === 'string'
+    && ['cross-layer', 'build', 'unit'].includes(opts.sourceTag) ? opts.sourceTag : null
+  out.sourceTag = declaredSource || classifyReceiptSourceTag(r && r.command)
   if (!r || !r.logPath) { out.reason = '回执缺 logPath'; return out }
   let content = null
   try {
@@ -424,7 +465,14 @@ function auditRuntimeReceipt(r, opts) {
   }
   if (out.failSignatures > 0) { out.reason = `日志含 ${out.failSignatures} 行失败签名（行首 error/exception/traceback/fatal，已剔除良性计数行）`; return out }
   if (out.exitCode !== 0) { out.reason = `exitCode=${out.exitCode}（非 0 不可用作在场证据）`; return out }
+  // 来源门（D-002/D-006，2026-09-17-pass-cap-semantics task-02）：四条件全过但来源 build/unit
+  // （编译/单测/构建类命令）→ 不作集成实测绿判据（EHS 实证口径），排在前置硬伤（缺日志/
+  // 出窗/签名/exit≠0）之后不抢 reason 优先级。
+  if (out.sourceTag !== 'cross-layer') {
+    out.reason = `回执来源 ${out.sourceTag}（command：${(r && r.command) || ''}）不构成「集成实测已跑」——build/unit 类命令（编译/单测/构建）不作集成绿判据（D-006）。出路：提供跨层实测回执（起服务/HTTP/进程对进程/smoke 冒烟命令），或降级 PASS WITH NOTES 并在「## 移交项（结构化）」承载缺口`
+    return out
+  }
   out.green = true
-  out.reason = '绿回执（log 存在 × mtime 窗口 × 无失败签名 × exit 0）'
+  out.reason = '绿回执（log 存在 × mtime 窗口 × 无失败签名 × exit 0 × 来源 cross-layer）'
   return out
 }

package/src/config-schema.js

@@ -152,6 +152,15 @@ export const LOCAL_YAML_SCHEMA = {
         { 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: 'gate_snapshot',
+      title: '门禁隔离快照 copy 面',
+      note: '门禁快照（gate-snapshot）= HEAD worktree + 会话文件 overlay + 环境目录 junction——gitignored 生成物（api-types/generated 类）不进 HEAD 也不在会话集，快照内 lint/test 环境性假败（2026-09-16 驾驭小结④，friction5-hardening R4 / D-002@v1）。按本清单在快照构建期从主仓 junction 链接补齐（失败回退复制）；快照内 overlay 已覆盖的同名路径跳过（本变更最新态优先）。⚠️ junction 是活链接：快照内再跑生成命令会写穿到主仓该目录。',
+      keys: [
+        { path: 'gate_snapshot.copy', type: 'array', optional: true, status: 'live', readers: ['createGateSnapshot (src/run/gate-snapshot.js)'], desc: '门禁隔离快照的生成物/额外路径 copy 面（元素 string，相对仓根）：HEAD 快照缺 gitignored 生成物导致 lint/test 环境性假败；声明后快照构建期从主仓 junction 链接（失败回退复制）。⚠️ junction 是活链接，快照内再跑生成命令会写穿到主仓该目录。未配置/空清单 = 全段空转零行为变化。', example: 'gate_snapshot:\n  copy:\n    - src/generated' },
+        { path: 'gate_snapshot.commands', type: 'array', optional: true, status: 'live', readers: ['parseGateSnapshotCommands + runGateSnapshotCommands (src/run/gate-snapshot.js — createGateSnapshot 环境预检后 copy 面前)'], desc: '门禁隔离快照的命令面（元素 string）：快照构建期在环境目录链接后、copy 面前于快照根逐条执行（cwd=快照根、300s/条超时帽、非零退出/超时只 warn 继续——fail-open 不作废快照），产出「本仓应然态」生成物，收口主仓生成物缺失/过期（fresh clone 未跑 postinstall / build-id 类产物）时快照内全量 lint/test 必挂的坑（D-002@v2，2026-09-17-feedback-hardening FR-01）。⚠️ 环境目录（node_modules/venv）是活链接，命令写它们会穿透主仓——只放生成物命令（npm run gen:build-id 类），不放 install/build 全家桶。未配置 = 全段空转零行为。', example: 'npm run gen:build-id' },
+      ],
+    },
     {
       id: 'auto_mode',
       title: '变更规模自动分类',
@@ -379,6 +388,18 @@ worktree-hook:
 #   supplyFiles:
 #     - src/build-id.ts
 
+# ── 门禁隔离快照 copy 面（HEAD 快照缺 gitignored 生成物 → 快照内 lint/test 环境性假败；构建期从主仓 junction 补齐）──
+# 相对仓根路径列表；失败回退复制；快照内 overlay 已覆盖的同名路径跳过。
+# ⚠️ junction 是活链接：快照内再跑生成命令会写穿到主仓该目录。
+# commands 面（D-002@v2）：快照构建期在快照根逐条执行的生成物命令（postinstall/build-id 类，
+# 产出本仓应然态；300s/条超时帽，失败 warn 继续）。⚠️ 命令不得改写 node_modules/venv 等
+# 环境目录（活链接，写穿透主仓）——只放生成物命令。
+# gate_snapshot:
+#   copy:
+#     - src/generated
+#   commands:
+#     - npm run gen:build-id
+
 # ── 变更规模自动分类（sillyspec run auto 时按需求描述强制 quick/full；正则数组，i 大小写无关）──
 auto_mode:
   force_full_patterns:

package/src/design-facts.js

@@ -332,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('## 接口定义')
@@ -458,22 +459,58 @@ export function validateDesignFileList({ changeDir, cwd } = {}) {
       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 变更可无清单）'] }
       }
-      checkAgainstRoot(cwd, entries.map(e => e.path), '主仓')
+      // 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 }
     }
 
-    // 有段头：逐段按其仓根核验。跨仓注册表读侧口径 = <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, '主仓')

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)