sillyspec 3.28.7 → 3.28.9

package/src/worktree-cross.js

@@ -198,23 +198,16 @@ export function ensureCrossWorktrees({ cwd, changeName, specBase }) {
     };
     writeAtomicSync(join(worktreePath, META_FILE), JSON.stringify(meta, null, 2) + '\n');
 
-    // dirty baseline overlay：跨仓主工作副本在途改动 → worktree baseline（借主仓同款实现，
-    // 只用其参数化逻辑，不用实例路径状态）
-    try {
-      const wmHelper = new WorktreeManager({ cwd: repoRoot });
-      const baselineResult = wmHelper._overlayBaseline(repoRoot, worktreePath);
-      meta.baselineFiles = baselineResult.files;
-      meta.baselineHash = baselineResult.baselineHash;
-      if (baselineResult.files.length > 0) {
-        meta.baselineCommit = wmHelper._createBaselineCheckpoint(worktreePath, `${changeName}--${key}`, baselineResult.files);
-      }
-      if (baselineResult.errors && baselineResult.errors.length > 0) {
-        console.warn(`⚠️ 跨仓 ${key} baseline overlay 部分失败（${baselineResult.errors.join('; ')}）——在途改动未全量进 baseline，apply 前请人工核对跨仓主工作副本`);
-      }
-      writeAtomicSync(join(worktreePath, META_FILE), JSON.stringify(meta, null, 2) + '\n');
-    } catch (e) {
-      console.warn(`⚠️ 跨仓 ${key} baseline overlay 失败（${e.message}）——跨仓主工作副本如有在途改动，worktree 不含它们`);
-    }
+    // 跨仓仓跳过 dirty baseline overlay + checkpoint（坑 cross-baseline-checkpoint-foreign-files，
+    // 2026-09-12 驾驭第十三批②，用户实证：跨仓主副本在途的外来文件——并行会话的 2 个 pptx +
+    // meta.json——被 checkpoint 带进跨仓分支，污染 apply 锚点对账被迫 cherry-pick 重建）：
+    // 跨仓模型 = 子代理直接 commit 跨仓分支（NG-3），跨仓主副本的 WIP 不属于本变更隔离面，
+    // 不该被固化进分支。meta.baselineFiles=[] 显式记录「无 checkpoint」，apply 侧以 baseHash
+    // （跨仓仓 HEAD）为锚。
+    meta.baselineFiles = [];
+    meta.baselineHash = baseHash;
+    console.log(`ℹ️ 跨仓 ${key}: 跳过 dirty baseline checkpoint（跨仓主副本在途改动不进本变更分支——含并行会话外来文件时防污染；锚点 = 跨仓仓 HEAD ${String(baseHash).slice(0, 8)}）`);
+    writeAtomicSync(join(worktreePath, META_FILE), JSON.stringify(meta, null, 2) + '\n');
 
     // deps 供给：specBase 传 null —— sniff worktree 自身（主仓 local.yaml 的 project.type/install
     // 描述的是主仓，跨仓仓类型常不同，如实测 maven 主仓 + nodejs 前端仓，沿用会把 mvn 命令
@@ -284,7 +277,8 @@ export function cleanupCrossWorktrees({ cwd, changeName, specBase, force = false
       git(repoRoot, ['worktree', 'remove', '--force', wtPath], { timeout: 60000 });
     } catch {
       // remove 失败（脏文件/锁）：解链后安全删目录 + prune 注册
-      try { safeRemoveWorktreeDir(wtPath, meta) } catch (e) { residual.push(`目录残留 ${wtPath}: ${e.message}`) }
+      // allowCross:true——本函数就是跨仓清理的显式路径（主仓守卫放行；见 safeRemoveWorktreeDir 注释）
+      try { safeRemoveWorktreeDir(wtPath, meta, { allowCross: true }) } catch (e) { residual.push(`目录残留 ${wtPath}: ${e.message}`) }
       try { gitQuiet(repoRoot, ['worktree', 'prune'], { timeout: 30000 }) } catch { residual.push(`git worktree prune 失败（${repoRoot}）`) }
     }
     details.push(`分支 ${meta.branch} 保留作 review 锚点（确认无需回溯后可 git -C ${repoRoot} branch -D ${meta.branch}）`);

package/src/worktree-deps.js

@@ -13,8 +13,8 @@
  * node 校验与 java 校验各说各话。新生态补一行表项即可；表外项目落 generic → n/a 不阻断。
  */
 
-import { existsSync, readFileSync, realpathSync, lstatSync, readdirSync, unlinkSync } from 'fs';
-import { join, isAbsolute, relative, resolve as resolvePath, sep as pathSep } from 'path';
+import { existsSync, readFileSync, realpathSync, lstatSync, readdirSync, readlinkSync, unlinkSync } from 'fs';
+import { join, dirname, isAbsolute, relative, resolve as resolvePath, sep as pathSep } from 'path';
 import { fileURLToPath } from 'url';
 import { execFileSync } from 'child_process';
 import { createHash } from 'crypto';
@@ -387,6 +387,86 @@ function isSafeModulePath(p) {
   return !segs.includes('..');
 }
 
+/**
+ * resolved 路径是否严格位于 root 目录之下（不含 root 自身）。win32 大小写不敏感比较由
+ * path.win32.relative 自带（与 detectEditableInstallEscape 的越界判定同口径）。
+ */
+function isUnderDir(child, root) {
+  if (!child || !root) return false;
+  const rel = relative(resolvePath(root), resolvePath(child));
+  return rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+}
+
+/**
+ * ql-20260915-003 修复①（坑 junction-foreign-ownership，2026-09-15 用户实证：主仓
+ * frontend/node_modules 内部发现 junction 指向 session-export worktree 的 .pnpm——跨会话
+ * node_modules 污染，apply 后被迫 --force 重装）。
+ *
+ * 归属判定：链接方向 wt/node_modules → main 是 SillySpec 的正确设计（worktree 共享主仓
+ * 依赖）；反向——main node_modules 内出现指向 .sillyspec/.runtime/worktrees/ 之下目标的
+ * junction/symlink——是 install 兜底/包管理器穿透写坏留下的污染，任何合法流程都不依赖它，
+ * 一律视为外来（foreign）。pnpm 自建的包链接（node_modules/<pkg> → 同 node_modules 内
+ * .pnpm/...）与全局 store 链接目标都不在 worktrees 区之下，零误伤。
+ *
+ * 扫描口径：main 的 node_modules（根 + 各子模块 node_modules）**顶层目录项**——单层
+ * readdir+lstat，不递归 .pnpm 内部（顶层已覆盖包链接；递归大仓 node_modules 的性能与
+ * 误删面都不可接受）。子模块清单：submodules 直传相对路径列表，或给 specBase 自动读
+ * local.yaml modules 块。
+ *
+ * 删除安全：junction/symlink 删除不跟随目标（win32 cmd /c rmdir / POSIX unlinkSync——与
+ * worktree.js unlinkNodeModulesLinks :82 同款安全删法）；单个清理失败 fail-open 记入
+ * failed 不阻断（清扫是治理动作，不拦主流程）。
+ *
+ * @param {string} mainDir 主仓根目录（node_modules 所在）
+ * @param {{ worktreesRoot?: string, specBase?: string|null, submodules?: string[]|null, dryRun?: boolean, onlyUnder?: string|null }} opts
+ *   - worktreesRoot 外来边界：resolved target 落在其下才算外来（缺省直接空手而归）
+ *   - submodules 为 null 且给了 specBase 时，自动读 local.yaml modules 块补子模块清单
+ *   - dryRun=true 只报清单零写盘
+ *   - onlyUnder 进一步收窄：只认 target 落在该目录之下的（install 兜底前只清指向本 worktree 的）
+ * @returns {{ foreign: Array<{link: string, target: string}>, removed: Array<{link: string, target: string}>, failed: Array<{link: string, error: string}> }}
+ *   dryRun 时 foreign=将清清单、removed/failed 恒空；非 dryRun 时 removed=实际已清、failed=清理失败
+ */
+export function sweepForeignNodeModulesJunctions(mainDir, { worktreesRoot, specBase = null, submodules = null, dryRun = false, onlyUnder = null } = {}) {
+  const result = { foreign: [], removed: [], failed: [] };
+  if (!mainDir || !worktreesRoot || !existsSync(mainDir)) return result;
+  let mods = submodules;
+  if (mods === null && specBase) mods = extractModulePaths(readLocalYaml(specBase, null));
+  const nmDirs = [join(mainDir, 'node_modules')];
+  for (const sp of Array.isArray(mods) ? mods : []) {
+    if (!isSafeModulePath(sp)) continue;
+    nmDirs.push(join(mainDir, sp, 'node_modules'));
+  }
+  for (const nmDir of nmDirs) {
+    let names;
+    try { names = readdirSync(nmDir); } catch { continue; } // 目录不存在/不可读 → 该层跳过
+    for (const nm of names) {
+      const linkPath = join(nmDir, nm);
+      let st;
+      try { st = lstatSync(linkPath); } catch { continue; }
+      if (!st.isSymbolicLink()) continue; // junction（reparse point）与 symlink 的 lstat 均报 isSymbolicLink
+      let target;
+      try { target = readlinkSync(linkPath); } catch { continue; }
+      // 相对 target（pnpm 自建包链接常态）相对链接所在目录解析
+      const resolved = resolvePath(dirname(linkPath), target);
+      if (!isUnderDir(resolved, worktreesRoot)) continue;
+      if (onlyUnder && !isUnderDir(resolved, onlyUnder)) continue;
+      result.foreign.push({ link: linkPath, target: resolved });
+      if (dryRun) continue;
+      try {
+        if (process.platform === 'win32') {
+          execFileSync('cmd.exe', ['/c', 'rmdir', linkPath], { stdio: ['pipe', 'pipe', 'pipe'] });
+        } else {
+          unlinkSync(linkPath);
+        }
+        result.removed.push({ link: linkPath, target: resolved });
+      } catch (e) {
+        result.failed.push({ link: linkPath, error: e.message });
+      }
+    }
+  }
+  return result;
+}
+
 /**
  * 对单个子模块目录 tryLink main 的 node_modules → wt 的 node_modules（modules 子模块专用）。
  * 仅走 link 快路径（不 install——子模块 install 慢且易失败；lockfile 不一致时交给用户 pnpm install）。
@@ -464,6 +544,24 @@ export function provisionDeps(worktreePath, mainCwd, opts = {}) {
     }
     if (!linked) {
       // 兜底：install
+      // ql-20260915-003 修复①（坑 junction-foreign-ownership）防再犯：install 在 worktree cwd
+      // 执行，若 main node_modules 内残留指向**本次 worktree** 的外来 junction，包管理器会经
+      // 反向链接穿透写坏主仓 node_modules（2026-09-15 实证的污染源头）——先清再装。
+      // 只清指向本 worktree 的（onlyUnder），全量治理交给 create/cleanup 挂点
+      // （worktree.js _sweepMainForeignJunctionLinks）。
+      if (mainCwd && existsSync(join(mainCwd, 'node_modules'))) {
+        try {
+          const preSweep = sweepForeignNodeModulesJunctions(mainCwd, {
+            worktreesRoot: resolvePath(mainCwd, '.sillyspec', '.runtime', 'worktrees'),
+            submodules: extractModulePaths(yamlText),
+            onlyUnder: worktreePath,
+          });
+          if (preSweep.removed.length > 0) {
+            console.warn(`⚠️ install 前清理：主仓 node_modules 内检测到指向本 worktree 的外来 junction（坑 junction-foreign-ownership），已移除 ${preSweep.removed.length} 个`);
+            for (const r of preSweep.removed) console.warn(`   ${r.link} → ${r.target}`);
+          }
+        } catch { /* 清扫自身异常 fail-open，交 install 自然暴露问题 */ }
+      }
       const installResult = tryInstall(installCmd, worktreePath, timeout);
       result = installResult.ok
         ? { depsStatus: 'installed', depsMethod: 'install', depsSource: 'install', depsLockHash: wtHash }

package/src/worktree.js

@@ -10,9 +10,10 @@
 
 import { execFileSync } from 'child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync, statSync, lstatSync, readlinkSync, unlinkSync, copyFileSync } from 'fs';
-import { join, resolve, dirname, relative, isAbsolute } from 'path';
+import { join, resolve, dirname, relative, isAbsolute, basename } from 'path';
 import { createHash } from 'crypto';
-import { provisionDeps, checkDepsFreshness, detectEditableInstallEscape } from './worktree-deps.js';
+import { provisionDeps, checkDepsFreshness, detectEditableInstallEscape, sweepForeignNodeModulesJunctions } from './worktree-deps.js';
+import { resolveRuntimeRoot } from './run/shared.js';
 import { writeAtomicSync } from './fs-atomic.js';
 import { openDatabase } from './db-engine.js';
 import { git, gitQuiet } from './git-helper.js';
@@ -25,6 +26,24 @@ const WORKTREES_REL = '.sillyspec/.runtime/worktrees';
 const BRANCH_PREFIX = 'sillyspec/';
 const META_FILE = 'meta.json';
 
+/**
+ * argv 长度分批（审查遗留终批-①；与 worktree-apply.js chunkPaths 同逻辑内联私有版——
+ * 那边 import 本文件，反向 import 成环，两处须同步演化）。Windows CreateProcess 命令行
+ * 32767 字符上限：数百个长路径全量展开时 spawn 直接失败（hash-object 失败返 null 会让
+ * hasUnappliedChanges 全量误判 pending 卡死 cleanup）。保守 8000 字符/批。
+ */
+function _chunkPathsPrivate(paths, maxChars = 8000) {
+  const batches = [[]]
+  let len = 0
+  for (const p of paths) {
+    const l = String(p).length + 1
+    if (batches[batches.length - 1].length > 0 && len + l > maxChars) { batches.push([]); len = 0 }
+    batches[batches.length - 1].push(p)
+    len += l
+  }
+  return batches
+}
+
 /**
  * 解除 worktree 内全部 node_modules junction/symlink（根 + meta.depsModules 各子模块）。
  *
@@ -79,7 +98,65 @@ export function unlinkNodeModulesLinks(worktreePath, meta = null, details = null
  * 安全删除 worktree 目录：先解链全部 node_modules junction 再 rmSync。
  * 幽灵目录清理（create 强删 / doctor ghost 修复）的统一出口——不再裸 rmSync。
  */
-export function safeRemoveWorktreeDir(worktreePath, meta = null) {
+/**
+ * 跨仓 worktree 目录判定（坑 cross-worktree-swept-by-main-cleanup，2026-09-12 驾驭第十三批①，
+ * 用户实证：跨仓 worktree 被 verify 期间的主仓侧清理面误删，apply 锚点校验连环失败、被迫
+ * cherry-pick 重建）：目录内 meta.json 带 isCross:true，或目录名呈 <change>--<repoKey> 跨仓
+ * 形态（.runtime/worktrees/ 下主仓 worktree 恒为纯 <change>，双连字符后缀是跨仓专属命名）。
+ */
+export function isCrossWorktreeDir(worktreePath) {
+  try {
+    const metaPath = join(worktreePath, 'meta.json')
+    if (existsSync(metaPath)) {
+      try {
+        const m = JSON.parse(readFileSync(metaPath, 'utf8'))
+        if (m && m.isCross === true) return true
+      } catch { /* 损坏 meta → 落到命名形态判定 */ }
+    }
+    const base = basename(worktreePath)
+    // 主仓 changeName 可含连字符（2026-09-10-x），跨仓后缀是 '--<repoKey>'——要求双连字符
+    // 分隔且两侧非空、repoKey 段无路径分隔符
+    const m2 = base.match(/^(.+)--([A-Za-z0-9_.\-]+)$/)
+    return !!(m2 && m2[1].trim() && m2[2].trim() && !m2[2].includes('/') && !m2[2].includes('\\'))
+  } catch {
+    return false
+  }
+}
+
+/**
+ * worktree 目录安全删除原语。opts.allowCross（默认 false）：跨仓 worktree（isCross meta/
+ * 命名形态）拒绝删除——主仓清理面（cleanup force-remove / doctor ghost / 幽灵清理）不得
+ * 波及跨仓 worktree（其注册在跨仓仓 .git，删除权在 cleanupCrossWorktrees 显式路径）。
+ */
+
+/**
+ * baseline checkpoint 产物防御（坑 baseline-checkpoint-binary-sweep，2026-09-12 驾驭第十五
+ * 批②，用户实证：部署 tar.gz（289MB）被 checkpoint 带进分支——FF 合并被迫改 merge commit +
+ * 二进制永久入 git）。untracked 收入口对两类产物恒跳过：①已知归档/分发扩展名（tar.gz/zip/
+ * whl/exe 等——几乎不可能是源码 WIP）；②单文件超体积帽（缺省 10MB，SILLYSPEC_BASELINE_
+ * MAX_FILE_MB 可调）。跳过清单返回调用方点名 + 补 .gitignore 指引（gitignore 缺口的实际代价
+ * 由工具兜底提示）。tracked-modified 不走本防御（已在 git 历史里，checkpoint diff 是 git 原生）。
+ */
+const ARTIFACT_EXT_RE = /\.(?:tar\.gz|tgz|tar|zip|7z|rar|gz|bz2|xz|whl|exe|dll|so|dylib|iso|dmg|pkg|jar|war|apk|ipa)$/i
+
+export function isCheckpointSkippableArtifact(absPath) {
+  const rel = String(absPath).split('\\').join('/')
+  if (ARTIFACT_EXT_RE.test(rel)) return 'artifact-ext'
+  try {
+    const maxMB = Number(process.env.SILLYSPEC_BASELINE_MAX_FILE_MB) || 10
+    const st = statSync(absPath)
+    if (st.isFile() && st.size > maxMB * 1024 * 1024) return 'size-cap'
+  } catch { /* stat 失败按不跳过（后续 copy 自会报错） */ }
+  return null
+}
+
+export function safeRemoveWorktreeDir(worktreePath, meta = null, opts = {}) {
+  if (!opts.allowCross && isCrossWorktreeDir(worktreePath)) {
+    throw new Error(
+      `跨仓 worktree 拒绝删除（主仓清理面守卫，坑 cross-worktree-swept-by-main-cleanup）: ${worktreePath}` +
+      `——跨仓 worktree 由 sillyspec worktree cleanup <change>（跨仓一并清理）或 apply no-op 路径管理；主仓侧清理/doctor 扫描不碰它`
+    )
+  }
   unlinkNodeModulesLinks(worktreePath, meta);
   rmSync(worktreePath, { recursive: true, force: true });
 }
@@ -402,6 +479,44 @@ export class WorktreeManager {
     return resolve(this.worktreeBase, changeName);
   }
 
+  /**
+   * ql-20260915-003 修复①（坑 junction-foreign-ownership，2026-09-15 用户实证：主仓
+   * frontend/node_modules 内 junction 指向历史 worktree 的 .pnpm——跨会话 node_modules
+   * 污染）：清扫主仓 node_modules（根 + local.yaml modules 子模块）内指向 worktrees 区的
+   * 外来 junction/symlink。正确链接方向只有 wt/node_modules → main；main 侧指向 worktrees
+   * 区的反向链接一律是 install 兜底/包管理器穿透写坏的污染，发现即清 + warn。
+   *
+   * 挂点：create 依赖供给前（5.7b，防新供给经污染链接写坏）与 cleanup（把本 worktree 可能
+   * 遗留的反向链接一并清）。清扫失败 fail-open 不阻断主流程（治理动作非卡点）。
+   *
+   * @param {string} label 调用场景（warn/details 文案用）
+   * @param {string[]|null} [details] 可选，cleanup details 兼容
+   * @returns {{ foreign: Array, removed: Array, failed: Array }} sweep 结果（异常时空集）
+   */
+  _sweepMainForeignJunctionLinks(label, details = null) {
+    try {
+      const mainRoot = this._resolveMainRepoRoot();
+      const sweep = sweepForeignNodeModulesJunctions(mainRoot, {
+        worktreesRoot: this.worktreeBase,
+        specBase: join(mainRoot, '.sillyspec'),
+      });
+      if (sweep.removed.length > 0) {
+        console.warn(`⚠️ 检测到主仓 node_modules 内指向历史 worktree 的外来 junction，已移除 ${sweep.removed.length} 个（坑 junction-foreign-ownership，${label}）`);
+        for (const r of sweep.removed) console.warn(`   ${r.link} → ${r.target}`);
+        if (details) details.push(`foreign junctions swept (${label}): ${sweep.removed.length}`);
+      }
+      if (sweep.failed.length > 0) {
+        console.warn(`⚠️ 主仓 node_modules 外来 junction 清理未全成（${sweep.failed.length} 个失败，可重跑 sillyspec worktree doctor 或手工 rmdir）: ${sweep.failed.map(f => f.link).join('、')}`);
+        if (details) details.push(`foreign junction sweep partial fail (${label}): ${sweep.failed.map(f => f.link).join('; ')}`);
+      }
+      return sweep;
+    } catch (e) {
+      // fail-open：清扫自身异常不阻断 create/cleanup 主流程
+      console.warn(`⚠️ 主仓 node_modules 外来 junction 清扫跳过（${e && e.message ? e.message : e}）`);
+      return { foreign: [], removed: [], failed: [] };
+    }
+  }
+
   /**
    * 读取 worktree 元数据
    * @param {string} changeName
@@ -620,6 +735,10 @@ export class WorktreeManager {
 
     // 5.8 依赖供给（change 2026-06-28-worktree-deps-provision）
     // baseline overlay 后让 worktree 立即可构建/测试；失败不阻断 create，只记 meta。
+    // 5.7b ql-20260915-003 修复①（坑 junction-foreign-ownership）：依赖供给前清扫主仓
+    // node_modules 内指向历史 worktree 的外来 junction（反向链接污染，install 兜底穿透
+    // 写坏的源头）——发现即清 + warn，防新供给再经污染链接写坏主仓依赖。
+    this._sweepMainForeignJunctionLinks('worktree create');
     let deps = {};
     try {
       deps = provisionDeps(worktreePath, this.cwd, { specBase: join(this.cwd, '.sillyspec') }) || {};
@@ -873,11 +992,10 @@ export class WorktreeManager {
   _branchReviewReferences(branch) {
     const runsDir = join(this.cwd, '.sillyspec', '.runtime', 'execute-runs');
     if (!existsSync(runsDir)) return [];
-    const branchCommits = new Set(
-      (gitQuiet(this.cwd, ['rev-list', branch]) || '').split('\n').map(s => s.trim()).filter(Boolean)
-    );
-    if (branchCommits.size === 0) return [];
-    const refs = [];
+    // 终批-②：先收 review.json 里出现的候选 hash（少量），再逐个精确校验「是分支祖先或自身」
+    // ——旧实现整分支 rev-list 进 Set（大历史仓 10 万 commit 每次 cleanup/doctor 可观内存与
+    // 时间，而判定只用到 review 引用过的那几个 hash）。
+    const candidates = new Map(); // hash → 引用它的 review.json 路径数组
     const visit = (dir) => {
       for (const entry of readdirSync(dir, { withFileTypes: true })) {
         const p = join(dir, entry.name);
@@ -887,14 +1005,25 @@ export class WorktreeManager {
             const r = JSON.parse(readFileSync(p, 'utf8'));
             for (const key of ['base', 'head']) {
               const h = typeof r[key] === 'string' ? r[key].trim() : '';
-              if (h && branchCommits.has(h)) { refs.push(p); break; }
+              if (h) {
+                if (!candidates.has(h)) candidates.set(h, []);
+                candidates.get(h).push(p);
+              }
             }
           } catch { /* review.json 损坏不参与判定 */ }
         }
       }
     };
     visit(runsDir);
-    return refs;
+    if (candidates.size === 0) return [];
+    const refs = [];
+    for (const [hash, paths] of candidates) {
+      // merge-base --is-ancestor：祖先或自身 → exit 0 输出空串（gitQuiet 返回 ''≠null）；
+      // 非祖先 → exit 1 → null；未知/畸形 hash → 报错非零 → null（不在分支内，语义正确）
+      const probe = gitQuiet(this.cwd, ['merge-base', '--is-ancestor', hash, branch]);
+      if (probe !== null) refs.push(...paths);
+    }
+    return [...new Set(refs)];
   }
 
   /**
@@ -960,16 +1089,76 @@ export class WorktreeManager {
     }
   }
 
+  /**
+   * ql-20260915-003 修复②（坑 cleanup-meta-fallback，2026-09-15 用户实证：cleanup 报
+   * 「mode: null 跳过清理」但 worktree 目录实际创建过——meta 在 apply 后丢失 + cwd/specRoot
+   * 漂移让 getWorktreePath 解析到别处时，meta/worktreePath/metaDir 三缺被误判「什么都不
+   * 存在」早退）：meta 缺失时的 worktree 残留兜底探测。两路探针（异常一律 fail-open 视为
+   * 未命中）：
+   *   (a) `git worktree list --porcelain` 中分支 refs/heads/sillyspec/<name> 的注册路径——
+   *       git 注册是权威口径，不受本进程 worktreeBase 解析漂移影响；目录在不在都算命中
+   *       （注册残留本身就该 prune，目录在则连目录一起清）
+   *   (b) resolveRuntimeRoot 口径（cwd/.sillyspec 为 localSpecBase）下 worktrees/<name>
+   *       目录存在性——平台 runtimeRoot / cwd 漂移时的第二解析口径
+   * 全不命中 → hit:null + candidates（三路探针描述，供 CLI 诊断式跳过输出）。
+   * @param {string} name changeName（已过 validateChangeName）
+   * @returns {{ hit: { path: string, via: string }|null, candidates: string[] }}
+   */
+  _probeWorktreeRemnants(name) {
+    const stdPath = this.getWorktreePath(name);
+    const candidates = [`meta/目录探针（getWorktreePath 口径）: ${stdPath} 不存在`];
+    try {
+      const out = gitQuiet(this.cwd, ['worktree', 'list', '--porcelain'], { timeout: 30000 });
+      const wantBranch = `branch refs/heads/${BRANCH_PREFIX}${name}`;
+      let curPath = null;
+      let regHit = null;
+      for (const line of String(out || '').split('\n')) {
+        if (line.startsWith('worktree ')) curPath = line.slice('worktree '.length).trim();
+        else if (curPath && line.trim() === wantBranch) { regHit = curPath; break; }
+      }
+      if (regHit) {
+        candidates.push(`git 分支探针: 分支 ${BRANCH_PREFIX}${name} 注册于 ${regHit} —— 命中`);
+        return { hit: { path: regHit, via: `git worktree list 分支 ${BRANCH_PREFIX}${name} 注册路径` }, candidates };
+      }
+      candidates.push(`git 分支探针: git worktree list 无分支 ${BRANCH_PREFIX}${name} 注册`);
+    } catch {
+      candidates.push(`git 分支探针: git worktree list 失败（fail-open 视为未命中）`);
+    }
+    try {
+      const alt = join(resolveRuntimeRoot(null, join(this.cwd, '.sillyspec')), 'worktrees', name);
+      if (existsSync(alt)) {
+        candidates.push(`runtimeRoot 口径目录探针: ${alt} 存在 —— 命中`);
+        return { hit: { path: alt, via: `resolveRuntimeRoot 口径目录 ${alt}` }, candidates };
+      }
+      candidates.push(`runtimeRoot 口径目录探针: ${alt} 不存在`);
+    } catch {
+      candidates.push('runtimeRoot 口径目录探针: 解析失败（fail-open 视为未命中）');
+    }
+    return { hit: null, candidates };
+  }
+
   cleanup(changeName, { force = false, maxRetries = 3 } = {}) {
     const name = validateChangeName(changeName);
     const meta = this.getMeta(name);
-    const worktreePath = this.getWorktreePath(name);
+    let worktreePath = this.getWorktreePath(name);
     const metaDir = join(this.worktreeBase, name);
     const details = [];
 
-    // 幂等：什么都不存在 → 直接跳过
+    // 幂等：什么都不存在 → 直接跳过。
+    // ql-20260915-003 修复②（坑 cleanup-meta-fallback）：meta 缺失时不轻信「三缺 = 什么都不
+    // 存在」——先跑 _probeWorktreeRemnants 兜底（git 注册路径 + resolveRuntimeRoot 口径目录），
+    // 任一命中 → 不走早退，按命中路径继续清理（mode 推断 'worktree'，details 记兜底依据）；
+    // 全不命中才跳过，跳过结果带 probePaths 探针清单（CLI 诊断式输出 + doctor 指引）。
     if (!meta && !existsSync(worktreePath) && !existsSync(metaDir)) {
-      return { result: 'skipped', mode: null, details };
+      const probes = this._probeWorktreeRemnants(name);
+      if (probes.hit) {
+        worktreePath = probes.hit.path;
+        const note = `meta 缺失，目录/分支探测兜底（命中：${probes.hit.via}）`;
+        details.push(note);
+        console.warn(`⚠️ ${note}`);
+      } else {
+        return { result: 'skipped', mode: null, details, probePaths: probes.candidates };
+      }
     }
 
     const mode = meta?.mode || 'worktree';
@@ -990,7 +1179,11 @@ export class WorktreeManager {
     if (!force) {
       const check = this.hasUnappliedChanges(name);
       if (check.hasChanges) {
-        console.error(`🚫 worktree cleanup 拒绝：${check.changedFiles.length} 个交付变更未落地主工作区 HEAD，清理会丢失代码。`);
+        // ql-20260915-003 修复② 配套：no-meta fail-closed 拦截时 changedFiles 为空，裸报
+        // 「0 个交付变更」让人误解——0 文件时改报无法判定的原因（保守保留语义不变）。
+        console.error(check.changedFiles.length > 0
+          ? `🚫 worktree cleanup 拒绝：${check.changedFiles.length} 个交付变更未落地主工作区 HEAD，清理会丢失代码。`
+          : `🚫 worktree cleanup 拒绝：无法判定交付是否已全部落地（${check.reason || 'meta 缺失，保守保留'}），保守不清理。`);
         for (const f of check.changedFiles) console.error(`   ${f}`);
         console.error('   请先落地（sillyspec worktree apply <name>）或 commit 到分支，或显式 --force 强制清理。');
         return { result: 'blocked', mode, details: [...details, 'blocked: uncommitted deliverable changes'], residual: [] };
@@ -1012,6 +1205,11 @@ export class WorktreeManager {
       unlinkNodeModulesLinks(worktreePath, meta, details)
     }
 
+    // ql-20260915-003 修复①（坑 junction-foreign-ownership）：cleanup 时同款清扫主仓
+    // node_modules——把本 worktree（及其他历史 worktree）可能遗留的反向链接一并清，
+    // 否则污染 junction 永久滞留主仓，直到下次人工 --force 重装依赖才发现。
+    this._sweepMainForeignJunctionLinks('worktree cleanup', details);
+
     // 1. git worktree remove（带 retry）—— in-place 跳过：无 git worktree 注册，且 worktreePath 即主工作区
     let gitRemoveOk = false;
     if (!isInPlace && existsSync(worktreePath)) {
@@ -1468,7 +1666,12 @@ export class WorktreeManager {
   hasUnappliedChanges(changeName) {
     const name = validateChangeName(changeName);
     const meta = this.getMeta(name);
-    if (!meta) return { hasChanges: false, changedFiles: [], reason: 'no meta' };
+    if (!meta) {
+      // meta 缺失（写坏/误删）→ 无法定位与判定交付，与「目录不存在」同款保守保留（对齐 create()
+      // 幽灵分支的 fail-closed）。旧版返回 hasChanges:false 使 cleanup 跳过未落仓护栏直接
+      // worktree remove --force——可删未提交代码（2026-09-11 审查 P1）
+      return { hasChanges: true, changedFiles: [], reason: 'no meta (conservative keep)' };
+    }
 
     const worktreePath = meta.worktreePath;
     if (!worktreePath || !existsSync(worktreePath)) {
@@ -1596,9 +1799,14 @@ export class WorktreeManager {
     }
 
     if (untrackedFiles.length > 0) {
-      // hash-object 按 argv 顺序逐行输出 blob hash；某文件不存在则整命令失败 → gitQuiet 返回 null
-      const wtHashes = (gitQuiet(worktreePath, ['hash-object', '--', ...untrackedFiles], { timeout: 30000 }) || '')
-        .split('\n');
+      // hash-object 按 argv 顺序逐行输出 blob hash；某文件不存在则整批失败 → 该批各行为空串
+      // （视为未应用，保守保留——与旧整命令失败语义一致，只是失败面从全量缩小到单批）。
+      // 终批-①：argv 分批（批次间行序拼接保持与 untrackedFiles 的索引对齐）。
+      const wtHashes = []
+      for (const batch of _chunkPathsPrivate(untrackedFiles)) {
+        const out = gitQuiet(worktreePath, ['hash-object', '--', ...batch], { timeout: 30000 }) || ''
+        wtHashes.push(...out.split('\n'))
+      }
       const mainBlobs = this._lsTreeBlobs(this.cwd, 'HEAD', untrackedFiles);
       for (let i = 0; i < untrackedFiles.length; i++) {
         // wtHashes[i] 缺失（命令失败/行数不齐）→ 视为未应用，保守保留
@@ -1623,14 +1831,18 @@ export class WorktreeManager {
   _lsTreeBlobs(cwd, treeish, files) {
     const map = new Map();
     if (!files || files.length === 0) return map; // 空 pathspec 会列整棵树，必须拦
-    const raw = gitQuiet(cwd, ['ls-tree', treeish, '--', ...files]);
-    if (!raw) return map;
-    for (const line of raw.split('\n')) {
-      if (!line) continue;
-      const tab = line.indexOf('\t');
-      if (tab === -1) continue;
-      const hash = line.slice(0, tab).split(' ')[2]; // "<mode> <type> <hash>"
-      if (hash) map.set(line.slice(tab + 1), hash);
+    // 终批-①：argv 分批（worktree-apply.js 的 chunkPaths 同逻辑内联——那边 import 本文件，
+    // 反向 import 会成环；两处口径须同步演化）
+    for (const batch of _chunkPathsPrivate(files)) {
+      const raw = gitQuiet(cwd, ['ls-tree', treeish, '--', ...batch]);
+      if (!raw) continue;
+      for (const line of raw.split('\n')) {
+        if (!line) continue;
+        const tab = line.indexOf('\t');
+        if (tab === -1) continue;
+        const hash = line.slice(0, tab).split(' ')[2]; // "<mode> <type> <hash>"
+        if (hash) map.set(line.slice(tab + 1), hash);
+      }
     }
     return map;
   }
@@ -1758,10 +1970,15 @@ export class WorktreeManager {
       // untracked 文件（排除 .sillyspec/.runtime 等）；目录跳过避免 readFileSync EISDIR
       const untracked = gitQuiet(mainCwd, ['ls-files', '--others', '--exclude-standard'], { timeout: 30000 }) || '';
       const skippedDirs = [];
+      const skippedArtifacts = [];
       if (untracked) {
         for (const f of untracked.split('\n').filter(Boolean)) {
           const norm = f.replace(/\\/g, '/')
           if (norm === '.sillyspec' || norm.startsWith('.sillyspec/')) { excludedSpecFiles.push(f); continue }
+          // 产物防御（坑 baseline-checkpoint-binary-sweep）：归档扩展名/超体积帽 untracked 恒不进
+          // baseline checkpoint——289MB tar.gz 入分支（FF 破坏 + 二进制永久入 git）的实际代价兜底
+          const artifactWhy = isCheckpointSkippableArtifact(join(mainCwd, f));
+          if (artifactWhy) { skippedArtifacts.push(`${f}（${artifactWhy}）`); continue }
           const r = copyUntrackedEntry(join(mainCwd, f), join(worktreePath, f));
           if (r.status === 'copied') files.push(f);
           else if (r.status === 'skipped-dir') skippedDirs.push(f);
@@ -1771,6 +1988,10 @@ export class WorktreeManager {
       if (skippedDirs.length > 0) {
         console.log(`ℹ️  baseline overlay 跳过 ${skippedDirs.length} 个 untracked 目录（不读目录避免 EISDIR，坑 execute-worktree-overlay-untracked-dir-eisdir）`);
       }
+      if (skippedArtifacts.length > 0) {
+        console.warn(`⚠️ baseline checkpoint 跳过 ${skippedArtifacts.length} 个产物/大文件（不进分支，留在主仓原位）：${skippedArtifacts.slice(0, 5).join('、')}${skippedArtifacts.length > 5 ? ' 等' : ''}`);
+        console.warn(`   归档/分发物与大文件不该入 git——补 .gitignore（如 *.tar.gz / dist/ / deploy/）或移出仓库；本跳过仅护 baseline checkpoint，git add -A 仍会把它们卷进提交`);
+      }
       // 跨变更 spec 文档隔离可见性：列出被排除的 .sillyspec/ 文件（去重，截断展示），
       // 让「ROADMAP 被谁改动、为何不在本 baseline」在 create 时刻可查，不需事后考古
       const excludedUnique = [...new Set(excludedSpecFiles)]
@@ -1819,8 +2040,12 @@ export class WorktreeManager {
    * @returns {string} commit hash
    */
   _createBaselineCheckpoint(worktreePath, changeName, baselineFiles = []) {
-    // 使用临时 git identity，避免用户未配置 user.name/user.email 导致失败
+    // 临时 git identity（用户未配置 user.name/email 时兜底）。终批-③：{ ...process.env } 展开
+    // 而非裸替换——裸 env 丢 SystemRoot/USERPROFILE/TEMP（Windows 上 git 直接起不来）；
+    // 提交走统一 git() 入口（safe.directory/timeout/maxBuffer 与全仓其他调用同口径——
+    // 旧裸 execFileSync 在 dubious-ownership 环境（CI/挂载盘）必败且无超时无 maxBuffer）。
     const env = {
+      ...process.env,
       GIT_AUTHOR_NAME: 'sillyspec',
       GIT_AUTHOR_EMAIL: 'sillyspec@baseline',
       GIT_COMMITTER_NAME: 'sillyspec',
@@ -1845,10 +2070,10 @@ export class WorktreeManager {
       // 分支上以便区分「前置 baseline」与「子代理新增改动」。它不该触发项目 pre-commit
       // hook（如 ruff format），否则主仓库 dirty 文件中任一不达标的会被 hook reformat
       // 致 commit 失败 → worktree 创建失败 → execute 无法启动。
-      execFileSync(
-        'git',
+      git(
+        worktreePath,
         ['commit', '--no-verify', '-m', `sillyspec: baseline checkpoint for ${changeName}${body}`],
-        { cwd: worktreePath, encoding: 'utf8', stdio: ['pipe','pipe','pipe'], env }
+        { timeout: 30000, env }
       );
       const hash = git(worktreePath, ['rev-parse', 'HEAD']);
       console.log(`📌 baseline checkpoint: ${hash}`);