sillyspec 3.27.5 → 3.27.7

package/.worktrees/8d2d0392/src/worktree-deps.js

@@ -0,0 +1,576 @@
+/**
+ * worktree-deps.js — Worktree 依赖供给引擎
+ *
+ * 在 worktree.create() 的 baseline overlay 之后调用，让 worktree 立即可构建/测试。
+ * 策略：junction/symlink 快路径（lockfile 一致）+ install 兜底；多语言按 local.yaml
+ * project.type + lockfile 推断 install 命令。供给可失败，但状态写进 meta 供验证硬门读取。
+ *
+ * 见 change 2026-06-28-worktree-deps-provision / D-005@v1, D-007@v1。
+ */
+
+import { existsSync, readFileSync, realpathSync, lstatSync } from 'fs';
+import { join, isAbsolute, relative, resolve as resolvePath, sep as pathSep } from 'path';
+import { execFileSync } from 'child_process';
+import { createHash } from 'crypto';
+
+const LOCKFILES = ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock'];
+const DEFAULT_TIMEOUT_MS = 300 * 1000;
+
+/**
+ * 取目录下首个命中的 lockfile 的 sha256 前 16 位；
+ * 无 lockfile 则 hash package.json；都没有返回 null。
+ */
+export function lockfileHash(dir) {
+  if (!dir || !existsSync(dir)) return null;
+  for (const lf of LOCKFILES) {
+    const p = join(dir, lf);
+    if (existsSync(p)) {
+      return createHash('sha256').update(readFileSync(p)).digest('hex').slice(0, 16);
+    }
+  }
+  const pkg = join(dir, 'package.json');
+  if (existsSync(pkg)) {
+    return createHash('sha256').update(readFileSync(pkg)).digest('hex').slice(0, 16);
+  }
+  return null;
+}
+
+/** 命中目录下的 lockfile 文件名（用于判断 nodejs 子类）*/
+function detectLockfile(dir) {
+  if (!dir || !existsSync(dir)) return null;
+  for (const lf of LOCKFILES) {
+    if (existsSync(join(dir, lf))) return lf;
+  }
+  return null;
+}
+
+/**
+ * 读取 local.yaml 文本（specBase 优先，回退 worktreePath/.sillyspec；不读 process.cwd 避免环境配置泄漏）。
+ * 返回 { text, source }——source 标记信任级（体检 SEC-01）：
+ *   - 'specBase'：主仓配置，可信（其 commands.install 允许执行，仍过白名单+元字符门）
+ *   - 'worktree'：worktree 内副本，agent/子代理可写区——只作 project.type / modules 等
+ *     只读探测，其 commands.install 永不执行（否则绕过 worktree-guard 的危险命令拦截）
+ */
+function readLocalYamlSourced(specBase, worktreePath) {
+  if (specBase) {
+    const p = join(specBase, 'local.yaml');
+    if (existsSync(p)) return { text: readFileSync(p, 'utf8'), source: 'specBase' };
+  }
+  if (worktreePath) {
+    const p = join(worktreePath, '.sillyspec', 'local.yaml');
+    if (existsSync(p)) return { text: readFileSync(p, 'utf8'), source: 'worktree' };
+  }
+  return { text: null, source: null };
+}
+
+/** 兼容旧签名：只要文本 */
+function readLocalYaml(specBase, worktreePath) {
+  return readLocalYamlSourced(specBase, worktreePath).text;
+}
+
+/** 从 local.yaml 文本提取 commands.install（轻量正则，不引 yaml 依赖，与 scan-postcheck 一致）*/
+function extractUserInstall(yamlText) {
+  if (!yamlText) return null;
+  // 匹配 commands: 段下的 install: "..." 或 install: '...'（unavailable 视为无）
+  const m = yamlText.match(/install:\s*["']([^"']+)["']/);
+  if (m && m[1] && m[1].toLowerCase() !== 'unavailable') return m[1];
+  return null;
+}
+
+/** 从 local.yaml 提取 project.type；缺失时按文件特征推断 */
+export function detectProjectType(worktreePath, specBase) {
+  const yamlText = readLocalYaml(specBase, worktreePath);
+  if (yamlText) {
+    const m = yamlText.match(/type:\s*(\S+)/);
+    if (m && m[1]) return m[1];
+  }
+  if (existsSync(join(worktreePath, 'pom.xml'))) return 'maven';
+  if (existsSync(join(worktreePath, 'build.gradle')) || existsSync(join(worktreePath, 'build.gradle.kts'))) return 'gradle';
+  if (existsSync(join(worktreePath, 'package.json'))) return 'nodejs';
+  // Python：pyproject.toml（uv/poetry/pdm）或 requirements.txt（pip）——治 worktree 内 ruff/pre-commit 等
+  // 二进制不供给（exec 复盘 3-②：detectProjectType 原无 python 分支，python 项目根被误判 generic → n/a）
+  if (existsSync(join(worktreePath, 'pyproject.toml')) || existsSync(join(worktreePath, 'requirements.txt'))) return 'python';
+  return 'generic';
+}
+
+/** 按 project.type + lockfile 推断 install 命令（无 commands.install 时）*/
+export function inferInstallCommand(projectType, worktreePath, userInstall) {
+  if (userInstall) return userInstall;
+  switch (projectType) {
+    case 'nodejs':
+      if (existsSync(join(worktreePath, 'pnpm-lock.yaml'))) return 'pnpm install --frozen-lockfile';
+      if (existsSync(join(worktreePath, 'package-lock.json'))) return 'npm ci';
+      if (existsSync(join(worktreePath, 'yarn.lock'))) return 'yarn install --frozen-lockfile';
+      return 'npm install'; // 无 lockfile 兜底（X-2）
+    case 'maven':
+      return 'mvn -o test';
+    case 'gradle':
+      // win32 cmd.exe 跑不了 ./gradlew（体检 BUG-08 同型）：优先 gradlew.bat，否则全局 gradle
+      if (process.platform === 'win32') {
+        return existsSync(join(worktreePath, 'gradlew.bat')) ? 'gradlew.bat test' : 'gradle test';
+      }
+      return './gradlew test';
+    case 'python':
+      // uv 优先（现代 Python 工具链，pyproject.toml/uv.lock 项目走 uv sync 建 .venv + 装依赖，
+      // 与 execute worktree 环境预告一致）；纯 requirements.txt（无 pyproject）回退 pip
+      if (existsSync(join(worktreePath, 'uv.lock')) || existsSync(join(worktreePath, 'pyproject.toml'))) return 'uv sync';
+      return 'pip install -r requirements.txt';
+    default:
+      return null; // generic → n/a
+  }
+}
+
+/** 在 worktreePath 创建 node_modules 链接到 mainNodeModules；失败回退 */
+function tryLink(mainNodeModules, linkPath) {
+  // 已存在：确认是否已指向 main（幂等）
+  if (existsSync(linkPath)) {
+    try {
+      const resolved = realpathSync(linkPath);
+      const resolvedTarget = realpathSync(mainNodeModules);
+      if (resolved === resolvedTarget) return { ok: true, method: process.platform === 'win32' ? 'junction' : 'symlink' };
+    } catch {}
+    // 真实目录 ≠ 已有依赖（坑 provision-preexisting-dir-fake-linked，2026-08-23 实证：doctor --fix
+    // 报 re-provisioned 但链接没建——worktree node_modules 是 install 半途中断残留的真实目录时，
+    // realpath 不等 main → 被 preexisting 短路标 ok，根快路径据此写 depsStatus=linked，一个链接
+    // 都没建且后验证 existsSync 对空/残目录照样过）。真实目录 → ok:false + preexistingDir 标记，
+    // 交调用方决策：根快路径降级 tryInstall 真重建（宁可重装不说谎）；linkOneDir 视为本地安装
+    // 保留（installed 语义，合法状态）。指向别处的 link 仍是「他者安装」，尊重不 clobber。
+    try {
+      if (!lstatSync(linkPath).isSymbolicLink()) {
+        return { ok: false, preexistingDir: true, error: `node_modules 已存在且为真实目录（非链接，疑似 install 残留）: ${linkPath}` };
+      }
+    } catch {}
+    // 指向别处 → 不 clobber，视为已有依赖（installed 语义）
+    return { ok: true, method: 'install', preexisting: true };
+  }
+  // broken junction 清理（existsSync 对目标丢失的 junction/symlink 返回 false，但目录项占位会使
+  // mklink/ln 撞名失败 → 根：落 install 慢路径；子模块：linkOneDir failed。此坑在 _doctorReprovision
+  // 的解链段同样存在——它也用 existsSync 前置判断，broken junction 永远解不掉）：lstat 是 link 而
+  // existsSync false → 删目录项后重建（rmdir 删 junction 不跟随 reparse，与 worktree.js 解链同款）。
+  try {
+    if (lstatSync(linkPath).isSymbolicLink()) {
+      if (process.platform === 'win32') {
+        execFileSync('cmd.exe', ['/c', 'rmdir', linkPath], { stdio: ['pipe', 'pipe', 'pipe'] });
+      } else {
+        unlinkSync(linkPath);
+      }
+    }
+  } catch { /* lstat 抛 = 目录项真不存在，直接建 */ }
+  try {
+    if (process.platform === 'win32') {
+      // execFileSync 数组形式不经 shell：POSIX 双引号内 `/$() 会执行、cmd.exe 双引号内 %VAR% 仍展开，
+      // linkPath 含 local.yaml 模块 path，属项目内可配置值（安全收敛，与 git-helper 同范式）
+      execFileSync('cmd.exe', ['/c', 'mklink', '/J', linkPath, mainNodeModules], { stdio: ['pipe', 'pipe', 'pipe'] });
+    } else {
+      execFileSync('ln', ['-s', mainNodeModules, linkPath], { stdio: ['pipe', 'pipe', 'pipe'] });
+    }
+    // 创建后实物复核（坑 provision-silent-fake-installed 第②层，2026-08-21 实证：doctor 报
+    // re-provisioned 成功但 junction 实际没建）——mklink/ln 退出码 0 不等于链接落盘（cmd.exe
+    // 垫片链存在静默失败面），lstat+existsSync 复核不存在即判失败，交由调用方走 install 兜底
+    //（junction（reparse point）与 symlink 的 lstat 均报 isSymbolicLink=true）
+    try {
+      const st = lstatSync(linkPath);
+      if (!st.isSymbolicLink() || !existsSync(linkPath)) {
+        return { ok: false, error: 'link 创建后复核失败：lstat 非 link 或路径不可达' };
+      }
+    } catch (e) {
+      return { ok: false, error: `link 创建后复核失败（lstat ${e.message}）` };
+    }
+    return { ok: true, method: process.platform === 'win32' ? 'junction' : 'symlink' };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+/**
+ * 执行 install 命令（带超时）。
+ *
+ * 安全收口（体检 SEC-01）：commands.install 来自 local.yaml 配置，若经 execSync(shell)
+ * 原样执行，yaml 里的 `$(...)`/反引号/`;` 必然被解释——且 worktree 副本属 agent 可写区。
+ * 三道门：
+ *   1. 调用方保证来源可信（provisionDeps 只对 source==='specBase' 的 userInstall 走到这里）
+ *   2. 可执行前缀白名单（包管理器家族）
+ *   3. shell 元字符黑名单（win32 额外拦 %，cmd.exe 会展开 %VAR%），通过后拆 argv 数组执行不经 shell
+ *
+ * 链式命令支持（坑 worktree-install-whitelist-monorepo-chain，2026-08-20 实证）：monorepo 的
+ * commands.install 常为链式写法（`cd web && pnpm install` / `npm install && npm run build:pkg`），
+ * 旧实现整条过白名单 + 元字符门，`&&` 必拒 → depsStatus=failed → execute deps 门控卡死且无自愈
+ * 路径（改 local.yaml 成单命令对需要 post-install build 的 monorepo 不可行）。现按 `&&` 拆段
+ * 逐段校验执行：每段独立过白名单 + 元字符门（拆分后残余的单 `&`/`|`/`;` 仍被元字符门拦），
+ * 段内允许 `cd <相对子路径>`（resolve 后必须仍在 worktree 根内，防越界建产物/读外部），
+ * 全程 argv 数组执行不经 shell、任一段失败即停（&& 语义）。安全面不变：每个执行段仍是
+ * 白名单包管理器命令，`||`/管道/`;`/后台均不支持。
+ */
+const INSTALL_BINARY_WHITELIST = /^(?:\.\/)?(?:pnpm|npm|yarn|bun|mvn|gradle|gradlew|uv|pip|pip3|python|python3|poetry|make)(?:\.cmd|\.bat|\.exe)?(?:\s|$)/;
+const SHELL_METACHARS = /[;&|<>$`\n]/;
+const WIN_SHELL_METACHARS = /[;&|<>$`\n%]/;
+const CD_SEGMENT_RE = /^cd\s+([^\s]+)$/;
+
+function tryInstall(cmd, cwd, timeout) {
+  const trimmed = String(cmd || '').trim();
+  if (!trimmed) {
+    return { ok: false, error: 'install 命令为空' };
+  }
+  const metaRe = process.platform === 'win32' ? WIN_SHELL_METACHARS : SHELL_METACHARS;
+  // && 拆段（单段命令与原路径完全一致，零回归）；空段（`a &&`/`&& b`）视为畸形命令拒绝
+  const segments = trimmed.split('&&').map(s => s.trim());
+  if (segments.some(s => s === '')) {
+    return { ok: false, error: `install 链式命令含空段，拒绝执行: ${trimmed}` };
+  }
+  let curCwd = cwd;
+  const root = resolvePath(cwd);
+  const planned = [];
+  for (const seg of segments) {
+    // 白名单先于元字符（保持原判定顺序）：`curl … | sh` 报非白名单而非元字符，
+    // `npm install; rm …` 过白名单后被元字符门拦——两类拒绝语义与原实现一致
+    const cd = seg.match(CD_SEGMENT_RE);
+    if (!cd && !INSTALL_BINARY_WHITELIST.test(seg)) {
+      return { ok: false, error: `install 命令不在包管理器白名单内，拒绝执行: ${seg}（支持 && 链式与 cd <子目录> 段，各执行段仍须为白名单包管理器命令）` };
+    }
+    if (metaRe.test(seg)) {
+      return { ok: false, error: `install 命令段含 shell 元字符，拒绝执行: ${seg}（链式仅支持 &&；|| / 管道 / ; / 后台不支持）` };
+    }
+    if (cd) {
+      const target = resolvePath(curCwd, cd[1]);
+      if (target !== root && !target.startsWith(root + pathSep)) {
+        return { ok: false, error: `install 命令的 cd 段越出 worktree 根，拒绝执行: ${seg}（cwd ${cwd}）` };
+      }
+      curCwd = target;
+      continue;
+    }
+    planned.push(seg);
+  }
+  for (const seg of planned) {
+    const argv = seg.split(/\s+/);
+    try {
+      if (process.platform === 'win32') {
+        // Windows 包管理器是 .cmd 垫片，无 shell 的 spawn 无法解析——经 cmd.exe /c 传参；
+        // 元字符（含 %）已拦，残余风险与 tryLink 的 mklink 同款
+        execFileSync('cmd.exe', ['/c', ...argv], { cwd: curCwd, timeout, stdio: ['pipe', 'pipe', 'pipe'] });
+      } else {
+        execFileSync(argv[0], argv.slice(1), { cwd: curCwd, timeout, stdio: ['pipe', 'pipe', 'pipe'] });
+      }
+    } catch (e) {
+      const msg = e.killed ? `timeout after ${timeout}ms` : ((e.stderr && e.stderr.toString()) || e.message);
+      return { ok: false, error: `${seg} failed (cwd ${curCwd}): ${msg}` };
+    }
+  }
+  return { ok: true };
+}
+
+/** 目录是否含 nodejs 标记（package.json 或任一 lockfile）——识别 monorepo 里的 nodejs 子模块 */
+function hasNodeMarker(dir) {
+  if (!dir || !existsSync(dir)) return false;
+  if (existsSync(join(dir, 'package.json'))) return true;
+  return LOCKFILES.some(lf => existsSync(join(dir, lf)));
+}
+
+/**
+ * 从 local.yaml 提取 modules 块的 path 列表（generic monorepo 子模块路径）。
+ * 兼容 inline flow（`frontend: { path: "frontend/" }`）与 block（`frontend:\n    path: frontend/`）。
+ * 轻量正则，不引 yaml 依赖（与 extractUserInstall / scan-postcheck 风格一致）。
+ * 坑 execute-worktree-pnpm-monorepo-no-node-modules：generic 项目 worktree 子模块无 node_modules。
+ * @returns {string[]} 去重 + 去 trailing 斜杠的相对路径
+ */
+function extractModulePaths(yamlText) {
+  if (!yamlText) return [];
+  const idx = yamlText.search(/^modules:\s*$/m);
+  if (idx < 0) return [];
+  const nlIdx = yamlText.indexOf('\n', idx);
+  if (nlIdx < 0) return [];
+  let rest = yamlText.slice(nlIdx + 1);
+  const nextTop = rest.search(/^\S/m); // 下一个顶层 key（行首非空白）
+  const block = nextTop >= 0 ? rest.slice(0, nextTop) : rest;
+  const paths = [];
+  const re = /path:\s*["']?([^"'\s,}]+)/g;
+  let pm;
+  while ((pm = re.exec(block)) !== null) {
+    const p = pm[1].replace(/\/+$/, '').trim();
+    if (p && p !== '.') paths.push(p);
+  }
+  return [...new Set(paths)];
+}
+
+/**
+ * modules 块 path 安全校验（体检 SEC-07）：只允许 worktree 内的相对子路径——
+ * 拒绝绝对路径与 `..` 段，防止 local.yaml 配置把 junction/symlink 建到 worktree 之外。
+ */
+function isSafeModulePath(p) {
+  if (!p || isAbsolute(p)) return false;
+  const segs = p.split(/[\\/]+/);
+  return !segs.includes('..');
+}
+
+/**
+ * 对单个子模块目录 tryLink main 的 node_modules → wt 的 node_modules（modules 子模块专用）。
+ * 仅走 link 快路径（不 install——子模块 install 慢且易失败；lockfile 不一致时交给用户 pnpm install）。
+ * lockfile 一致才 link，避免误链不匹配的 deps。
+ */
+function linkOneDir(wtDir, mainDir) {
+  const mainNodeModules = join(mainDir, 'node_modules');
+  if (!existsSync(mainNodeModules)) return { status: 'skipped', reason: 'main 无 node_modules' };
+  const wtHash = lockfileHash(wtDir);
+  const mainHash = lockfileHash(mainDir);
+  if (wtHash && mainHash && wtHash !== mainHash) {
+    return { status: 'mismatch', reason: `lockfile 不一致 main=${mainHash} wt=${wtHash}` };
+  }
+  const r = tryLink(mainNodeModules, join(wtDir, 'node_modules'));
+  if (r.ok) return { status: 'linked', method: r.method };
+  // 真实目录 = 子模块本地安装过（合法状态，如 mismatch 后用户手动 pnpm install）：保留为
+  // installed 真话，不假 linked 也不误报 failed（tryLink 的 preexistingDir 细分见其注释）
+  if (r.preexistingDir) return { status: 'installed', reason: '子模块 node_modules 为真实目录（本地安装），保留' };
+  return { status: 'failed', error: r.error };
+}
+
+/**
+ * 供给依赖。返回 deps 状态对象（合并进 meta）。两段：
+ *   1. 根目录供给（原有逻辑：lockfile 一致 link / 不一致 install / generic→根 n/a）
+ *   2. modules 块的 nodejs 子模块 link（generic monorepo：根无 deps 但 frontend/daemon 等子模块需要）
+ * generic + 子模块 link 成功时，整体 depsStatus 从 n/a 升级为 linked（deps gate 不再误判 unknown 阻断）。
+ *
+ * @param {string} worktreePath - worktree 根目录
+ * @param {string} mainCwd - 主 checkout 根目录（node_modules 来源）
+ * @param {{ specBase?: string, timeout?: number, force?: boolean }} opts
+ *   - force=true（doctor --fix 强制重装）：绕过根目录 lockfile 一致快路径（下方 line 216 区块），
+ *     强制走 install 分支重装。该快路径是 tryLink 的唯一根调用点，绕过它即同时绕过 tryLink
+ *     的 preexisting 幂等短路（101-110），实现"强制重装"语义。配合调用方先解 junction
+ *     （worktree.js _doctorReprovision），避免 install 经 junction 误改主仓 node_modules。
+ *     modules 子模块 link 不受 force 影响（仅根 install）。
+ * @returns {{ depsStatus, depsMethod, depsSource, depsLockHash, depsCheckedAt, depsError?, depsModules? }}
+ */
+export function provisionDeps(worktreePath, mainCwd, opts = {}) {
+  const { specBase = null, timeout = DEFAULT_TIMEOUT_MS, force = false } = opts;
+  const depsCheckedAt = new Date().toISOString();
+  const { text: yamlText, source: yamlSource } = readLocalYamlSourced(specBase, worktreePath);
+  const wtHash = lockfileHash(worktreePath);
+
+  // ── 1. 根目录供给 ──
+  const projectType = detectProjectType(worktreePath, specBase);
+  // SEC-01：commands.install 只信主仓 specBase 的 local.yaml——worktree 副本是 agent 可写区，
+  // 其 install 命令若执行等于绕过 worktree-guard 的危险命令拦截
+  const userInstall = yamlSource === 'specBase' ? extractUserInstall(yamlText) : null;
+  if (yamlSource === 'worktree' && extractUserInstall(yamlText)) {
+    console.warn('⚠️ worktree 内 local.yaml 的 commands.install 被忽略（agent 可写区，只信主仓 .sillyspec/local.yaml）');
+  }
+  const installCmd = inferInstallCommand(projectType, worktreePath, userInstall);
+
+  let result;
+  if (!installCmd) {
+    // generic / 无可执行 install → 根无 deps 动作（n/a）；但下方 modules 子模块仍可能 link 升级
+    result = { depsStatus: 'n/a', depsMethod: null, depsSource: null, depsLockHash: wtHash };
+  } else {
+    // 快路径：main 有 node_modules 且 lockfile hash 一致 → junction/symlink
+    // force=true 时绕过（doctor --fix 强制重装；绕过此块即同时绕过 tryLink 101-110 幂等短路）
+    const mainNodeModules = mainCwd ? join(mainCwd, 'node_modules') : null;
+    const mainHash = lockfileHash(mainCwd);
+    let linked = false;
+    if (!force && mainNodeModules && existsSync(mainNodeModules) && mainHash && wtHash && mainHash === wtHash) {
+      const linkResult = tryLink(mainNodeModules, join(worktreePath, 'node_modules'));
+      if (linkResult.ok) {
+        result = {
+          depsStatus: 'linked',
+          depsMethod: linkResult.method,
+          depsSource: linkResult.preexisting ? 'install' : 'main-checkout',
+          depsLockHash: wtHash,
+        };
+        linked = true;
+      }
+    }
+    if (!linked) {
+      // 兜底：install
+      const installResult = tryInstall(installCmd, worktreePath, timeout);
+      result = installResult.ok
+        ? { depsStatus: 'installed', depsMethod: 'install', depsSource: 'install', depsLockHash: wtHash }
+        : { depsStatus: 'failed', depsMethod: null, depsSource: null, depsLockHash: wtHash, depsError: installResult.error };
+    }
+    // ── 结果后验证（坑 provision-silent-fake-installed，2026-08-21 Windows 实证；
+    //    坑 provision-monorepo-subpackage-fake-installed，2026-08-22 复发：pnpm monorepo
+    //    workspace 根 package.json 的 dependencies 常为空（依赖在 frontend/daemon 子包），
+    //    只查根会把 installed 状态整体跳过——doctor 标 installed 但子包 node_modules 全缺，
+    //    Wave 1 测试才挂）。分层校验：
+    //   linked：根 junction 实存硬校验（link 声称成功必留痕）；
+    //   installed：校验目标集 = 根 + local.yaml modules 块声明的含 package.json 子模块，
+    //     其中【声明了依赖】的目录逐一要求 node_modules 存在（pnpm/npm/yarn workspace
+    //     安装都会给子包建 node_modules；无依赖声明的空壳目录合法地不建，不校验）。
+    //   python/.venv、jvm 本地仓库本就不适用（整体仅 nodejs）。
+    if (projectType === 'nodejs') {
+      const pkgHasDeps = (dir) => {
+        try {
+          const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'))
+          return ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']
+            .some(k => pkg[k] && Object.keys(pkg[k]).length > 0)
+        } catch { return false }
+      }
+      // 目标集：根 + modules 块内含 package.json 的安全子模块（monorepo 子包）
+      const verifyDirs = [worktreePath]
+      for (const mp of extractModulePaths(yamlText)) {
+        if (!isSafeModulePath(mp)) continue
+        const sub = join(worktreePath, mp)
+        if (existsSync(join(sub, 'package.json'))) verifyDirs.push(sub)
+      }
+      const depsDeclaredDirs = verifyDirs.filter(pkgHasDeps)
+      const needVerify = result.depsStatus === 'linked'
+        || (result.depsStatus === 'installed' && depsDeclaredDirs.length > 0)
+      if (needVerify) {
+        // linked 只验根（junction 语义）；installed 验全部声明依赖的目标目录
+        const targets = result.depsStatus === 'linked' ? [worktreePath] : depsDeclaredDirs
+        const missing = targets.filter(dir => !existsSync(join(dir, 'node_modules')))
+        if (missing.length > 0) {
+          const missingRel = missing.map(dir => relative(worktreePath, dir) || '(根)')
+          result = {
+            depsStatus: 'failed', depsMethod: null, depsSource: null, depsLockHash: wtHash,
+            depsError: `${result.depsStatus} 后验证失败：${missingRel.join('、')} 的 node_modules 不存在（报成功但实际未落盘——Windows 静默失败面：cmd.exe 垫片解析/杀毒拦截/frozen-lockfile 快退）。` +
+              `手动兜底：进 worktree 手动跑 ${installCmd}（子包随 workspace 一起装），或对 lockfile 一致的目录用 junction：New-Item -ItemType Junction -Path "<目标>/node_modules" -Target "<主仓对应目录>/node_modules"，然后重试 doctor --fix`,
+          }
+        }
+      }
+    }
+  }
+  result.depsCheckedAt = depsCheckedAt;
+
+  // ── 2. modules 块的 nodejs 子模块 link（坑 execute-worktree-pnpm-monorepo-no-node-modules）──
+  // generic monorepo（如 multi-agent-platform）worktree 子模块 frontend/sillyhub-daemon 无 node_modules，
+  // 跑 pnpm test 失败。读 local.yaml modules 块，对 nodejs 子模块 tryLink main 的 node_modules。
+  const modulePaths = extractModulePaths(yamlText);
+  const moduleResults = [];
+  for (const mp of modulePaths) {
+    if (!isSafeModulePath(mp)) {
+      moduleResults.push({ path: mp, status: 'skipped', reason: 'path 越界（绝对路径或 .. 段），拒绝 link' });
+      continue;
+    }
+    const wtDir = join(worktreePath, mp);
+    const mainDir = mainCwd ? join(mainCwd, mp) : null;
+    if (!existsSync(wtDir) || !mainDir || !hasNodeMarker(wtDir)) continue;
+    moduleResults.push({ path: mp, ...linkOneDir(wtDir, mainDir) });
+  }
+
+  if (moduleResults.length > 0) {
+    result.depsModules = moduleResults;
+    const linkedModules = moduleResults.filter(m => m.status === 'linked');
+    if (linkedModules.length > 0 && result.depsStatus === 'n/a') {
+      // 标 generic 但子模块 link 成功 → 升级为 linked（deps gate 不再误判 unknown 阻断 execute）
+      result.depsStatus = 'linked';
+      result.depsMethod = linkedModules[0].method;
+      result.depsSource = 'main-checkout';
+    }
+    // 子模块 link 后验证（坑 modules-submodule-link-verify，2026-08-23 实证：Windows 下漏链
+    // frontend node_modules——linkOneDir 报 linked 但 junction 实际未建或 main 侧本就没有）。
+    // linked 状态的子模块逐一核验 wt/<mp>/node_modules 实存：缺失降 failed 并给兜底指引
+    //（不静默放行——跑测试时才发现就晚了）。
+    for (const m of moduleResults) {
+      if (m.status !== 'linked') continue
+      const nmPath = join(worktreePath, m.path, 'node_modules')
+      if (!existsSync(nmPath)) {
+        m.status = 'failed'
+        m.error = `linked 后验证失败：${m.path}/node_modules 不存在（报成功但实际未落盘）。兜底：New-Item -ItemType Junction -Path "<wt>/${m.path}/node_modules" -Target "<主仓>/${m.path}/node_modules"`
+      }
+    }
+    const failedModules = moduleResults.filter(m => m.status === 'failed');
+    if (failedModules.length > 0) {
+      const fmsg = failedModules.map(m => `${m.path}: ${m.error}`).join('; ');
+      result.depsError = result.depsError ? `${result.depsError}; ${fmsg}` : fmsg;
+    }
+    // mismatch 可见性（坑 modules-mismatch-invisible，2026-08-23 实证：mismatch/skipped 只写
+    // depsModules 而 src 内零消费——doctor 报 re-provisioned 成功、子模块实际无链接且无任何
+    // 提示）。mismatch（worktree 与主仓 lockfile 不一致，link 不适用）摘要进 depsError：可见、
+    // 落 meta、doctor msg 带出（_doctorReprovision 不再抹）；但不降级 depsStatus——mismatch 是
+    // 配置分叉态不是供给失败，降级会经 deps gate 卡死 execute（正确动作是用户在 worktree 跑
+    // pnpm install 或对齐 lockfile， doctor --fix 的 force 重装路径也会覆盖此场景）。
+    const mismatchModules = moduleResults.filter(m => m.status === 'mismatch');
+    if (mismatchModules.length > 0) {
+      const mmsg = `子模块 lockfile 与主仓不一致（未链接，本地 install 或对齐 lockfile）: ${mismatchModules.map(m => m.path).join('、')}`;
+      result.depsError = result.depsError ? `${result.depsError}; ${mmsg}` : mmsg;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 统一的 worktree deps 新鲜度判定（H1，change 2026-08-05-tooling-feedback-fixes）。
+ * 供 doctor（worktree.js）与 ensureDepsFreshness（run/stage.js）共用，消除两处双写漂移。
+ *
+ * 判定优先级：failed → missing → stale → main-drift → fresh
+ *   - failed: meta.depsStatus==='failed'（上次供给失败，占最高优先级）
+ *   - missing: depsStatus ∈ {linked, installed} 且 node_modules 不存在
+ *   - stale: wtHash 与 meta.depsLockHash 不一致（worktree 自身 lockfile 在上次供给后变化）
+ *   - main-drift: wtHash 与主仓 mainHash 不一致（主仓 lockfile 漂移；复用 linkOneDir 177-178 的 mismatch 判据）
+ *   - fresh: 其余情况
+ *
+ * lockfileHash 返回 null（无 lockfile/package.json）时相关比较优雅降级——不报 stale / main-drift，
+ * 避免无 lockfile 项目（如纯 generic / 非 nodejs）误判漂移。
+ *
+ * @param {object} [meta] - worktree meta（读 depsStatus / depsLockHash / depsError）
+ * @param {string} wtPath - worktree 根目录
+ * @param {string} mainCwd - 主 checkout 根目录
+ * @returns {{ status: 'fresh'|'missing'|'stale'|'main-drift'|'failed', detail: string, wtHash: (string|null), mainHash: (string|null), metaLockHash: (string|null) }}
+ */
+export function checkDepsFreshness(meta, wtPath, mainCwd) {
+  const depsStatus = meta && meta.depsStatus ? meta.depsStatus : null;
+  const metaLockHash = meta && meta.depsLockHash ? meta.depsLockHash : null;
+  const wtHash = lockfileHash(wtPath);
+  const mainHash = lockfileHash(mainCwd);
+
+  // 1. failed 最高优先级（对齐 task-01 蓝图：failed → missing → stale → main-drift → fresh）
+  if (depsStatus === 'failed') {
+    return {
+      status: 'failed',
+      detail: '上次依赖供给失败' + (meta && meta.depsError ? ': ' + meta.depsError : ''),
+      wtHash, mainHash, metaLockHash,
+    };
+  }
+
+  // 2. missing：曾 link/install 但 node_modules 已丢失（对齐 doctor 914-915 / ensure 403）
+  const nmExists = wtPath ? existsSync(join(wtPath, 'node_modules')) : false;
+  if (['linked', 'installed'].includes(depsStatus) && !nmExists) {
+    return {
+      status: 'missing',
+      detail: `meta.depsStatus=${depsStatus} 但 node_modules 缺失`,
+      wtHash, mainHash, metaLockHash,
+    };
+  }
+
+  // 2b. 子模块 missing（坑 modules-submodule-missing-no-selfheal）：meta.depsModules 中 linked
+  // 状态的子模块逐一核验 wt/<mp>/node_modules 实存。provisionDeps 内的同款核验（坑
+  // modules-submodule-link-verify）只管供给时刻，此后 junction 被删（杀毒/手工误删/半途清理）
+  // 时本函数只查根（上方）→ 永远 fresh → doctor 不再报 → 漏链永不自愈。此处补 doctor 侧
+  // 闭环：缺失 → missing → doctor --fix 走 relinkFirst 重链（provisionDeps 非 force 路径
+  // 的 linkOneDir 对缺失目录直接重建 junction）。
+  if (Array.isArray(meta && meta.depsModules)) {
+    const missingMods = meta.depsModules.filter(m =>
+      m && m.status === 'linked' && typeof m.path === 'string'
+      && !existsSync(join(wtPath, m.path, 'node_modules')));
+    if (missingMods.length > 0) {
+      return {
+        status: 'missing',
+        detail: `${missingMods.length} 个 linked 子模块 node_modules 缺失: ${missingMods.map(m => m.path).join('、')}`,
+        wtHash, mainHash, metaLockHash,
+      };
+    }
+  }
+
+  // 3. stale：worktree 自身 lockfile 与 meta 快照不一致（对齐 doctor 916-917 / ensure 404）
+  if (metaLockHash && wtHash && wtHash !== metaLockHash) {
+    return {
+      status: 'stale',
+      detail: `lockfile 变化 (${metaLockHash} -> ${wtHash})`,
+      wtHash, mainHash, metaLockHash,
+    };
+  }
+
+  // 4. main-drift（新增）：wtHash 与主仓 mainHash 不一致——主仓 lockfile 更新过、worktree 未跟
+  if (wtHash && mainHash && wtHash !== mainHash) {
+    return {
+      status: 'main-drift',
+      detail: `worktree lockfile 与主仓不一致 (wt=${wtHash} main=${mainHash})`,
+      wtHash, mainHash, metaLockHash,
+    };
+  }
+
+  // 5. fresh
+  return {
+    status: 'fresh',
+    detail: '依赖新鲜',
+    wtHash, mainHash, metaLockHash,
+  };
+}