@yemi33/minions 0.1.2232 → 0.1.2234

package/engine.js

@@ -1047,37 +1047,6 @@ function _statusPorcelainCmd() {
     : 'git status --porcelain';
 }
 
-// W-mq5n1zx5 — Layer 1a: rename worktree dir with jittered backoff. The
-// raw `fs.renameSync` used to throw Windows EBUSY/EPERM/EACCES if a
-// lingering `git.exe` descendant (typically leaked by a status-probe
-// timeout) still held a packfile handle. We retry with capped exponential
-// backoff + random jitter so the descendant has time to exit on its own.
-// Worst-case wall time ≈ baseMs * (2^attempts) ≈ 16s when attempts=6,
-// baseMs=250 — small enough not to wedge a tick, large enough to clear
-// the typical race. Throws the LAST error on exhaustion so the caller
-// can decide whether to fall back to `git worktree remove --force`.
-async function _renameWithRetry(src, dst, opts = {}) {
-  const attempts = Number(opts.attempts) > 0
-    ? Number(opts.attempts)
-    : ENGINE_DEFAULTS.quarantineRenameRetryAttempts;
-  const baseMs = Number(opts.baseMs) > 0
-    ? Number(opts.baseMs)
-    : ENGINE_DEFAULTS.quarantineRenameRetryBaseMs;
-  let lastErr;
-  for (let i = 0; i < attempts; i++) {
-    try { fs.renameSync(src, dst); return { attempts: i + 1 }; }
-    catch (e) {
-      if (!['EBUSY', 'EPERM', 'EACCES', 'ENOTEMPTY'].includes(e.code)) throw e;
-      lastErr = e;
-      if (i < attempts - 1) {
-        const delay = baseMs * (2 ** i) + Math.random() * 200;
-        await new Promise(r => setTimeout(r, delay));
-      }
-    }
-  }
-  throw lastErr;
-}
-
 // W-mqila0t5 — resolve the worktree-holder reap probe timeout, honoring a
 // `config.engine.statusProbeKillTimeoutMs` override (the dashboard Settings
 // control persists there) and falling back to the ENGINE_DEFAULTS default.
@@ -1223,7 +1192,17 @@ function _reapWorktreeHolders(worktreePath, opts = {}) {
   }
   if (live) { result.skipped = true; result.reason = 'live'; return result; }
 
-  // Layer 0 — legacy git.exe-by-cmdline sweep.
+  // Layer 0 — legacy git.exe-by-cmdline sweep. NOT redundant with Layer 2
+  // (P-e2a6c9d4, evaluated): Layer 2 (findProcessCwdHolders) matches purely on a
+  // process's CWD resolving at/under THIS worktree (engine/shared.js
+  // _windowsCwdProbeScript + _parseCwdHolderLines filter on cwd only). Layer 0
+  // matches `git.exe` by `CommandLine -like '*<worktreePath>*'` regardless of CWD.
+  // The case Layer 2 cannot see: a git.exe the engine itself spawns FROM the repo
+  // root referencing the worktree by argument — e.g. `git -C <gitRoot> worktree
+  // remove <wt>` / `git worktree prune` / `git worktree add <wt>` — its CWD is the
+  // repo root, not under <wt>, so Layer 2 never emits it, but it can still hold a
+  // packfile/dir handle on <wt>. Layer 0's command-line match is the only layer
+  // that reaps it. Keep both.
   try { result.layer0 = (layer0Fn(worktreePath).killed) || 0; }
   catch { /* best-effort */ }
 
@@ -1653,6 +1632,11 @@ async function assertCleanSharedWorktree(rootDir, worktreePath, branchName, disp
 // field is populated and `result.quarantined` stays false (env-blocked
 // path); a normal return means quarantine succeeded.
 async function _quarantineDirtyWorktree(rootDir, worktreePath, branchName, gitOpts, diag = {}) {
+  // P-c7e2b405 — INTENTIONAL divergence from worktree-gc.reapAndRemoveWorktree:
+  // this is the bespoke dirty-worktree quarantine flow (rename → branch backup-ref
+  // → reset → fetch), NOT a plain reap-then-remove. It is deliberately NOT folded
+  // into the shared helper. It does share the same live-guard + holder-reap
+  // primitives (isWorktreePathLive + _reapWorktreeHolders below).
   const ts = Date.now();
   const quarantinedPath = `${worktreePath}-quarantine-${ts}`;
   _bumpQuarantineOutcome('attempts', 1);
@@ -1693,11 +1677,24 @@ async function _quarantineDirtyWorktree(rootDir, worktreePath, branchName, gitOp
   // W-mq5n1zx5 Layer 1a: rename with jittered backoff. Replaces the bare
   // `fs.renameSync(worktreePath, quarantinedPath)` that used to throw
   // Windows EBUSY uncatchably and burn the WI's auto-recovery budget.
+  // Consolidated onto shared._retryFsOp (P-a1c4f7e2): same base*2^i+jitter
+  // backoff math and identical retryable-code set (shared._WORKTREE_RETRYABLE_CODES
+  // === {EBUSY,EPERM,EACCES,ENOTEMPTY}, the exact set the old _renameWithRetry
+  // used). Pass the quarantine-specific attempts/baseMs so the rename keeps its
+  // own retry budget rather than adopting the worktree-remove default. _retryFsOp
+  // is synchronous (blocking sleepMs backoff), so no await here.
   let renameAttempts = 0;
   let renameError = null;
   try {
-    const r = await _renameWithRetry(worktreePath, quarantinedPath);
-    renameAttempts = r.attempts || 1;
+    const r = shared._retryFsOp(
+      () => fs.renameSync(worktreePath, quarantinedPath),
+      `rename ${worktreePath} -> ${quarantinedPath}`,
+      {
+        attempts: ENGINE_DEFAULTS.quarantineRenameRetryAttempts,
+        baseMs: ENGINE_DEFAULTS.quarantineRenameRetryBaseMs,
+      },
+    );
+    renameAttempts = r.attempt || 1;
   } catch (e) {
     renameError = e;
   }
@@ -2634,8 +2631,29 @@ async function spawnAgent(dispatchItem, config) {
                   log('info', `Retrying -b create after prune for ${branchName}`);
                   try { await shared.shellSafeGit(['worktree', 'prune'], { ..._gitOpts, cwd: rootDir, timeout: 15000 }); } catch { /* optional */ }
                   removeStaleIndexLock(rootDir);
-                  // Clean up partial worktree directory from failed attempt
-                  try { if (fs.existsSync(worktreePath)) fs.rmSync(worktreePath, { recursive: true, force: true }); } catch { /* optional */ }
+                  // Clean up partial worktree directory from the failed -b
+                  // attempt. Keep this a RAW fs.rmSync: this husk pre-dates
+                  // `git worktree add`, so git does not yet own it and
+                  // shared.removeWorktree's `git worktree remove --force` would
+                  // no-op on it (P-b3d9a162). Two guards before the delete:
+                  //   1. isWorktreePathLive (fail-open): skip if another
+                  //      dispatch raced onto this path — it returns true on a
+                  //      SQL outage, so we leak the husk rather than nuke a
+                  //      sibling agent's live worktree. Exclude our OWN id.
+                  //   2. belt-and-braces: never recurse-delete a path that
+                  //      carries its own `.git` DIRECTORY (a mis-pointed
+                  //      worktreePath onto a real repo) — a linked worktree's
+                  //      `.git` is a FILE, so this never blocks a real husk.
+                  try {
+                    const _huskGit = path.join(worktreePath, '.git');
+                    let _huskIsRealRepo = false;
+                    try { _huskIsRealRepo = fs.existsSync(_huskGit) && fs.lstatSync(_huskGit).isDirectory(); } catch { /* unreadable — treat as husk */ }
+                    if (fs.existsSync(worktreePath)
+                        && !_huskIsRealRepo
+                        && !shared.isWorktreePathLive(worktreePath, { excludeDispatchId: id })) {
+                      fs.rmSync(worktreePath, { recursive: true, force: true });
+                    }
+                  } catch { /* optional */ }
                   try {
                     await runWorktreeAdd(rootDir, worktreePath, ['-b', branchName, _freshCreateBase], _worktreeGitOpts, 0);
                   } catch (e1b) {
@@ -10016,7 +10034,7 @@ module.exports = {
   gitOutputToString, gitErrorOutput, classifyDepMergeFailureOutput, listUnmergedFiles, // exported for testing
   buildDepConflictFixItem, deriveConflictFixKey, // exported for testing (W-mpcwojgr000a0244)
   isWorktreeRetryableError, removeStaleIndexLock, syncReusedWorktree, assertCleanSharedWorktree, _quarantineDirtyWorktree, // exported for testing
-  _renameWithRetry, _statusPorcelainCmd, _killGitDescendantsForWorktree, _bumpQuarantineOutcome, // exported for testing (W-mq5n1zx5)
+  _statusPorcelainCmd, _killGitDescendantsForWorktree, _bumpQuarantineOutcome, // exported for testing (W-mq5n1zx5)
   _reapWorktreeHolders, _findTerminalWorktreeOwners, // exported for testing (W-mqila0t5 — CWD-pinned holder reap)
   pruneStaleWorktreeForBranch, // exported for testing
   findExistingWorktree, // exported for testing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2232",
+  "version": "0.1.2234",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"