sillyspec 3.32.3 → 3.32.5

package/README.md

@@ -85,7 +85,7 @@ SillySpec 进度库使用 SQLite 持久化（基于 Node.js 内置的 `node:sqli
 
 **也可以跳过完整流程：**
 
-- 小改动：`/sillyspec:quick "修复 xxx"`
+- 小改动：`/sillyspec:flow "修复 xxx"`
 - 不确定做什么：`/sillyspec:explore`
 - 中断恢复：`/sillyspec:resume`
 - 不知道下一步：`/sillyspec:continue`
@@ -112,7 +112,7 @@ SillySpec 进度库使用 SQLite 持久化（基于 Node.js 内置的 `node:sqli
 | `/sillyspec:status` · `/sillyspec:state` | 查看进度 / 当前工作状态 |
 | `/sillyspec:continue` | 自动判断并执行下一步 |
 | `/sillyspec:explore` | 自由思考：画图、讨论、调研、HTML 原型 |
-| `/sillyspec:quick` | 快速模式：跳过完整流程 |
+| `/sillyspec:flow` | 轻量变更（默认快道）：需求明确的小改动两步收口 |
 | `/sillyspec:resume` | 恢复工作（支持大模块阶段进度） |
 | `/sillyspec:doctor` | 项目自检与状态修复 |
 | `/sillyspec:commit` | 智能提交 |
@@ -122,7 +122,7 @@ SillySpec 进度库使用 SQLite 持久化（基于 Node.js 内置的 `node:sqli
 ## CLI 命令
 
 ```bash
-sillyspec run <stage>            执行阶段（auto/brainstorm/plan/execute/verify/archive/scan/quick/explore）
+sillyspec run <stage>            执行阶段（auto/brainstorm/plan/execute/verify/archive/scan/explore）
 sillyspec run <stage> --done     完成当前步骤并推进到下一步
 sillyspec run <stage> --status   查看阶段进度
 sillyspec progress show          显示当前项目状态
@@ -140,7 +140,7 @@ sillyspec change-delete <变更名>    删除变更（DB status=deleted 与归
 **第一层：护城河（外部状态，模型能力不可替代）**
 
 - **多 agent 并发控制** — 会话/变更/worktree 三级隔离；文件锁 ID 分配 + 双占用 fail-closed 硬拦；`--files` 边界声明切分"这是谁改的"；`--done` 前并发写预检告警他者未提交改动；平台同步乐观锁（base_ts + 身份 + 服务器权威钟）+ 冲突血统归属（自回声不误报）
-- **实测验收门禁** — verify / quick 收尾时 CLI **亲自执行** test / lint 与 agent 自报对账，不符即阻断回滚；docHash 重算比对 + git 提交证据交叉对账防伪造；门禁跑在隔离快照，不受并行会话脏文件污染
+- **实测验收门禁** — verify 收尾时 CLI **亲自执行** test / lint 与 agent 自报对账，不符即阻断回滚；docHash 重算比对 + git 提交证据交叉对账防伪造；门禁跑在隔离快照，不受并行会话脏文件污染
 - **持久账本 + 断点恢复** — SQLite（node:sqlite）单一进度源，进度/决策/审批答复全落库，跨会话跨天续跑；quicklog 四字段结构化台账可检索
 - **跨仓变更管理** — task 卡声明 `repo:` 字段即可管理跨仓任务：同构 worktree 隔离、base 锚快照、apply 永不覆盖用户在途改动
 

package/SKILL.md

@@ -51,7 +51,6 @@ Claude Code / Cursor / Codex / OpenCode / OpenClaw / Gemini 通用。
 | `/sillyspec:continue` | 自动判断并执行下一步 |
 | `/sillyspec:explore` | 自由思考模式 |
 | `/sillyspec:flow` | 轻量变更（默认快道）：flow start → 干活 → flow done |
-| `/sillyspec:quick` | （已退役，重定向到 flow）仅存量在途会话收尾 |
 | `/sillyspec:resume` | 恢复工作 |
 | `/sillyspec:doctor` | 项目自检 |
 | `/sillyspec:commit` | 智能提交 |
@@ -70,7 +69,6 @@ sillyspec run execute         执行开发阶段（子代理并行 + worktree
 sillyspec run verify          执行验证阶段
 sillyspec run archive         执行归档阶段
 sillyspec flow start/done/status  轻量变更（默认快道，2 次调用收口）
-sillyspec run quick           （已退役，仅存量在途会话 --done/--cancel 收尾）
 sillyspec run explore         自由探索
 sillyspec progress show       显示当前项目状态
 sillyspec setup               安装推荐 MCP 工具
@@ -81,12 +79,12 @@ sillyspec init                初始化（零交互，自动检测工具）
 
 **护城河层（外部状态，模型能力不可替代）**
 - **多 agent 并发控制** — 会话/变更/worktree 三级隔离；文件锁 ql-ID 分配 + 双占用 fail-closed 硬拦；边界声明归属切分（窗口∩声明）；并发写预检告警；平台乐观锁（base_ts + 身份头 + 服务器权威钟）
-- **实测验收门禁** — verify/quick 收尾时 CLI 亲自执行 test/lint 与自报对账，不符即阻断回滚；docHash 重算 + git 证据交叉对账防伪造；门禁跑在隔离快照里不受并行会话脏文件污染
+- **实测验收门禁** — verify 收尾时 CLI 亲自执行 test/lint 与自报对账，不符即阻断回滚；docHash 重算 + git 证据交叉对账防伪造；门禁跑在隔离快照里不受并行会话脏文件污染
 - **持久账本 + 断点恢复** — SQLite 单一进度源，进度/决策/审批答复全落库，跨会话跨天续跑；quicklog 四字段结构化台账
 - **跨仓变更管理** — task 卡声明 `repo:` 字段，跨仓同构 worktree 隔离，base 锚快照，apply 不覆盖用户在途改动
 
 **确定性对账层（机械核验，零模型轮次）**
-- **范围对账** — 计划改动 × 实际改动三态对账（planned/unplanned/untouched），execute/verify/archive/quick 四处收尾注入
+- **范围对账** — 计划改动 × 实际改动三态对账（planned/unplanned/untouched），execute/verify/archive 三处收尾注入
 - **API 契约矩阵** — provider/consumer 识别、endpoint 工件提取、前后端 API parity 对账
 - **文档一致性棘轮** — 源码引用真实性校验（HEAD 模式），失败数只降不升
 - **noAI 下沉 / IR 事实层** — 机械轮次下沉 CLI（骨架预生成、注入、代算对账），判断层留给 agent；同一契约清单事前渲染预览、事后引擎核验

package/package.json

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

package/src/command-cards.js

@@ -10,7 +10,7 @@ import { writeAtomicSync } from './fs-atomic.js'
 
 export const COMMAND_CARD_TARGETS = { zcode: '.zcode/commands/sillyspec', claude: '.claude/commands/sillyspec' }
 // flow=轻量变更默认道入口卡（2026-09-25-quick-channel-retire 配套：quick 退役后快道首次有卡）
-export const COMMAND_CARD_NAMES = ['flow', 'run-brainstorm', 'run-plan', 'run-execute', 'run-verify', 'run-archive', 'run-quick', 'status']
+export const COMMAND_CARD_NAMES = ['flow', 'run-brainstorm', 'run-plan', 'run-execute', 'run-verify', 'run-archive', 'status']
 
 const ANCHOR_TAIL_RE = /\n?<!-- sillyspec-card: v(\S+) sha256=([0-9a-f]{64}) -->\s*$/
 const sha256 = (s) => createHash('sha256').update(s, 'utf8').digest('hex')

package/src/config-schema.js

@@ -157,6 +157,7 @@ export const LOCAL_YAML_SCHEMA = {
       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' },
+        { path: 'worktree.crossPlacement.<repoKey>', type: 'string', optional: true, status: 'live', readers: ['readCrossPlacementConfig + resolvePlacementRoot (src/cross-placement.js) → ensureCrossWorktrees 落位 (src/worktree-cross.js)'], desc: '跨仓 worktree 按仓落位根目录（坑 cross-wt-toolchain-split：主仓在 WSL /root、跨仓在 /mnt/<盘>/ Windows 盘时，默认落位与该仓构建工具链分居互不可访文件系统，隔离形同虚设——2026-10-10 fire-equipment D-007 实证）。worktree 落 <目录>/<change>--<repoKey>；相对路径相对主仓根解析；落位根在跨仓仓根内 = 配置错拒绝创建；落位注册表 cross-placements.json 保 meta/list/cleanup/verify 对账全链寻回。缺省 = 默认公式 <specBase>/.runtime/worktrees/（零回归）。【推荐迁移】repos 条目内联 worktree 子键（repos.<key>: {path: <仓根>, worktree: <落位根>}，2026-10-10 配置简化）——优先级 repos 内联 > 本键 > 默认；本键兼容保留不废。', example: '/mnt/e/sillyspec-worktrees' },
         { path: 'worktree.policy.adopt_branch', type: 'boolean', optional: true, status: 'live', readers: ['readWorktreePolicy (src/worktree-policy.js) → WorktreeManager.create 分支冲突守卫 (src/worktree.js)'], desc: '分支已存在冲突的选择记忆：true = 自动收编既有分支（等效常备 --adopt-branch，meta 记 adoptViaPolicy 留痕）。缺省 false = 既有三选一 fail-closed 菜单。显式 flag 优先于 policy。', example: 'true' },
         { path: 'worktree.policy.apply_overlap', type: 'enum', values: ['manual', 'force', 'skip'], optional: true, status: 'live', readers: ['readWorktreePolicy (src/worktree-policy.js) → applyWorktree guard 相交拦截 (src/worktree-apply.js)'], desc: 'apply 与活跃 quick 会话在途声明相交时的处置记忆：manual（缺省）= 既有 fail-closed 报错；force = 放行并留痕（overlapForced.via 记 policy 来源）；skip = 无人值守软跳过（同 autoApply 路径）。--force 显式 flag 优先。', example: 'manual' },
         { path: 'worktree.policy.stash_dirty', type: 'boolean', optional: true, status: 'live', readers: ['readWorktreePolicy (src/worktree-policy.js) → applyWorktree 4.4 stash 段 (src/worktree-apply.js)'], desc: '主仓在途改动自动 stash 的选择记忆：true = 等效常备 --stash-dirty（stash SHA 显著打印 + 失败绝不 drop）。缺省 false = 显式 flag opt-in。', example: 'false' },
@@ -412,6 +413,13 @@ dispatch:
 #     # adopt_branch: true    # 分支已存在冲突自动收编（等效常备 --adopt-branch）
 #     # apply_overlap: manual # manual=fail-closed（缺省）| force=放行留痕 | skip=软跳过
 #     # stash_dirty: false    # true=主仓在途改动自动 stash（等效常备 --stash-dirty）
+#   crossPlacement:          # 跨仓 worktree 按仓落位（坑 cross-wt-toolchain-split：主仓 WSL + 跨仓
+#     # urgent: /mnt/e/wt    #   Windows 盘时工具链够不着默认落位——配到跨仓工具链可达的目录）
+#                            #   ↑推荐改用 repos 条目内联（一处声明注册+落位）：
+#                            #   repos:
+#                            #     urgent:
+#                            #       path: /mnt/e/Java/crrc/qmdp/urgent
+#                            #       worktree: /mnt/e/sillyspec-worktrees
 
 # ── 测试策略（2026-09-26-dynamic-test-inference 起）──
 # 缺省=动态子集：本变更测试 ∪ FR 关联回归（active FR 覆盖面∩触碰文件→绑定 tests）∪ import 依赖，

package/src/cross-placement.js

@@ -0,0 +1,246 @@
+/**
+ * cross-placement.js — 跨仓 worktree 落位配置 / 注册表 / 路径解析（零依赖叶子模块）
+ *
+ * 坑 cross-wt-toolchain-split（2026-10-10 用户实证，fire-equipment D-007）：跨仓 worktree 固定
+ * 落位主仓 specBase 下——主仓在 WSL /root、跨仓在 Windows 盘时，worktree 与该仓唯一构建工具链
+ * 分居互不可访文件系统，隔离形同虚设（agent 被迫绕开 worktree 回主副本直写主干）。
+ *
+ * 本模块承载三件事：
+ *   1. worktree.crossPlacement 配置读取（local.yaml，块式/inline 双形态）；
+ *   2. 落位注册表 cross-placements.json（create 写 / cleanup 删，read-modify-merge 原子写）——
+ *      挪位后 listCrossWorktreeMetas/cleanup/verify 对账仍可寻址；
+ *   3. crossWorktreePath(placementRoot?) 路径公式 + resolveCrossWorktreePath（注册表优先、公式兜底）。
+ *
+ * 依赖纪律（评审吸收①）：本模块只 import fs/path/fs-atomic——worktree-cross.js 与
+ * run/multi-repo-context.js 都 import 本模块。multi-repo-context 此前刻意不 import worktree-cross
+ * （经 run/shared 的既有环），落位逻辑下沉叶子模块后两侧共用不引新环。
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve as resolvePath, isAbsolute, dirname } from 'path';
+import { writeAtomicSync } from './fs-atomic.js';
+
+const PLACEMENT_REGISTRY_FILE = 'cross-placements.json';
+
+/** 跨仓 worktree 目录名（默认落位与自定义落位同形态——isCrossWorktreeDir 的双连字符判定依赖它） */
+export function crossWorktreeDirName(changeName, repoKey) {
+  return `${changeName}--${repoKey}`;
+}
+
+/**
+ * 路径公式：默认落位 <specBase>/.runtime/worktrees/<change>--<repoKey>；
+ * placementRoot 给定时 <placementRoot>/<change>--<repoKey>（与默认同目录名形态）。
+ * @param {string} specBase 主仓 spec 根（<主仓>/.sillyspec）
+ * @param {string} changeName
+ * @param {string} repoKey
+ * @param {string|null} [placementRoot] 已解析的落位根目录（null/缺省走默认公式——三参调用零回归）
+ */
+export function crossWorktreePath(specBase, changeName, repoKey, placementRoot = null) {
+  const dirName = crossWorktreeDirName(changeName, repoKey);
+  if (placementRoot) return join(placementRoot, dirName);
+  return join(specBase, '.runtime', 'worktrees', dirName);
+}
+
+/**
+ * 解析 crossPlacement 配置值为落位根目录：相对路径相对主仓根解析；拒绝 .. 逃逸出主仓根
+ * 之外的形态不在此处判（主仓根外合法——/mnt/e/wt-root 本就在主仓外），只归一绝对路径。
+ * @param {string} raw local.yaml 配置原文
+ * @param {string} mainRoot 主仓根（相对路径解析基准）
+ * @returns {string} 绝对落位根
+ */
+export function resolvePlacementRoot(raw, mainRoot) {
+  const trimmed = String(raw || '').trim().replace(/^['"]|['"]$/g, '');
+  if (isAbsolute(trimmed)) return resolvePath(trimmed);
+  return resolvePath(mainRoot, trimmed);
+}
+
+/**
+ * 读主仓 local.yaml 的 worktree.crossPlacement 段 → Map<repoKey, 原始配置值>。
+ * 兼容两种写法（沿 worktree.js readSupplyFilesConfig / hooks/worktree-guard.js parseSimpleYaml
+ * 的轻量手写风格，不引 yaml 依赖）：
+ *   worktree:
+ *     crossPlacement:
+ *       urgent: /mnt/e/wt-root        # 块式（indent 4）
+ *   worktree:
+ *     crossPlacement: {urgent: /mnt/e/wt-root, front: D:/wt}   # inline flow
+ * 文件缺失/段缺失/解析异常 → 空 Map（fail-open，落位步空转走默认公式）。
+ * @param {string} mainCwd 主仓根
+ * @returns {Map<string, string>}
+ */
+export function readCrossPlacementConfig(mainCwd) {
+  const out = new Map();
+  let content;
+  try {
+    content = readFileSync(join(mainCwd, '.sillyspec', 'local.yaml'), 'utf8');
+  } catch {
+    return out;
+  }
+  const stripQuotes = (v) => (
+    v.length >= 2 && ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) ? v.slice(1, -1) : v
+  );
+  let inWorktree = false;
+  let inCrossPlacement = false;
+  for (const rawLine of content.split('\n')) {
+    const noComment = rawLine.replace(/\s+#.*$/, ''); // 尾注释剥离（与 worktree-guard 同口径）
+    const trimmed = noComment.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const indent = noComment.length - noComment.trimStart().length;
+    if (indent === 0) {
+      inWorktree = /^worktree:\s*$/.test(trimmed);
+      inCrossPlacement = false;
+      continue;
+    }
+    if (!inWorktree) continue;
+    if (indent === 2) {
+      const m = trimmed.match(/^crossPlacement:\s*(.*)$/);
+      if (!m) { inCrossPlacement = false; continue; }
+      inCrossPlacement = true;
+      const rest = m[1].trim();
+      // inline flow 形态：{urgent: /a, front: D:/b}——逗号拆（值内逗号不支持，落位路径含逗号用块式）
+      if (rest.startsWith('{') && rest.endsWith('}')) {
+        for (const part of rest.slice(1, -1).split(',')) {
+          const kv = part.split(':');
+          if (kv.length >= 2) {
+            const k = kv[0].trim();
+            const v = stripQuotes(kv.slice(1).join(':').trim());
+            if (k && v) out.set(k, v);
+          }
+        }
+        inCrossPlacement = false; // inline 一行吃尽
+      }
+      continue;
+    }
+    if (inCrossPlacement && trimmed.includes(':')) {
+      const idx = trimmed.indexOf(':');
+      const k = trimmed.slice(0, idx).trim();
+      const v = stripQuotes(trimmed.slice(idx + 1).trim());
+      if (k && v) out.set(k, v);
+    }
+  }
+  return out;
+}
+
+/** 注册表路径 <specBase>/.runtime/worktrees/cross-placements.json */
+export function placementRegistryPath(specBase) {
+  return join(specBase, '.runtime', 'worktrees', PLACEMENT_REGISTRY_FILE);
+}
+
+/**
+ * 读注册表（整对象）。文件缺失/损坏半截 JSON → {}（fail-open：读取方降级默认公式）。
+ * @returns {Record<string, {repoKey: string, changeName: string, worktreePath: string, placementRoot: string}>}
+ */
+export function readPlacementRegistry(specBase) {
+  const p = placementRegistryPath(specBase);
+  if (!existsSync(p)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(p, 'utf8'));
+    return (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * 写/更新一条注册表（read-modify-merge + 原子写——多变更并发各改各键，merge 防整文件覆盖丢他键；
+ * 极小窗口仍可能丢并发写，后果=该变更降级公式寻址，见 design R-02）。
+ * @param {string} specBase
+ * @param {string} changeName
+ * @param {string} repoKey
+ * @param {{worktreePath: string, placementRoot: string}} entry
+ */
+export function updatePlacementRegistry(specBase, changeName, repoKey, entry) {
+  const registry = readPlacementRegistry(specBase);
+  registry[crossWorktreeDirName(changeName, repoKey)] = {
+    repoKey,
+    changeName,
+    worktreePath: entry.worktreePath,
+    placementRoot: entry.placementRoot,
+  };
+  writeAtomicSync(placementRegistryPath(specBase), JSON.stringify(registry, null, 2) + '\n');
+}
+
+/**
+ * 删除一条注册表键（无键幂等 no-op；目录被并发清理后再删同键安全）。
+ */
+export function removePlacementRegistryEntry(specBase, changeName, repoKey) {
+  const registry = readPlacementRegistry(specBase);
+  const key = crossWorktreeDirName(changeName, repoKey);
+  if (!(key in registry)) return;
+  delete registry[key];
+  writeAtomicSync(placementRegistryPath(specBase), JSON.stringify(registry, null, 2) + '\n');
+}
+
+/**
+ * 差集 sweep（评审 P2 吸收）：本变更名下的全部注册表键（<change>--*），凡 worktreePath 处
+ * 无 meta.json 的悬挂键一律删除——覆盖「cleanup 迭代源=listCrossWorktreeMetas 只列有 meta
+ * 条目」够不着的残留形态（worktree remove 连目录带 meta 同亡、仅键存）。
+ * @returns {string[]} 实际删除的键
+ */
+export function sweepPlacementRegistry(specBase, changeName) {
+  const registry = readPlacementRegistry(specBase);
+  const prefix = `${changeName}--`;
+  const removed = [];
+  for (const [key, entry] of Object.entries(registry)) {
+    if (!key.startsWith(prefix)) continue;
+    const wtPath = entry && typeof entry.worktreePath === 'string' ? entry.worktreePath : '';
+    if (!wtPath || !existsSync(join(wtPath, 'meta.json'))) {
+      delete registry[key];
+      removed.push(key);
+    }
+  }
+  if (removed.length > 0) {
+    writeAtomicSync(placementRegistryPath(specBase), JSON.stringify(registry, null, 2) + '\n');
+  }
+  return removed;
+}
+
+/**
+ * 寻址候选有序列表（去重）：注册表条目 → 仓内新默认公式（传 repoRoot 时）→ 主仓 specBase
+ * 旧默认公式（legacy 存量兜底）。需要「找真实在场位置」的读取方（meta 读取 / reconcile B' 档）
+ * 逐候选探测；单地址语义（resolve）取首候选。
+ * @returns {string[]}
+ */
+export function resolveCrossWorktreePathCandidates(specBase, changeName, repoKey, repoRoot = null) {
+  const out = [];
+  const registry = readPlacementRegistry(specBase);
+  const entry = registry[crossWorktreeDirName(changeName, repoKey)];
+  if (entry && typeof entry.worktreePath === 'string' && entry.worktreePath) {
+    out.push(entry.worktreePath);
+  }
+  if (repoRoot) {
+    out.push(crossWorktreePath(specBase, changeName, repoKey, join(repoRoot, '.sillyspec', '.runtime', 'worktrees')));
+  }
+  out.push(crossWorktreePath(specBase, changeName, repoKey));
+  return [...new Set(out.map((p) => resolvePath(p)))];
+}
+
+/**
+ * 寻址：注册表优先（键 <change>--<repoKey>）→ 仓内新默认公式（<repoRoot>/.sillyspec/
+ * .runtime/worktrees/<change>--<repoKey>，传 repoRoot 时）→ 主仓 specBase 旧默认公式（legacy
+ * 兜底——存量 worktree 仍可达）。
+ * 注册表只提供位置——条目指向处是否真有 worktree 由调用方（meta 读取/目录判定）裁决，
+ * 本函数不做存在性校验（create 前调用时目录尚不存在是合法态）。
+ * @param {string} specBase
+ * @param {string} changeName
+ * @param {string} repoKey
+ * @param {string|null} [repoRoot] 跨仓仓根（知道时传——寻址仓内新默认；缺省跳过该级）
+ * @returns {string} worktree 应在/所在路径
+ */
+export function resolveCrossWorktreePath(specBase, changeName, repoKey, repoRoot = null) {
+  return resolveCrossWorktreePathCandidates(specBase, changeName, repoKey, repoRoot)[0];
+}
+
+/**
+ * WSL 跨文件系统分裂判定（坑 cross-wt-toolchain-split，advisory 依据）：
+ * linux 平台且 repoRoot 匹配 /mnt/<盘>/（WSL automount Windows 盘）而 worktreePath 不匹配
+ * → 该仓构建工具链（Windows 侧）与 worktree（WSL 原生 fs）分居。win32/darwin 恒 false 不误报。
+ * @param {string} repoRoot 跨仓仓根
+ * @param {string} worktreePath worktree 落位路径
+ * @returns {boolean}
+ */
+const WSL_AUTOMOUNT_RE = /^\/mnt\/[A-Za-z](?:\/|$)/;
+export function isWslSplit(repoRoot, worktreePath) {
+  return process.platform === 'linux'
+    && WSL_AUTOMOUNT_RE.test(String(repoRoot || ''))
+    && !WSL_AUTOMOUNT_RE.test(String(worktreePath || ''));
+}

package/src/cross-repo-reconcile.js

@@ -33,7 +33,7 @@ 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'
-import { crossWorktreePath } from './worktree-cross.js'
+import { resolveCrossWorktreePathCandidates } from './cross-placement.js'
 import { resolveLatestExecuteRunIdWithTasks, readReview } from './task-review.js'
 
 // 与 verify-postcheck normalizeReconcilePath 同口径（本地实现防环）：剥 ./ 前缀、反斜杠归一
@@ -235,10 +235,13 @@ export function collectRepoActual({ repoKey, specBase, cwd, runtimeRoot = null,
     //     提交，对 worktree 多笔交付是假信号（2026-10-09 tombstone 取证：声明 4 实测 0）。
     //     meta 缺失/worktree 不在场/不可读 → 回退 B 档（不回退语义）。
     try {
-      const wtPath = crossWorktreePath(specBase, changeName, repoKey)
-      const metaPath = join(wtPath, 'meta.json')
-      if (existsSync(metaPath)) {
-        const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
+      // 寻址候选逐级探测（注册表 → 仓内新默认 → 主仓 specBase 旧默认）——任一候选 meta 在场即成窗
+      let wtPath = null
+      for (const cand of resolveCrossWorktreePathCandidates(specBase, changeName, repoKey, repoPath)) {
+        if (existsSync(join(cand, 'meta.json'))) { wtPath = cand; break }
+      }
+      if (wtPath) {
+        const meta = JSON.parse(readFileSync(join(wtPath, 'meta.json'), 'utf8'))
         const base = meta && meta.baseHash
         if (base && typeof base === 'string' && /^[0-9a-f]{7,40}$/i.test(base)) {
           const union2 = new Set()

package/src/doctor-diagnostics.js

@@ -1147,7 +1147,7 @@ export function detectSelfMaintenanceTax(cwd, authoritySpecDir) {
  * 语义：WARNING advisory 不阻断、只读无修复（钩子/门禁挂载是后续独立策略裁决）；
  * 无 archive 目录 / 无 task 行 → pass（无任务视为完备，同 OpenSpec "nothing to complete"）。
  */
-function detectArchiveIntegrity(cwd, authoritySpecDir) {
+export function detectArchiveIntegrity(cwd, authoritySpecDir) {
   const base = { name: 'archive_integrity', label: '归档完整性重扫', safe_actions: [] };
   if (!authoritySpecDir) {
     return { ...base, pass: true, severity: null, findings: ['无权威 specDir，跳过'] };
@@ -1169,6 +1169,26 @@ function detectArchiveIntegrity(cwd, authoritySpecDir) {
   if (names.length === 0) {
     return { ...base, pass: true, severity: null, findings: ['changes/archive 为空（无已归档变更）'], archive_count: 0, offenders: [] };
   }
+  // 幽灵复活检测（坑 archived-change-resurrect-by-merge，2026-10-10 实证：远端 merge 把
+  // 已归档变更的旧四件套带回活跃路径，run <stage> 自动注册幽灵行并推上平台）：活跃目录与
+  // 归档同名并存 = 高危形态。doctor 只报不治（勿建议 align——会给幽灵补 execute 戳）。
+  const activeChangesDir = join(authoritySpecDir, 'changes');
+  const resurrected = names.filter((name) => existsSync(join(activeChangesDir, name)));
+  if (resurrected.length > 0) {
+    return {
+      ...base,
+      pass: false,
+      severity: CHECK_SEVERITY.FAILED,
+      findings: [
+        `活跃目录与归档同名并存（${resurrected.length} 个）：${resurrected.join('、')}——疑似 merge 带回的幽灵复活（run 命令已拒绝对其注册）`,
+        '处置（先递归 diff 活跃 vs 归档确认归档侧为超集零信息损失）：认归档则 git rm -r 活跃目录提交；确要重开则换新变更名',
+        '勿用 --align-execute-progress（会给幽灵目录补 execute 戳）',
+      ],
+      archive_count: names.length,
+      resurrected,
+      offenders: [],
+    };
+  }
   const offenders = [];
   // FR 索引面（D14 第四检查数据源，循环外一次扫描复用；fr/ 不存在=仓未启用，全跳不误报）
   const frKnowledgeRoot = join(authoritySpecDir, 'knowledge');

package/src/flow-parity.js

@@ -221,7 +221,7 @@ export function filterCommittedFace(committedRaw, ownPrefix, opts = {}) {
 
 /**
  * patch 冻结面漂移检测（2026-10-05-disposition-refreeze-drift，主清单 P1）：处置重入审计
- * 错位——评审发现处置涉及代码修改后重跑 flow done，patch 子步幂等跳过让 change.patch/
+ * 时点错位——评审发现处置涉及代码修改后重跑 flow done，patch 子步幂等跳过让 change.patch/
  * review.json 停在处置前时点（2026-10-05-review-promise-negation 先例 905397ef；
  * 2026-10-05-flowdone-lintfail-output 收编活体复现：评审 P1 处置提交后不带 --refreeze 重跑，
  * 归档件缺处置面）。
@@ -230,23 +230,41 @@ export function filterCommittedFace(committedRaw, ownPrefix, opts = {}) {
  * 漂移——按提交 message 变更名归属（parseChangeNamesFromSubject，与 filterCommittedFace
  * 同口径的既成事实切分，非声明抢文件）。仅他侧后缀/裸提交不触发（他侧面归属切分另有防线，
  * 裸提交保守不动作）。检测自身失败按无漂移（退现状幂等跳过行为，fail-safe 不新造阻断面）。
+ *
+ * 文件面三字段（2026-10-10-drift-review-governance-keep，坑 drift-review-governance-loop）：
+ * ownCommits 只答「有没有漂移」，不答「评审结论该不该作废」——调用方（flow.js 漂移分支）
+ * 据文件面区分治理面等价（评审保留）与交付/承诺面（隔离重评）：
+ *   ownFiles            窗口内本变更提交触及的文件集（--name-only 采集，正斜杠归一；merge 提交
+ *                       无 -m 展开不计文件——漏采只可能让 governanceOnly 偏 false，回落隔离
+ *                       重评，fail-safe 宁可多评）
+ *   governanceOnly      own 提交全在 .sillyspec/** 下且文件集非空（治理文件等价漂移）
+ *   touchedPromiseFace  含本变更 requirements.md / design.md（承诺面也是评审对象，破豁免）
  * @param {{ cwd: string, change: string, freezeHead: string|null }} opts
- * @returns {{ drifted: boolean, ownCommits: string[], head: string|null }} ownCommits=本变更后缀提交的 subject 列表（截 80 字）
+ * @returns {{ drifted: boolean, ownCommits: string[], head: string|null, ownFiles: string[], governanceOnly: boolean, touchedPromiseFace: boolean }} ownCommits=本变更后缀提交的 subject 列表（截 80 字）
  */
 export function detectPatchDrift({ cwd, change, freezeHead }) {
   try {
-    if (!freezeHead) return { drifted: false, ownCommits: [], head: null }
+    if (!freezeHead) return { drifted: false, ownCommits: [], head: null, ownFiles: [], governanceOnly: false, touchedPromiseFace: false }
     const head = execFileSync('git', ['rev-parse', 'HEAD'], { cwd, encoding: 'utf8', timeout: 30000, windowsHide: true }).trim()
-    if (!head || head === freezeHead) return { drifted: false, ownCommits: [], head }
-    const log = execFileSync('git', ['log', '--format=%x00%s', `${freezeHead}..HEAD`], { cwd, encoding: 'utf8', timeout: 30000, windowsHide: true })
+    if (!head || head === freezeHead) return { drifted: false, ownCommits: [], head, ownFiles: [], governanceOnly: false, touchedPromiseFace: false }
+    const log = execFileSync('git', ['log', '--name-only', '--format=%x00%s', `${freezeHead}..HEAD`], { cwd, encoding: 'utf8', timeout: 30000, windowsHide: true })
     const own = []
+    const ownFileSet = new Set()
     for (const block of String(log).split('\x00')) {
-      const subject = block.split('\n').map((l) => l.trim()).filter(Boolean)[0]
+      const lines = block.split('\n').map((l) => l.trim()).filter(Boolean)
+      const subject = lines[0]
       if (!subject) continue
-      if (parseChangeNamesFromSubject(subject).includes(change)) own.push(subject.slice(0, 80))
+      if (parseChangeNamesFromSubject(subject).includes(change)) {
+        own.push(subject.slice(0, 80))
+        for (const f of lines.slice(1)) ownFileSet.add(f.replace(/\\/g, '/'))
+      }
     }
-    return { drifted: own.length > 0, ownCommits: own, head }
-  } catch { return { drifted: false, ownCommits: [], head: null } }
+    const ownFiles = [...ownFileSet]
+    const promiseFace = [`.sillyspec/changes/${change}/requirements.md`, `.sillyspec/changes/${change}/design.md`]
+    const governanceOnly = own.length > 0 && ownFiles.length > 0 && ownFiles.every((f) => f.startsWith('.sillyspec/'))
+    const touchedPromiseFace = ownFiles.some((f) => promiseFace.includes(f))
+    return { drifted: own.length > 0, ownCommits: own, head, ownFiles, governanceOnly, touchedPromiseFace }
+  } catch { return { drifted: false, ownCommits: [], head: null, ownFiles: [], governanceOnly: false, touchedPromiseFace: false } }
 }
 
 /**
@@ -290,10 +308,16 @@ export function collectFreezeFiles({ cwd, specBase, change, committed, exclusive
  * stats（collectNumstatByPath 产物 Map）缺档落 null 行数（不出伪数据）；planEntries 空/缺省
  * → 实际侧 only 行（无 verdict，与主链路计划侧降级同语义）。清单条目未命中冻结面 →
  * untouched 0/0 补行（跨仓条目带 crossRepo 保持 ⊘ 形态，主链路补行同语义）。
+ * crossRepoRows（2026-10-10-cross-repo-patch-freeze D-002@v1 可选第 4 参）：scope-audit
+ * reconcileCrossRepoPlan 的跨仓对账行（真实三态或 degraded ⊘，均带 crossRepo 标记）——
+ * 提供时带 repo 的声明条目若已被对账行覆盖（crossRepo+pathMatches 双判）不再落 ⊘ 补行
+ * （跨仓实改不谎报「未动」）；缺省 undefined → 现行为逐字节零回归（单仓变更/对账失败
+ * fail-soft 退路）。
  * @returns {{ rows: Array<object>, totals: { files: number, additions: number, deletions: number } }}
  */
-export function buildThinSnapshotRows({ ownFiles, stats, planEntries }) {
+export function buildThinSnapshotRows({ ownFiles, stats, planEntries, crossRepoRows }) {
   const plan = Array.isArray(planEntries) ? planEntries : []
+  const crossRows = (Array.isArray(crossRepoRows) ? crossRepoRows : []).filter((r) => r && typeof r === 'object')
   const statMap = stats instanceof Map ? stats : new Map()
   const rowFiles = filterDeliverableFiles([...new Set((Array.isArray(ownFiles) ? ownFiles : [])
     .map((f) => String(f).replace(/\\/g, '/')).filter(Boolean))]).sort()
@@ -324,12 +348,19 @@ export function buildThinSnapshotRows({ ownFiles, stats, planEntries }) {
   }
   for (const e of plan) {
     if (!e || matched.has(e.path)) continue
+    // 跨仓对账覆盖判定（D-002@v1）：crossRepoRows 提供且该声明条目已被对账行覆盖（同 repoKey
+    // + pathMatches 双判——对账行是真实三态或 degraded ⊘，覆盖即不再补恒 ⊘ 行）；对账行缺失
+    // （fail-soft 退路/降级仓无行）→ 照旧补 ⊘ 行
+    if (e.repo && crossRows.some((r) => r.crossRepo === e.repo && pathMatches(String(r.path || ''), e.path))) continue
     rows.push({
       path: e.path, planned: e.operation || null, additions: 0, deletions: 0,
       kind: 'modified', verdict: 'untouched',
       ...(e.repo ? { crossRepo: e.repo } : {}),
     })
   }
+  // 跨仓对账行并入总表（D-002@v1，heavy 通道同款语义——「跨仓行并入后自然计入 totals」）：
+  // 主仓行在前、跨仓行按仓追加；真实三态行（实 +/- 行数）替换恒 ⊘ 谎报
+  rows.push(...crossRows)
   let additions = 0
   let deletions = 0
   for (const r of rows) {

package/src/flow-review.js

@@ -16,7 +16,7 @@
  * 豁免 ≠ 免责：全信号不命中而豁免的变更按 1/4 定额抽查采样（确定性哈希分桶），采样命中照评
  * 并进遥测——误豁免率可测量可校准（先例：review-dispatch shadow 影子期 N=10 转正判据）。
  */
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
 import { DESIGN_QUESTIONS as DESIGN_QUESTIONS_FALLBACK } from './flow-draft.js'
 
@@ -203,7 +203,17 @@ export function renderReviewerTaskbook({ change, changeDir, head = null }) {
   // （首评任务书与现状逐字一致）。
   let priorFindingsMd = ''
   try {
-    const prev = JSON.parse(readFileSync(join(changeDir, 'review.json'), 'utf8'))
+    // 前轮产物读取（2026-10-10-drift-review-governance-keep，坑 drift-review-governance-loop ②）：
+    // review.json 在场优先；漂移隔离后已改名 review.json.superseded-<ts>——缺席时回退字典序最新
+    // 隔离件（时间戳后缀同格式可排序），否则处置重评读不到前轮 findings，「已报项只验修复+
+    // 回归」复审语义丢失，退化为全量首评整轮重报（2026-10-10 用户实证）。changeDir 不存在/
+    // 无隔离件 → readFileSync/readdirSync 抛错走外层 catch，首评形态零注入不变。
+    let prevPath = join(changeDir, 'review.json')
+    if (!existsSync(prevPath)) {
+      const supers = readdirSync(changeDir).filter((f) => /^review\.json\.superseded-/.test(f)).sort()
+      if (supers.length > 0) prevPath = join(changeDir, supers[supers.length - 1])
+    }
+    const prev = JSON.parse(readFileSync(prevPath, 'utf8'))
     if (Array.isArray(prev.findings) && prev.findings.length > 0) {
       priorFindingsMd = [
         ``,

package/src/flow.js

@@ -1272,6 +1272,14 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
           } catch { /* 锚定判定失败按未锚定处理 */ }
           if (anchoredToHead) {
             console.log(`   review.json 已锚定当前 HEAD（reviewedAgainst 命中 ${String(drift.head || '').slice(0, 8)}）——评审对象即最新交付面，结论保留不隔离`)
+          } else if (drift.governanceOnly && !drift.touchedPromiseFace) {
+            // 治理面等价保留（2026-10-10-drift-review-governance-keep，坑 drift-review-governance-loop
+            // 用户实证）：评审结论的对象是交付面——窗口内本变更提交只碰 .sillyspec/** 治理文件且
+            // 未触本变更 requirements/design（承诺面也是评审对象）时，结论对最新交付面逐字节等价，
+            // 保留不隔离不重置标记；change.patch 仍走下方 driftRefreeze 自动重冻结吸收治理面增量
+            // （审计件覆盖最新提交面不变量不破）。此前任何后缀提交一律隔离重评——评审后修一个
+            // P2 文档措辞也付整轮子代理评审费（循环，被迫手工重排执行顺序自赎）。
+            console.log(`   review.json 保留不隔离——窗口内本变更提交仅触及治理文件（${drift.ownFiles.length} 个，未触 requirements/design），评审对象（交付面）未变，结论对最新面等价；change.patch 自动重冻结吸收治理面增量`)
           } else {
             const ts = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, '')
             try {
@@ -1478,10 +1486,34 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
           let planEntries = []
           try {
             const { parseFileChangeListDetailed } = await import('./change-list.js')
-            planEntries = parseFileChangeListDetailed(join(changeDir, 'design.md'), { keepSillyspecDocs: true })
+            // repoKeys（2026-10-10-cross-repo-patch-freeze D-002@v1）：注册仓清单传入——跨仓
+            // 子段/cross-repo: 前缀条目才带 repo 标注（不传则跨仓声明全落主仓口径， thin 跨仓
+            // 对账无从谈起）
+            const { loadRegisteredRepoKeys } = await import('./scope-audit.js')
+            planEntries = parseFileChangeListDetailed(join(changeDir, 'design.md'), { keepSillyspecDocs: true, repoKeys: loadRegisteredRepoKeys(specBase) })
           } catch { /* 清单缺失/不可解析 → 实际侧 only 快照行（无 verdict，与主链路降级同语义） */ }
+          // 跨仓声明在场 → 共享集成层分仓对账 + patch 冻结（D-001/D-002@v1）：与 heavy 通道
+          // （execute --done）同源 reconcileCrossRepoPlan，repos[]（锚点/计数/patch 正文）
+          // 随 snapObj 进 change-patch.json；任何异常 fail-soft 退 ⊘ 补行现行为（不阻断收口）
+          let crossRepos = []
+          let crossRepoRows = undefined
+          if (planEntries.some((e) => e && e.repo)) {
+            try {
+              const { reconcileCrossRepoPlan } = await import('./scope-audit.js')
+              const recon = reconcileCrossRepoPlan({
+                cwd, specBase,
+                runtimeRoot: resolveRuntimeRoot(runtimeRootOpt ? { runtimeRoot: runtimeRootOpt } : {}, specBase),
+                changeName: change,
+                planEntries,
+                collectPatch: true,
+              })
+              crossRepoRows = recon.rows
+              crossRepos = recon.repos
+              for (const n of recon.notes) console.log(`   📎 ${n}`)
+            } catch { /* 跨仓对账失败 → 退 ⊘ 补行（crossRepoRows 保持 undefined） */ }
+          }
           const { buildThinSnapshotRows, writeCloseTraceArtifacts } = await import('./flow-parity.js')
-          const { rows: snapRows, totals: snapTotals } = buildThinSnapshotRows({ ownFiles, stats, planEntries })
+          const { rows: snapRows, totals: snapTotals } = buildThinSnapshotRows({ ownFiles, stats, planEntries, crossRepoRows })
           const closeTrace = writeCloseTraceArtifacts({
             changeDir,
             change,
@@ -1499,6 +1531,7 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
               excluded: { foreignDeclared: [] },
               note: 'flow done 时点冻结（本文件落盘时采集）',
               closedBy: 'flow done',
+              ...(crossRepos.length > 0 ? { repos: crossRepos } : {}),
             },
             meta: {
               note: 'flow done 时点冻结（本变更可归属面：baseline..HEAD 提交面过滤 .sillyspec/ 非本变更目录但保留 .sillyspec/docs/ 交付文档 + 本变更目录工作树件；含未提交与 untracked，排除 flow-state.yaml 运行态）',
@@ -1511,6 +1544,11 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
             },
           })
           console.log(`📦 变更 patch 留档（单套）：change.patch + change-patch.json（${ownFiles.length} 文件，+${additions}/-${deletions}，对账面并入 scopeAudit 子对象）${closeTrace.patchStatus === 'ok' ? '，sha256 已锚' : '——patch 采集失败已留痕'}`)
+          if (crossRepos.length > 0) {
+            const frozenRepos = crossRepos.filter((r) => r && r.patch).length
+            const degradedRepos = crossRepos.filter((r) => r && r.degraded).length
+            console.log(`   📦 跨仓 patch 冻结：${crossRepos.length} 仓（正文 ${frozenRepos}、降级 ${degradedRepos}）——锚点/计数/diff 正文见 change-patch.json scopeAudit.repos[]`)
+          }
           // design 声明面自证（2026-09-25-platform-feedback-batch2 E）：design.md 文件变更清单
           // 声明的交付文件是否都在冻结面——不在=承诺改了但没交付（承诺未兑现面，advisory 不
           // 阻断——可能是范围裁剪了但 design 没同步更新）
@@ -1598,6 +1636,11 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
       if (others.length > 0) {
         console.warn(`⚠️ 评审非阻断发现 ${others.length} 项（P2/P3，随归档留档）：`)
         for (const f of others) console.warn(`   [${f.severity}] ${f.title} — ${f.evidence || ''}`)
+        // 处置提示（2026-10-10-drift-review-governance-keep，坑 drift-review-governance-loop）：
+        // P2/P3 非阻断可留债归档；要修则修复面决定是否重评——只碰治理文件不动本变更
+        // requirements/design 的后缀提交触发治理面等价保留（评审保留+自动重冻结，零重评）；
+        // 触及交付面或承诺面才隔离重评（任务书带前轮 findings，复审只验修复+新增）。
+        console.warn(`   💡 处置参考：P2/P3 非阻断，可留债归档；要修——只碰治理文件（.sillyspec/**，不动本变更 requirements/design）的提交不触发重评；触及交付面或 requirements/design 需重评（复审只验修复+新增，非全量首评）`)
       }
       console.log(`✅ 独立评审通过（reviewer=${v.review.reviewer}${tier.sampled ? '，豁免抽查采样命中' : ''}）`)
       reviewOutcome = { required: true, sampled: tier.sampled, verdict: 'PASS', findingsP1: 0 }