sillyspec 3.28.7 → 3.28.8

package/src/worktree.js

@@ -10,7 +10,7 @@
 
 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 { writeAtomicSync } from './fs-atomic.js';
@@ -25,6 +25,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 +97,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 });
 }
@@ -873,11 +949,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 +962,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)];
   }
 
   /**
@@ -1468,7 +1554,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 +1687,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 +1719,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 +1858,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 +1876,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 +1928,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 +1958,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}`);

package/src/wt-commit.js

@@ -0,0 +1,128 @@
+/**
+ * sillyspec wt-commit —— worktree 内 per-task 串行化提交（提交队列）
+ *
+ * 坑 wt-parallel-commit-race（2026-08-29 用户实证×2）：同 Wave 多个 task 子代理共享同一个
+ * 主仓 worktree，各自裸跑 git add/commit 有两条竞态：① `git add -A` 把并行兄弟的 WIP 文件卷进
+ * 自己的提交；② 并发写 index 撞 index.lock。两次都靠子代理自觉救回，属结构性风险——本命令把
+ * 「自觉」换成「机制」：
+ *
+ * ① 文件锁串行化：withFileLock 排他锁 <mainRepo>/.sillyspec/.runtime/wt-commit-<change>.lock，
+ *    同 change 的 wt-commit 全局排队（per-task 提交队列效果），锁内 add→commit 原子完成；
+ * ② 强制显式 pathspec：-- 后逐路径（或 --pathspec-from-file）——命令语义上杜绝 add -A 扫入
+ *    他人 WIP；commit 带同一 pathspec（--only 语义），不动其他并行者已暂存的内容。
+ *
+ * 边界：锁只约束 wt-commit 调用方；兄弟子代理若仍裸跑 git，靠 ② 的 pathspec 隔离兜底 + git 侧
+ * index.lock 冲突时退避重试。跨仓 task 不走本命令（跨仓有独立 workdir / 直写主干，execute 指引
+ * 要求显式 pathspec 提交）。锁文件在 .runtime（运行时目录，不入 git 历史）。
+ *
+ * 成功返回 HEAD hash（review.json 的 head 锚点直接可用）；无变更 → ok=true + skipped。
+ */
+import { join, resolve } from 'node:path'
+import { existsSync, readFileSync } from 'node:fs'
+import { withFileLock } from './quicklog.js'
+import { safeGit } from './git-helper.js'
+import { WorktreeManager } from './worktree.js'
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms))
+
+/**
+ * git 子操作退避重试：撞 index.lock / HEAD 锁（锁队列外裸跑 git 的兄弟进程短暂持锁）时等待重试。
+ * 非 lock 类错误（路径不存在 / pathspec 不匹配 / 权限）直接抛，不空转。
+ */
+async function gitWithLockRetry(cwd, args, label, { retries = 6, waitMs = 1000 } = {}) {
+  for (let i = 0; ; i++) {
+    const { value, error } = safeGit(cwd, args, { timeout: 30000 })
+    if (!error) return value
+    const msg = String((error && error.message) || error)
+    if (/index\.lock|HEAD\.lock|cannot lock ref/i.test(msg) && i < retries) {
+      await sleep(waitMs)
+      continue
+    }
+    throw new Error(`${label} 失败：${msg.split('\n')[0].trim()}`)
+  }
+}
+
+/**
+ * 执行 worktree 串行化提交。
+ *
+ * @param {object} opts
+ * @param {string} opts.changeName - 变更名（worktree 名）
+ * @param {string} opts.message - 提交信息（建议 "<task-NN 摘要>"）
+ * @param {string[]} opts.pathspecs - 显式路径列表（必填，防 add -A 扫入并行兄弟 WIP）
+ * @param {string|null} [opts.pathspecFile] - --pathspec-from-file：每行一个路径（与 pathspecs 二选一或叠加）
+ * @param {string} [opts.cwd] - 调用方 cwd（主仓根或 worktree 内均可——WorktreeManager 经
+ *   git-common-dir 反推主仓根，worktree 内调用同样定位正确）
+ * @returns {Promise<{ok:boolean,skipped:boolean,head:string,shortHead:string,worktreePath:string,changeName:string,files:string[]}>}
+ *   ok=false 时抛错（调用方打错误 + exit 1），skipped=无变更可提交（HEAD 不动，不算失败）。
+ */
+export async function runWtCommit({ changeName, message, pathspecs = [], pathspecFile = null, cwd = process.cwd() }) {
+  if (!changeName) throw new Error('缺少 --change <变更名>（worktree 名；在 worktree 内运行时可省略，CLI 从 cwd 推断）')
+  if (!message || !message.trim()) throw new Error('缺少 -m/--message <提交信息>（建议 "<task-NN 摘要>"）')
+
+  // pathspec 汇总：显式路径 + 文件逐行（# 注释与空行忽略，与 git pathspec-from-file 习惯一致）
+  const files = [...pathspecs.map(p => p.trim()).filter(Boolean)]
+  if (pathspecFile) {
+    if (!existsSync(pathspecFile)) throw new Error(`--pathspec-from-file 文件不存在: ${pathspecFile}`)
+    for (const line of readFileSync(pathspecFile, 'utf8').split(/\r?\n/)) {
+      const t = line.trim()
+      if (t && !t.startsWith('#')) files.push(t)
+    }
+  }
+  if (files.length === 0) {
+    throw new Error('缺少提交路径：`--` 后逐个给出本 task 的精确路径（或 --pathspec-from-file <file>）。wt-commit 刻意不支持 add -A / 空 pathspec——同 Wave 兄弟子代理共享本 worktree，整树 add 会把对方 WIP 卷进你的提交')
+  }
+
+  const wm = new WorktreeManager({ cwd })
+  const worktreePath = wm.getWorktreePath(changeName)
+  // 隔离模式（worktree 目录存在）→ 提交目标 = worktree 本体；in-place-fallback（meta 声明无
+  // worktree 直改主仓）→ 主仓根（与 MultiRepoContext 主仓 entry 的 worktreePath 兜底口径一致）。
+  // 顺序先看目录再看 meta：worktree 目录存在即隔离态，meta 缺失/损坏不改变目标（fail-safe）。
+  let target = null
+  if (existsSync(worktreePath)) {
+    target = worktreePath
+  } else {
+    const meta = wm.getMeta(changeName)
+    if (meta && meta.mode === 'in-place-fallback') {
+      target = resolve(wm.worktreeBase, '..', '..', '..') // <main>/.sillyspec/.runtime/worktrees → <main>
+    }
+  }
+  if (!target) {
+    throw new Error(`worktree 不存在: ${worktreePath}（确认 --change 变更名；execute 尚未创建 worktree 时先跑 sillyspec run execute）`)
+  }
+
+  // 锁：主仓 .sillyspec/.runtime/ 下按 change 一把（in-place 模式同目录可达，零分叉）
+  const lockPath = join(wm.worktreeBase, '..', `wt-commit-${changeName}.lock`)
+  const envTimeout = parseInt(process.env.SILLYSPEC_WT_COMMIT_LOCK_TIMEOUT_MS || '', 10)
+  const lockTimeoutMs = Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : 120000
+
+  const result = await withFileLock(lockPath, async () => {
+    const headBefore = safeGit(target, ['rev-parse', 'HEAD'], { timeout: 10000 }).value || ''
+    await gitWithLockRetry(target, ['add', '--', ...files], 'git add')
+    // pathspec 范围内是否有 staged 变更（vs HEAD）：空 = 无可提交（task 幂等重跑场景），
+    // 跳过 commit 保持 skipped 语义——不靠解析 git commit 的 "nothing to commit" stdout
+    // （safeGit 的 error 只保留命令首行，stdout 不可得）。
+    const staged = safeGit(target, ['diff', '--cached', '--name-only', '--', ...files], { timeout: 10000 }).value || ''
+    if (!staged.trim()) {
+      return { ok: true, skipped: true, head: headBefore }
+    }
+    await gitWithLockRetry(target, ['commit', '-m', message, '--', ...files], 'git commit')
+    const head = safeGit(target, ['rev-parse', 'HEAD'], { timeout: 10000 }).value || headBefore
+    return { ok: true, skipped: false, head }
+  }, {
+    // 持有者语义：超时报错时能看出是谁卡着队列
+    content: JSON.stringify({ pid: process.pid, changeName, purpose: 'wt-commit' }),
+    staleMs: 120000, // 持锁进程崩溃残留的回收阈值（commit 通常秒级）
+    timeoutMs: lockTimeoutMs, // 排队上限：同 Wave 并行 task 全走队列，给足余量
+    retryMs: 200,
+  })
+
+  return {
+    ok: true,
+    skipped: !!result.skipped,
+    head: result.head,
+    shortHead: (result.head || '').slice(0, 8),
+    worktreePath: target,
+    changeName,
+    files,
+  }
+}