sillyspec 3.28.10 → 3.28.12

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/doctor-diagnostics.js

@@ -1125,6 +1125,144 @@ export function detectSelfMaintenanceTax(cwd, authoritySpecDir) {
   }
 }
 
+/**
+ * D14 归档完整性重扫（archive_integrity，2026-09-17 OpenSpec validate --archived 对标）。
+ *
+ * 为什么需要：归档前的完成门禁很严（review.json 驱动勾选 / Wave 断言 / verify 对账），
+ * 但目录搬进 changes/archive/ 后**没有任何机制回头看**——手工挪目录绕流程的自愈只在
+ * 下次 CLI 触碰时生效，归档后手改 tasks.md / 删 plan.md 无人发现。本维度补事后重扫：
+ *   ① 任务 checkbox 全勾（tasks.md 优先，回退 plan.md——读侧兼容同 D5/progress 口径；
+ *      归档后 runtime 工件已 prune，review.json 不可用，checkbox 是归档目录里唯一持久的完成面）
+ *   ② plan.md 在场（archive 自愈 findAlreadyArchivedDir 的基准文件）
+ *   ③ 注册表文件存在但读不了 → finding（OpenSpec #205 教训：读不了 ≠ 没任务，
+ *      检查不许在什么都没看的情况下静默通过）
+ * 语义：WARNING advisory 不阻断、只读无修复（钩子/门禁挂载是后续独立策略裁决）；
+ * 无 archive 目录 / 无 task 行 → pass（无任务视为完备，同 OpenSpec "nothing to complete"）。
+ */
+function detectArchiveIntegrity(cwd, authoritySpecDir) {
+  const base = { name: 'archive_integrity', label: '归档完整性重扫', safe_actions: [] };
+  if (!authoritySpecDir) {
+    return { ...base, pass: true, severity: null, findings: ['无权威 specDir，跳过'] };
+  }
+  const archiveDir = join(authoritySpecDir, 'changes', 'archive');
+  if (!existsSync(archiveDir)) {
+    return { ...base, pass: true, severity: null, findings: ['无 changes/archive 目录（未归档/新仓），跳过'] };
+  }
+  let entries;
+  try {
+    entries = readdirSync(archiveDir, { withFileTypes: true });
+  } catch (e) {
+    return { ...base, pass: false, severity: CHECK_SEVERITY.WARNING, findings: [`changes/archive 目录不可读（${e?.message || e}）——人工排查，不静默跳过`] };
+  }
+  const names = entries
+    .filter((d) => d.isDirectory() && !d.name.startsWith('.'))
+    .map((d) => d.name)
+    .sort();
+  if (names.length === 0) {
+    return { ...base, pass: true, severity: null, findings: ['changes/archive 为空（无已归档变更）'], archive_count: 0, offenders: [] };
+  }
+  const offenders = [];
+  for (const name of names) {
+    const dir = join(archiveDir, name);
+    const reasons = [];
+    // ② plan.md 在场性
+    const planPath = join(dir, 'plan.md');
+    const hasPlan = existsSync(planPath);
+    if (!hasPlan) reasons.push('plan.md 缺失（归档自愈基准文件）');
+    // ①③ 任务注册表：tasks.md 优先回退 plan.md；存在但不可读必须显式报（区分「缺席」与「读不了」）。
+    // 2026-08-20-task-truth-unify 之前的旧归档完成态勾在 plan.md（tasks.md 是留给后人的未勾任务清单）——
+    // tasks.md 有 checkbox 行但 0 勾、而 plan.md 有 ≥1 勾时，完成证据在 plan.md，切 plan.md 为完成源
+    // （真实仓首扫实证：2026-05-31-sqlite-migration tasks 0/15 + plan 15/15，43 份 offenders 大半为此误报）。
+    const tasksPath = join(dir, 'tasks.md');
+    const readRegistry = (p) => {
+      const content = readFileSync(p, 'utf8');
+      // 与 progress.js readPlanCheckboxStatus 同正则（task- 前缀锚定，x/X 计勾）
+      const re = /^\s*[-*]\s+\[([ xX])\]\s+task-\d+/gm;
+      let t = 0;
+      let c = 0;
+      let m;
+      while ((m = re.exec(content)) !== null) {
+        t++;
+        if (m[1] !== ' ') c++;
+      }
+      return { total: t, checked: c };
+    };
+    const regPath = existsSync(tasksPath) ? tasksPath : hasPlan ? planPath : null;
+    if (regPath) {
+      try {
+        let stat = readRegistry(regPath);
+        if (regPath === tasksPath && stat.total > 0 && stat.checked === 0 && hasPlan) {
+          try {
+            const planStat = readRegistry(planPath);
+            if (planStat.total > 0 && planStat.checked > 0) stat = planStat;
+          } catch { /* plan.md 不可读 → 维持 tasks.md 0 勾口径（本就报未勾） */ }
+        }
+        if (stat.total > 0 && stat.checked < stat.total) {
+          reasons.push(`${stat.total - stat.checked} 个任务未勾（${stat.checked}/${stat.total}）`);
+        }
+      } catch (e) {
+        reasons.push(`任务注册表不可读（${relative(archiveDir, regPath)}：${e?.code || e?.message || e}）`);
+      }
+    }
+    if (reasons.length > 0) offenders.push({ name, reasons });
+  }
+
+  // 豁免账本（2026-09-17 收尾裁决）：老归档历史形态（早于 plan.md 流程的手工归档/远古命名）逐份豁免——
+  // 照 docs-check skip 清单先例（39 处历史快照冻结），不伪造 plan.md 篡改历史；账本外继续亮红；
+  // 纪律：新欠账禁止入账（入账须变更流程裁决）；账本解析失败按无豁免 fail-safe。
+  const exemptPath = join(authoritySpecDir, 'archive-integrity-exempt.yaml');
+  let exemptNames = new Set();
+  const exemptNotes = [];
+  if (existsSync(exemptPath)) {
+    try {
+      const doc = jsYaml.load(readFileSync(exemptPath, 'utf8'));
+      const entries = Array.isArray(doc && doc.entries) ? doc.entries : [];
+      exemptNames = new Set(entries.filter((e) => e && typeof e.name === 'string').map((e) => e.name));
+    } catch (e) {
+      exemptNotes.push(`豁免账本解析失败（${e?.message || e}）——按无豁免处理，红灯保持`);
+    }
+  }
+  const exempted = offenders.filter((o) => exemptNames.has(o.name));
+  const effective = offenders.filter((o) => !exemptNames.has(o.name));
+  const staleExemptions = [...exemptNames].filter((n) => !offenders.some((o) => o.name === n));
+  if (exempted.length > 0) {
+    exemptNotes.push(`${exempted.length} 份豁免在案（历史形态，账本 archive-integrity-exempt.yaml）`);
+  }
+  if (staleExemptions.length > 0) {
+    exemptNotes.push(`${staleExemptions.length} 条豁免已失效（对应归档不再欠账）可清理：${staleExemptions.slice(0, 5).join(', ')}${staleExemptions.length > 5 ? ' …' : ''}`);
+  }
+
+  if (effective.length === 0) {
+    const findings = [`${names.length} 份归档完整（任务全勾 + plan.md 在场${exempted.length > 0 ? `，另有 ${exempted.length} 份豁免在案` : ''}）`];
+    findings.push(...exemptNotes);
+    return {
+      ...base,
+      pass: true,
+      severity: null,
+      findings,
+      archive_count: names.length,
+      offenders: [],
+      exempted_count: exempted.length,
+      stale_exemptions: staleExemptions,
+    };
+  }
+  const findings = effective.slice(0, 10).map((o) => `${o.name}：${o.reasons.join('；')}`);
+  if (effective.length > 10) findings.push(`…还有 ${effective.length - 10} 份`);
+  findings.push(...exemptNotes);
+  findings.push('语义：归档=全勾终态；未勾/缺文件多为归档后手改或手工搬目录绕流程——git log 定位改动来源，doctor 只读不自动修');
+  return {
+    ...base,
+    pass: false,
+    severity: CHECK_SEVERITY.WARNING,
+    findings,
+    safe_actions: [{ dimension: 'archive_integrity', action: 'manual_inspect', risk: 'manual_edit', rationale: '归档完整性破损', next_step: '逐份核对 offenders：git log --follow .sillyspec/changes/archive/<name>/tasks.md 定位改动者与意图，确属历史遗留走变更流程裁决入豁免账本（新欠账禁止入账），勿改语义' }],
+    archive_count: names.length,
+    offenders: effective,
+    exempted_count: exempted.length,
+    stale_exemptions: staleExemptions,
+  };
+}
+
 /**
  * renderDoctorSummary（FR-01，全新输出契约——2026-09-09-doctor-noai）：逐维
  * ✅/⚠️/❌ + label + findings 首行 + safe_actions 提示行。顶层非 --json 命令与
@@ -1177,7 +1315,9 @@ export async function runDoctorDiagnostics({ cwd }) {
   const applyManifestDrift = detectApplyManifestDrift(cwd, authoritySpecDir)
   // task-02（2026-09-15-tax-governance）：自维护税面（活跃 tally 列示 + 台账聚合 + 税重阈值，只读）
   const selfMaintenanceTax = detectSelfMaintenanceTax(cwd, authoritySpecDir)
-  const dimensions = [multiDb, pointerHealth, changesSplit, changeDb, executeMismatch, docBloat, repoNativeChain, lifecycleDoc, worktreeHealth, buildEnv, mcpEndpoints, applyManifestDrift, selfMaintenanceTax];
+  // D14（2026-09-17 archive-rescan，OpenSpec validate --archived 对标）：归档完整性事后重扫（只读 WARNING）
+  const archiveIntegrity = detectArchiveIntegrity(cwd, authoritySpecDir)
+  const dimensions = [multiDb, pointerHealth, changesSplit, changeDb, executeMismatch, docBloat, repoNativeChain, lifecycleDoc, worktreeHealth, buildEnv, mcpEndpoints, applyManifestDrift, selfMaintenanceTax, archiveIntegrity];
 
   return {
     dimensions,

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)