sillyspec 3.27.7 → 3.27.11

package/src/worktree-cross.js

@@ -0,0 +1,294 @@
+/**
+ * worktree-cross.js — 跨仓仓 worktree 隔离（坑 cross-repo-no-worktree-isolation，2026-08-27 用户实证）。
+ *
+ * 背景：跨仓 task 的原设计（multi-repo W1 D-005/D-006/D-009）是子代理直写跨仓仓主工作副本、
+ * commit 直落该仓主干，apply 对跨仓 no-op。实战暴露三类事故面：
+ *   1. 并行混流：跨仓主工作副本常有用户/其他变更的在途改动，子代理产物与之混在同一工作区，
+ *      无法区分归属、无法整体回滚（实证：sub-grid-security 主工作副本 task-05 产物与
+ *      .gitignore/.webpackrc.js/yarn.lock 并行改动混流，无法核对）；
+ *   2. 无 base 锚：跨仓仓无 meta/baseHash，base 只能靠 task 卡 base_commit 锡点；
+ *   3. 误伤面大：子代理在主工作副本可误改/误删用户未提交文件，无护栏。
+ *
+ * 本模块把跨仓仓纳入与主仓同构的 worktree 隔离（D-009 就地翻新，向后兼容）：
+ *   - worktree 落位 <主仓 specBase>/.runtime/worktrees/<change>--<repoKey>：主仓侧该目录已被
+ *     .gitignore 覆盖（主仓 create 已强制检查），不要求跨仓仓自配 .gitignore；git worktree
+ *     的注册信息在跨仓 .git/worktrees/，目录本身可在仓外任意路径；
+ *   - meta.json 与主仓同 schema + repoKey/crossRepoRoot/isCross 标识（唯一写入方 = 本模块，
+ *     multi-repo-context.js 只读且路径公式与此处 crossWorktreePath 保持同步）；
+ *   - base 锚 meta.baseHash（跨仓仓 HEAD 快照）；dirty baseline overlay 沿用主仓同款
+ *     （跨仓主工作副本的在途改动进 baseline，不算交付 diff，apply 不覆盖它们）；
+ *   - deps 供给 provisionDeps(worktree, 跨仓根, {specBase:null})——sniff worktree 自身项目
+ *     类型（package.json→nodejs 链主工作副本 node_modules；不沿用主仓 local.yaml 的
+ *     project.type，主仓与跨仓类型常不同，如实测 maven 主仓 + nodejs 前端仓）；
+ *   - cleanup：解链 node_modules junction → git worktree remove --force → 保留分支
+ *     sillyspec/<change> 作 review 锚点（对齐主仓 cleanup 的分支保护哲学）。
+ *
+ * 兼容：无跨仓 worktree meta 的旧变更（legacy 直写主干模式）各链路继续走原路径，零回归。
+ */
+
+import { existsSync, readFileSync, readdirSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { git, gitQuiet } from './git-helper.js';
+import { writeAtomicSync } from './fs-atomic.js';
+import { WorktreeManager, unlinkNodeModulesLinks, safeRemoveWorktreeDir } from './worktree.js';
+import { provisionDeps } from './worktree-deps.js';
+import { aggregateDeclaredRepos } from './run/shared.js';
+import { parseRepoRegistry } from './stages/plan-postcheck.js';
+
+const META_FILE = 'meta.json';
+const BRANCH_PREFIX = 'sillyspec/';
+
+/**
+ * 跨仓 worktree 路径（唯一路径公式；multi-repo-context.js 的 meta 只读逻辑与此同步）。
+ * @param {string} specBase 主仓 spec 根（<主仓>/.sillyspec）
+ * @param {string} changeName 变更名
+ * @param {string} repoKey 跨仓 repo 键（local.yaml repos: 段的 key）
+ */
+export function crossWorktreePath(specBase, changeName, repoKey) {
+  return join(specBase, '.runtime', 'worktrees', `${changeName}--${repoKey}`);
+}
+
+/**
+ * 读跨仓 worktree meta（不存在/损坏返 null = legacy 直写模式）。
+ * @returns {object|null}
+ */
+export function getCrossWorktreeMeta(specBase, changeName, repoKey) {
+  const metaPath = join(crossWorktreePath(specBase, changeName, repoKey), META_FILE);
+  if (!existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(readFileSync(metaPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 列出某变更已建的全部跨仓 worktree meta（扫描 worktrees 目录下 `<change>--*` 且 isCross 的 meta）。
+ * @returns {Array<{repoKey: string, meta: object}>}
+ */
+export function listCrossWorktreeMetas(specBase, changeName) {
+  const base = join(specBase, '.runtime', 'worktrees');
+  if (!existsSync(base)) return [];
+  const out = [];
+  for (const name of readdirSync(base)) {
+    if (!name.startsWith(`${changeName}--`)) continue;
+    const metaPath = join(base, name, META_FILE);
+    if (!existsSync(metaPath)) continue;
+    try {
+      const meta = JSON.parse(readFileSync(metaPath, 'utf8'));
+      if (meta && meta.isCross && meta.repoKey) out.push({ repoKey: meta.repoKey, meta });
+    } catch { /* 损坏 meta 跳过（cleanup 阶段仍按目录处理） */ }
+  }
+  return out;
+}
+
+/**
+ * 聚合声明跨仓 key（plan.md 内联卡片 + tasks/ 独立卡片双源，与 shared.js getOrCreateMultiRepoContext 同口径）。
+ * @param {string} specBase
+ * @param {string} changeName
+ * @returns {string[]} 除 'main' 外的跨仓 key（未注册/配置错由 MultiRepoContext fail-closed，此处只聚合）
+ */
+function aggregateCrossRepoKeys(specBase, changeName) {
+  const planFile = join(specBase, 'changes', changeName, 'plan.md');
+  let planContent = '';
+  if (existsSync(planFile)) {
+    try { planContent = readFileSync(planFile, 'utf8') } catch { planContent = '' }
+  }
+  // tasks/ 独立卡片兜底（与 run/shared.js collectTaskCardReposFallback 同口径，该函数未导出）
+  const tasksDir = join(specBase, 'changes', changeName, 'tasks');
+  if (existsSync(tasksDir)) {
+    for (const f of readdirSync(tasksDir)) {
+      if (!/^task-\d+\.md$/i.test(f)) continue;
+      try { planContent += '\n' + readFileSync(join(tasksDir, f), 'utf8') + '\n' } catch { /* 兜底源不阻断 */ }
+    }
+  }
+  return aggregateDeclaredRepos(planContent).filter(k => k !== 'main');
+}
+
+/**
+ * 读主仓 local.yaml 的 repos: 段（路径口径与 run/shared.js readLocalYamlRaw 一致：cwd/.sillyspec/local.yaml）。
+ * @returns {Map<string,string>}
+ */
+function readRepoRegistry(cwd) {
+  const p = join(cwd, '.sillyspec', 'local.yaml');
+  let text = '';
+  if (existsSync(p)) {
+    try { text = readFileSync(p, 'utf8') } catch { text = '' }
+  }
+  return parseRepoRegistry(text);
+}
+
+/**
+ * execute 启动时为每个声明的跨仓仓建 worktree（幂等：meta 在即复用）。
+ *
+ * 失败语义 fail-closed（对齐主仓 create：隔离建不起来就不该开工）：任何仓创建失败 → 抛错，
+ * 由调用方（run/stage.js execute 启动）exit(1) 并给修复指引。已建成功的仓保留（重跑幂等复用）。
+ *
+ * @param {{ cwd: string, changeName: string, specBase?: string }} opts
+ * @returns {{ created: Array<{repoKey,worktreePath}>, reused: Array<{repoKey,worktreePath}>, skippedLegacy: string[] }}
+ * @throws {Error} 跨仓仓未注册 / git 不可达 / worktree add 失败 / 分支冲突
+ */
+export function ensureCrossWorktrees({ cwd, changeName, specBase }) {
+  const base = specBase || join(cwd, '.sillyspec');
+  const keys = aggregateCrossRepoKeys(base, changeName);
+  const registry = readRepoRegistry(cwd);
+  const created = [];
+  const reused = [];
+  const skippedLegacy = [];
+
+  for (const key of keys) {
+    const repoRoot = registry.get(key);
+    if (!repoRoot) {
+      // 与 MultiRepoContext 约束②同语义：声明的 repo 必须已注册，配置错不降级
+      throw new Error(
+        `跨仓 repo "${key}" 未在 local.yaml repos: 段注册。` +
+        `一键注册：sillyspec local register-repo ${key} <${key} 仓根路径>（勿手编 YAML），补注册后重跑 execute。`
+      );
+    }
+    const existing = getCrossWorktreeMeta(base, changeName, key);
+    if (existing && existing.worktreePath && existsSync(existing.worktreePath)) {
+      reused.push({ repoKey: key, worktreePath: existing.worktreePath });
+      continue;
+    }
+    // meta 在但目录没了（外部误删）：走重建（下方 git worktree add 会因注册残留失败，
+    // 先 prune 掉悬空注册再建——目录不在则 prune 无损）
+    if (existing) {
+      try { gitQuiet(repoRoot, ['worktree', 'prune'], { timeout: 30000 }) } catch {}
+    }
+
+    const worktreePath = crossWorktreePath(base, changeName, key);
+    const branch = BRANCH_PREFIX + changeName;
+
+    // base 快照：跨仓仓当前 HEAD（与主仓 create 的默认 base 语义一致）
+    let baseHash;
+    try {
+      baseHash = git(repoRoot, ['rev-parse', 'HEAD']);
+    } catch (e) {
+      throw new Error(`跨仓 repo "${key}"（${repoRoot}）git 不可达（rev-parse HEAD 失败：${e.message}）。请检查 local.yaml repos: 段路径。`);
+    }
+    const branchExists = !!gitQuiet(repoRoot, ['rev-parse', '--verify', `refs/heads/${branch}`]);
+    if (branchExists) {
+      throw new Error(
+        `跨仓仓 ${key} 已有分支 ${branch}（疑似上次 execute 残留）。三选一：\n` +
+        `  ① 确认残留作废：git -C ${repoRoot} branch -D ${branch} 后重跑；\n` +
+        `  ② 分支内容已 apply 落地或不再需要：sillyspec worktree cleanup ${changeName} --force（跨仓 worktree 一并清理后重跑）；\n` +
+        `  ③ 换变更名重跑。`
+      );
+    }
+    mkdirSync(join(base, '.runtime', 'worktrees'), { recursive: true });
+    try {
+      git(repoRoot, ['worktree', 'add', worktreePath, '-b', branch, baseHash], { timeout: 120000 });
+    } catch (e) {
+      throw new Error(`跨仓仓 ${key} worktree 创建失败（${worktreePath}）：${e.stderr || e.message}`);
+    }
+
+    const meta = {
+      name_zh: 'worktree 元数据',
+      changeName,
+      repoKey: key,
+      crossRepoRoot: repoRoot,
+      isCross: true,
+      branch,
+      baseBranch: gitQuiet(repoRoot, ['symbolic-ref', '--short', 'HEAD']) || 'HEAD',
+      baseHash,
+      actualBaseHash: gitQuiet(worktreePath, ['rev-parse', 'HEAD']) || baseHash,
+      createdAt: new Date().toISOString(),
+      worktreePath,
+      mode: 'worktree',
+    };
+    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 不含它们`);
+    }
+
+    // deps 供给：specBase 传 null —— sniff worktree 自身（主仓 local.yaml 的 project.type/install
+    // 描述的是主仓，跨仓仓类型常不同，如实测 maven 主仓 + nodejs 前端仓，沿用会把 mvn 命令
+    // 打到前端仓上）。失败不阻断（与主仓 create 同语义，doctor --fix 可修）
+    try {
+      const deps = provisionDeps(worktreePath, repoRoot, { specBase: null }) || {};
+      Object.assign(meta, {
+        depsStatus: deps.depsStatus,
+        depsMethod: deps.depsMethod || null,
+        depsSource: deps.depsSource || null,
+        depsLockHash: deps.depsLockHash || null,
+        depsCheckedAt: deps.depsCheckedAt || null,
+        ...(deps.depsError ? { depsError: deps.depsError } : {}),
+      });
+      writeAtomicSync(join(worktreePath, META_FILE), JSON.stringify(meta, null, 2) + '\n');
+    } catch (e) {
+      meta.depsStatus = 'failed';
+      meta.depsError = `provisionDeps crashed: ${e.message}`;
+      writeAtomicSync(join(worktreePath, META_FILE), JSON.stringify(meta, null, 2) + '\n');
+    }
+
+    created.push({ repoKey: key, worktreePath });
+  }
+  return { created, reused, skippedLegacy };
+}
+
+/**
+ * 清理某变更的全部跨仓 worktree（幂等）。
+ *
+ * 顺序对齐主仓 cleanup 的 Windows 防护：先解 node_modules junction（裸删会穿透删跨仓主工作
+ * 副本的 node_modules），再 git worktree remove --force，最后**保留分支** sillyspec/<change>
+ * 作 review 锚点（分支删除在主仓侧有 review 锚点 + 双保护，跨仓侧 v1 保守不删，残 branch
+ * 可人工清理）。目录残留（remove 失败）走 safeRemoveWorktreeDir 兜底 + residual 上报。
+ *
+ * @param {{ cwd: string, changeName: string, specBase?: string, force?: boolean }} opts
+ * @returns {{ results: Array<{repoKey, result: 'cleaned'|'skipped'|'partial', details: string[], residual: string[]}> }}
+ */
+export function cleanupCrossWorktrees({ cwd, changeName, specBase, force = false }) {
+  const base = specBase || join(cwd, '.sillyspec');
+  const results = [];
+  for (const { repoKey, meta } of listCrossWorktreeMetas(base, changeName)) {
+    const details = [];
+    const residual = [];
+    const repoRoot = meta.crossRepoRoot;
+    const wtPath = meta.worktreePath || crossWorktreePath(base, changeName, repoKey);
+    if (!existsSync(wtPath)) {
+      try { if (repoRoot) gitQuiet(repoRoot, ['worktree', 'prune'], { timeout: 30000 }) } catch {}
+      results.push({ repoKey, result: 'skipped', details: ['目录不存在（已清理）'], residual });
+      continue;
+    }
+    if (!force) {
+      // fail-closed：worktree 内还有未落地交付（相对 baseHash 有 diff）时拒绝清理（对齐主仓
+      // hasUnappliedChanges 哲学；跨仓侧以「分支上有交付 diff 且未 apply」近似）
+      try {
+        const diff = gitQuiet(wtPath, ['diff', '--name-only', meta.baseHash]) || '';
+        const untracked = gitQuiet(wtPath, ['ls-files', '--others', '--exclude-standard']) || '';
+        if (diff.trim() || untracked.trim()) {
+          results.push({ repoKey, result: 'partial', details: [`blocked: 跨仓 worktree 有未 apply 的交付改动（git diff ${String(meta.baseHash).slice(0, 8)} 非空）——先 apply 或显式 --force`], residual: [wtPath] });
+          continue;
+        }
+      } catch (e) {
+        details.push(`未落地检测失败（${e.message}），按 force 处理`);
+      }
+    }
+    try { unlinkNodeModulesLinks(wtPath, meta, details) } catch (e) { details.push(`junction 解链失败: ${e.message}`) }
+    try {
+      git(repoRoot, ['worktree', 'remove', '--force', wtPath], { timeout: 60000 });
+    } catch {
+      // remove 失败（脏文件/锁）：解链后安全删目录 + prune 注册
+      try { safeRemoveWorktreeDir(wtPath, meta) } 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}）`);
+    results.push({ repoKey, result: residual.length > 0 ? 'partial' : 'cleaned', details, residual });
+  }
+  return { results };
+}

package/src/worktree-deps.js

@@ -3,9 +3,14 @@
  *
  * 在 worktree.create() 的 baseline overlay 之后调用，让 worktree 立即可构建/测试。
  * 策略：junction/symlink 快路径（lockfile 一致）+ install 兜底；多语言按 local.yaml
- * project.type + lockfile 推断 install 命令。供给可失败，但状态写进 meta 供验证硬门读取。
+ * project.type + ECOSYSTEMS 清单表推断 install 命令。供给可失败，但状态写进 meta 供验证硬门读取。
  *
  * 见 change 2026-06-28-worktree-deps-provision / D-005@v1, D-007@v1。
+ *
+ * 生态中立（坑 deps-ecosystem-hardcode，2026-08-27）：本模块所有「按语言判断」一律走下方
+ * ECOSYSTEMS 清单表（单一事实源），不再散落 nodejs 特判——此前 lockfileHash 只认 nodejs
+ * 清单、missing 只认 node_modules、maven/gradle 无清单基准（pom.xml 改了不触发重供给）、
+ * node 校验与 java 校验各说各话。新生态补一行表项即可；表外项目落 generic → n/a 不阻断。
  */
 
 import { existsSync, readFileSync, realpathSync, lstatSync, readdirSync, unlinkSync } from 'fs';
@@ -18,21 +23,117 @@ const LOCKFILES = ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock'];
 const DEFAULT_TIMEOUT_MS = 300 * 1000;
 
 /**
- * 取目录下首个命中的 lockfile 的 sha256 前 16 位；
- * 无 lockfile 则 hash package.json；都没有返回 null。
+ * 生态清单表——deps 链路「按语言判断」的单一事实源。每项声明：
+ *   type:      project.type 值（local.yaml 可显式声明覆盖探测）
+ *   detect:    文件特征探测（表序即优先级；polyglot 目录按先命中者定性，hash 基准与 install
+ *              同取该生态——检测与供给/新鲜度始终同生态，不自相矛盾）
+ *   manifests: 依赖清单文件（按优先级取首个存在者作 freshness 的 hash 基准：清单变 = 依赖集变
+ *              = stale 触发重供给。nodejs 原以 lockfile/package.json 充当；maven/gradle/python
+ *              原先无基准 → pom.xml 改了也不触发，正是「node 校验的和 java 的不一样」的病根）
+ *   marker:    depsStatus=installed/linked 后应存在的 worktree 本地产物（missing 判定）。
+ *              null = 产物在用户级仓库（maven ~/.m2、gradle ~/.gradle）或安装方式两可
+ *              （python：uv sync 建 .venv、pip 装进当前环境），无 worktree 内统一标记，
+ *              freshness 只信 depsStatus + 清单 hash——不重蹈 non-nodejs-missing-misjudge
+ *   install:   无 commands.install 时的默认命令（null = 无默认，根供给 n/a）
+ */
+const ECOSYSTEMS = [
+  {
+    type: 'maven',
+    manifests: ['pom.xml'],
+    marker: null,
+    detect: (d) => existsSync(join(d, 'pom.xml')),
+    install: () => 'mvn -o test',
+  },
+  {
+    type: 'gradle',
+    manifests: ['build.gradle.kts', 'build.gradle', 'settings.gradle', 'gradle.lockfile'],
+    marker: null,
+    detect: (d) => existsSync(join(d, 'build.gradle')) || existsSync(join(d, 'build.gradle.kts')),
+    // win32 cmd.exe 跑不了 ./gradlew（体检 BUG-08 同型）：优先 gradlew.bat，否则全局 gradle
+    install: (d) => (process.platform === 'win32'
+      ? (existsSync(join(d, 'gradlew.bat')) ? 'gradlew.bat test' : 'gradle test')
+      : './gradlew test'),
+  },
+  {
+    type: 'nodejs',
+    manifests: ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock', 'package.json'],
+    marker: 'node_modules',
+    // 探测含 LOCKFILES（与 hasNodeMarker 同口径）：只有 lockfile 没有 package.json 的目录
+    //（子包/残缺 checkout）也是 nodejs——missing 护栏对它们同样生效
+    detect: (d) => existsSync(join(d, 'package.json')) || LOCKFILES.some(lf => existsSync(join(d, lf))),
+    install: (d) => {
+      if (existsSync(join(d, 'pnpm-lock.yaml'))) return 'pnpm install --frozen-lockfile';
+      if (existsSync(join(d, 'package-lock.json'))) return 'npm ci';
+      if (existsSync(join(d, 'yarn.lock'))) return 'yarn install --frozen-lockfile';
+      return 'npm install'; // 无 lockfile 兜底（X-2）
+    },
+  },
+  {
+    type: 'python',
+    manifests: ['uv.lock', 'poetry.lock', 'requirements.txt', 'pyproject.toml'],
+    marker: null,
+    detect: (d) => existsSync(join(d, 'pyproject.toml')) || existsSync(join(d, 'requirements.txt')),
+    // uv 优先（现代 Python 工具链，pyproject/uv.lock 项目走 uv sync 建 .venv + 装依赖，
+    // 与 execute worktree 环境预告一致）；纯 requirements.txt（无 pyproject）回退 pip
+    install: (d) => (existsSync(join(d, 'uv.lock')) || existsSync(join(d, 'pyproject.toml')) ? 'uv sync' : 'pip install -r requirements.txt'),
+  },
+  {
+    type: 'go',
+    manifests: ['go.mod', 'go.sum'],
+    marker: null,
+    detect: (d) => existsSync(join(d, 'go.mod')),
+    install: () => 'go mod download',
+  },
+  {
+    type: 'rust',
+    manifests: ['Cargo.lock', 'Cargo.toml'],
+    marker: null,
+    detect: (d) => existsSync(join(d, 'Cargo.toml')),
+    install: () => 'cargo fetch --locked',
+  },
+  {
+    type: 'php',
+    manifests: ['composer.lock', 'composer.json'],
+    marker: null,
+    detect: (d) => existsSync(join(d, 'composer.json')),
+    install: () => 'composer install',
+  },
+  {
+    type: 'ruby',
+    manifests: ['Gemfile.lock', 'Gemfile'],
+    marker: null,
+    detect: (d) => existsSync(join(d, 'Gemfile')),
+    install: () => 'bundle install',
+  },
+];
+
+/** 目录命中的生态表项（表序优先；无命中 → null = generic）。polyglot 目录取先命中生态。 */
+export function detectEcosystem(dir) {
+  if (!dir || !existsSync(dir)) return null;
+  for (const eco of ECOSYSTEMS) {
+    if (eco.detect(dir)) return eco;
+  }
+  return null;
+}
+
+/**
+ * 取目录下首个命中的生态清单文件的 sha256 前 16 位（全生态：pnpm-lock/yarn.lock/pom.xml/
+ * go.mod/Cargo.lock/composer.lock/Gemfile.lock…按 ECOSYSTEMS 表序）；无任何清单返回 null。
+ * 函数名保留 lockfileHash（历史导出名，worktree.js/modules 链接一致性判定等多处消费），
+ * 语义自 2026-08-27 起泛化为「依赖清单 hash」——maven 的 pom.xml 等与 nodejs 的 lockfile
+ * 同权作 stale/main-drift 基准。polyglot 目录首次泛化后基准可能从 package.json 切到先命中
+ * 生态的清单（一次性 stale 重供给，自愈后以新基准续跑）。
  */
 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);
+  for (const eco of ECOSYSTEMS) {
+    for (const mf of eco.manifests) {
+      const p = join(dir, mf);
+      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;
 }
 
@@ -78,47 +179,24 @@ function extractUserInstall(yamlText) {
   return null;
 }
 
-/** 从 local.yaml 提取 project.type；缺失时按文件特征推断 */
+/** 从 local.yaml 提取 project.type；缺失时按 ECOSYSTEMS 表文件特征推断（表序优先） */
 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';
+  const eco = detectEcosystem(worktreePath);
+  return eco ? eco.type : 'generic';
 }
 
-/** 按 project.type + lockfile 推断 install 命令（无 commands.install 时）*/
+/** 按 project.type（+ 表内 install 探测）推断 install 命令（无 commands.install 时）。
+ *  表外 project.type（含 local.yaml 显式声明的自定义值）→ null → 根供给 n/a，
+ *  需要执行的装法在 local.yaml 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
-  }
+  const eco = ECOSYSTEMS.find(e => e.type === projectType);
+  return eco ? eco.install(worktreePath) : null;
 }
 
 /** 在 worktreePath 创建 node_modules 链接到 mainNodeModules；失败回退 */
@@ -202,7 +280,7 @@ function tryLink(mainNodeModules, linkPath) {
  * 全程 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 INSTALL_BINARY_WHITELIST = /^(?:\.\/)?(?:pnpm|npm|yarn|bun|mvn|mvnd|gradle|gradlew|uv|pip|pip3|python|python3|poetry|make|go|cargo|composer|bundle|dotnet)(?:\.cmd|\.bat|\.exe)?(?:\s|$)/;
 const SHELL_METACHARS = /[;&|<>$`\n]/;
 const WIN_SHELL_METACHARS = /[;&|<>$`\n%]/;
 const CD_SEGMENT_RE = /^cd\s+([^\s]+)$/;
@@ -252,8 +330,15 @@ function tryInstall(cmd, cwd, timeout) {
         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}` };
+      const raw = e.killed ? `timeout after ${timeout}ms` : ((e.stderr && e.stderr.toString()) || e.message);
+      // 命令找不到 → 追加 PATH 定向指引（坑 deps-tool-not-on-path-failed-loop，2026-08-27 实证）：
+      // CLI 子进程继承调用方 shell 的 PATH，无 mvn/gradle 等工具链的环境里 install 必败，裸报
+      // "'mvn' 不是内部或外部命令" 让人误以为是项目配置问题。指引换环境重跑 doctor --fix。
+      const notFoundRe = /is not recognized|不是内部或外部命令|command not found|no such file or directory|ENOENT/i;
+      const hint = (!e.killed && notFoundRe.test(raw))
+        ? `（工具 ${argv[0]} 不在当前 shell 的 PATH——CLI 子进程继承调用方环境。请在含该工具链的环境重跑 sillyspec worktree doctor --fix --change <变更名>，或把工具目录加入 PATH 后重试）`
+        : '';
+      return { ok: false, error: `${seg} failed (cwd ${curCwd}): ${raw}${hint}` };
     }
   }
   return { ok: true };
@@ -491,15 +576,21 @@ export function provisionDeps(worktreePath, mainCwd, opts = {}) {
  * 统一的 worktree deps 新鲜度判定（H1，change 2026-08-05-tooling-feedback-fixes）。
  * 供 doctor（worktree.js）与 ensureDepsFreshness（run/stage.js）共用，消除两处双写漂移。
  *
+ * 生态中立（坑 deps-ecosystem-hardcode，2026-08-27）：判定基准全部来自 ECOSYSTEMS 清单表，
+ * 各生态同一套语义——不再有「node 一套校验、java 另一套」：
+ *
  * 判定优先级：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 判据）
+ *   - missing: depsStatus ∈ {linked, installed} 且生态 marker（如 nodejs 的 node_modules）
+ *     不存在。仅对声明了 marker 的生态生效（nodejs）；maven/gradle/python 等产物在用户级
+ *     仓库或安装方式两可（表内 marker=null），只信 depsStatus + 清单 hash
+ *   - stale: wtHash 与 meta.depsLockHash 不一致（worktree 自身依赖清单在上次供给后变化——
+ *     nodejs 的 lockfile/package.json、maven 的 pom.xml、go 的 go.mod 等同权）
+ *   - main-drift: wtHash 与主仓 mainHash 不一致（主仓清单漂移；复用 linkOneDir 的 mismatch 判据）
  *   - fresh: 其余情况
  *
- * lockfileHash 返回 null（无 lockfile/package.json）时相关比较优雅降级——不报 stale / main-drift，
- * 避免无 lockfile 项目（如纯 generic / 非 nodejs）误判漂移。
+ * lockfileHash 返回 null（目录内无任何生态清单文件）时相关比较优雅降级——不报 stale /
+ * main-drift，避免无清单项目（如纯 generic）误判漂移。
  *
  * @param {object} [meta] - worktree meta（读 depsStatus / depsLockHash / depsError）
  * @param {string} wtPath - worktree 根目录
@@ -521,12 +612,18 @@ export function checkDepsFreshness(meta, wtPath, mainCwd) {
     };
   }
 
-  // 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) {
+  // 2. missing：曾 link/install 但生态 marker 已丢失（对齐 doctor 914-915 / ensure 403）。
+  // marker 来自 ECOSYSTEMS 表：nodejs → node_modules。marker=null 的生态（maven/gradle/python…）
+  // 产物在 ~/.m2、~/.gradle 或安装方式两可，worktree 内无统一标记——此前无此门会把这类项目
+  // 每次 execute 入口都误判 missing → 重跑 install → 无工具链 PATH 的 shell 里失败 →
+  // depsStatus 被打回 failed → deps 门控阻断 --done（坑 non-nodejs-missing-misjudge，2026-08-27
+  // maven 项目实证）。
+  const eco = detectEcosystem(wtPath);
+  const marker = eco ? eco.marker : null;
+  if (marker && ['linked', 'installed'].includes(depsStatus) && wtPath && !existsSync(join(wtPath, marker))) {
     return {
       status: 'missing',
-      detail: `meta.depsStatus=${depsStatus} 但 node_modules 缺失`,
+      detail: `meta.depsStatus=${depsStatus} 但 ${marker} 缺失（${eco.type} 生态就绪标记）`,
       wtHash, mainHash, metaLockHash,
     };
   }
@@ -550,20 +647,21 @@ export function checkDepsFreshness(meta, wtPath, mainCwd) {
     }
   }
 
-  // 3. stale：worktree 自身 lockfile 与 meta 快照不一致（对齐 doctor 916-917 / ensure 404）
+  // 3. stale：worktree 自身依赖清单与 meta 快照不一致（对齐 doctor 916-917 / ensure 404；
+  // 清单=ECOSYSTEMS 表内文件：nodejs lockfile/package.json、maven pom.xml、go go.mod 等同权）
   if (metaLockHash && wtHash && wtHash !== metaLockHash) {
     return {
       status: 'stale',
-      detail: `lockfile 变化 (${metaLockHash} -> ${wtHash})`,
+      detail: `依赖清单变化 (${metaLockHash} -> ${wtHash})`,
       wtHash, mainHash, metaLockHash,
     };
   }
 
-  // 4. main-drift（新增）：wtHash 与主仓 mainHash 不一致——主仓 lockfile 更新过、worktree 未跟
+  // 4. main-drift（新增）：wtHash 与主仓 mainHash 不一致——主仓依赖清单更新过、worktree 未跟
   if (wtHash && mainHash && wtHash !== mainHash) {
     return {
       status: 'main-drift',
-      detail: `worktree lockfile 与主仓不一致 (wt=${wtHash} main=${mainHash})`,
+      detail: `worktree 依赖清单与主仓不一致 (wt=${wtHash} main=${mainHash})`,
       wtHash, mainHash, metaLockHash,
     };
   }

package/templates/prompts/verify-probes.md

@@ -26,7 +26,8 @@ grep -rl "<关键词>" <源码目录>/ --include="*.java" --include="*.js" --inc
 6. 任意 P0/P1 unresolved/blocking 决策标记为 FAIL blocker
 
 **探针 5 补充（CLI 已出对账表，你做诚实判定）**
-CLI 的 missing backend endpoint 是 advisory（不硬阻断归档）——但 contract gap 是真实集成缺陷，应诚实标 FAIL 并回 execute 补端点，勿因 CLI 不拦而放行。后端 router 的端点清单可用 `sillyspec endpoints extract --change <变更名> --task <task-NN>` 重新静态提取（勿手扫装饰器）。
+CLI 的 missing backend endpoint 是 advisory（不硬阻断归档）——但 contract gap 是真实集成缺陷，应诚实标 FAIL 并回 execute 补端点，勿因 CLI 不拦而放行。后端 router 的端点清单用 `sillyspec endpoints extract --change <变更名> --all-tasks` 聚合提取（逐 task 卡各自落产物，与对账聚合口径一致；勿手扫装饰器、勿只提单 task——单 task 产物对账会放大假 missing）。
+先看对账表 scope 标注：`change-diff`（含 apply-pathspec 兜底）口径可信；若显示 `full-repo`（diff 与 apply 清单都不可得时的兜底），missing 大概率是「全仓调用 × 本变更局部端点」的口径错配噪音——先收窄复跑（`sillyspec verify-probes --change <变更名>`）再判定，不要把口径噪音直接记成 contract gap。
 
 **探针 6 补充（CLI 已出三态判定，你做终审）**
 以 git 事实为准（真实 > 声明）；CLI 的三态（合规/高风险/未声明）是机械判定，是否构成 FAIL blocker 由你诚实判定，务必如实记录——静默删除代码是 verify 的最大盲区。