@yemi33/minions 0.1.2232 → 0.1.2234

package/engine/worktree-gc.js

@@ -347,6 +347,162 @@ function _postReapRetry(wtPath, gitRoot, parentDir, resolvedPath, _removeWorktre
   return false;
 }
 
+/**
+ * P-c7e2b405 — shared "reap-then-remove" core for the THREE worktree pruners
+ * (gcDispatchWorktreeIfOrphan, pruneOrphanWorktrees in-root,
+ * pruneOrphanWorktreesFromGitRegistry out-of-root). It folds the previously
+ * copy-pasted slow-retry gate / ownership-marker gate / remove+escalate+
+ * post-reap-retry tail into one decision surface so the three sites cannot
+ * drift apart.
+ *
+ * Encapsulates, in order:
+ *   (1) slow-retry gate — only when `slowRetryMs` is a number (the two
+ *       sweeps pass it; the dispatch-end caller leaves it null so a fresh
+ *       worktree is never slow-gated). Skip → `{ outcome:'skip',
+ *       reason:'slow-retry' }`.
+ *   (2) ownership-marker gate — only when `requireOwnerMarker:true`
+ *       (fail-open: a read error counts as "no marker"). No marker → KEEP the
+ *       foreign/hand-made worktree, emit the debug log, and never escalate.
+ *       Skip → `{ outcome:'skip', reason:'no-marker' }`.
+ *   (3) pre-remove reaper hook — `reapHolders(path,{excludeDispatchId,
+ *       ownerDispatchId})` when injected (dispatch-end only). Best-effort;
+ *       a throw never blocks the removal that follows.
+ *   (4) remove — the injected `removeWorktree(path,gitRoot,parentDir,rmOpts)`.
+ *       We do NOT re-implement its EBUSY/_retryFsOp backoff; removeWorktree
+ *       owns that loop. The live-guard ALSO stays authoritative inside
+ *       shared.removeWorktree + engine._reapWorktreeHolders (both fail-open) —
+ *       it is never re-implemented here.
+ *   (5) outcome accounting — on truthy: bump `evicted` on each `stats` object,
+ *       _markStuckSuccess, optional success metric, info log. On false/throw:
+ *       bump `failed`, _maybeEscalateStuck (with each site's exact
+ *       reason/findProcessesWithCwdInside/killImmediate/config/writeToInbox
+ *       args), warn log (gated on alreadyEscalated + suppression), and the
+ *       `if (reapedPids.length) _postReapRetry(...)` tail when
+ *       `enablePostReapRetry`.
+ *
+ * Returns `{ outcome, removed, reason, escalated, stuckEscalated, reapedPids }`
+ * matching gcDispatchWorktreeIfOrphan's existing contract. When `stats`
+ * objects are supplied the helper mutates their evicted/failed/kept counters
+ * directly (the sweeps); the dispatch-end caller passes none and maps the
+ * return value instead.
+ */
+function reapAndRemoveWorktree(opts) {
+  const {
+    worktreePath,
+    gitRoot,
+    parentDir,
+    resolved: resolvedIn = null,
+    rmOpts,
+    // gates
+    slowRetryMs = null,
+    requireOwnerMarker = false,
+    // pre-remove reaper (dispatch-end only)
+    reapHolders = null,
+    excludeDispatchId = null,
+    ownerDispatchId = null,
+    // escalation flavor
+    escalateReason = null, // 'orphan-sweep' for the two sweeps; null for dispatch-end
+    findProcessesWithCwdInside = null,
+    killImmediate = null,
+    config = null,
+    writeToInbox = null,
+    sleepSyncFn = null,
+    // accounting + logging
+    stats = [],
+    successReason = 'orphan',
+    successMetric = null,
+    recheckSuppressedAfterEscalate = false,
+    enablePostReapRetry = false,
+    onRemovedLog = null,
+    onFailLog = null,
+    onMarkerSkipLog = null,
+    // injected deps (real-impl defaults)
+    removeWorktree = null,
+    hasOwnerMarker = null,
+    log = _noopLog,
+  } = opts || {};
+
+  const _removeFn = typeof removeWorktree === 'function' ? removeWorktree : shared.removeWorktree;
+  const _hasMarker = typeof hasOwnerMarker === 'function' ? hasOwnerMarker : shared.hasWorktreeOwnerMarker;
+  const resolved = resolvedIn || (() => { try { return path.resolve(worktreePath); } catch { return worktreePath; } })();
+  const _bumpStats = (key) => { for (const s of stats) { if (s && typeof s[key] === 'number') s[key]++; } };
+  const _idle = () => ({ outcome: 'skip', removed: false, escalated: false, stuckEscalated: false, reapedPids: [] });
+
+  // (1) slow-retry gate — sweeps only.
+  if (typeof slowRetryMs === 'number') {
+    if (!_shouldSlowRetry(resolved, slowRetryMs)) {
+      _bumpStats('kept');
+      return { ..._idle(), reason: 'slow-retry' };
+    }
+  }
+
+  // (2) ownership-marker gate — fail-open (no marker ⇒ KEEP foreign/hand-made).
+  if (requireOwnerMarker) {
+    let owned = false;
+    try { owned = !!_hasMarker(worktreePath); }
+    catch (_e) { owned = false; }
+    if (!owned) {
+      _bumpStats('kept');
+      if (typeof onMarkerSkipLog === 'function') log('debug', onMarkerSkipLog());
+      return { ..._idle(), reason: 'no-marker' };
+    }
+  }
+
+  // Capture suppression state BEFORE the remove attempt (sweep semantics).
+  const suppressedBefore = _isStuckPathSuppressed(resolved);
+
+  // (3) pre-remove holder reap (dispatch-end injects engine._reapWorktreeHolders).
+  if (typeof reapHolders === 'function') {
+    try {
+      reapHolders(worktreePath, { excludeDispatchId, ownerDispatchId });
+    } catch (reapErr) {
+      log('warn', `worktree-gc: pre-remove reap threw for ${worktreePath}: ${reapErr && reapErr.message}`);
+    }
+  }
+
+  const _escalateOpts = {
+    config, writeToInbox,
+    reason: escalateReason,
+    findProcessesWithCwdInside, killImmediate,
+  };
+  const _shouldWarn = (escResult) => {
+    const suppressed = recheckSuppressedAfterEscalate
+      ? _isStuckPathSuppressed(resolved)
+      : suppressedBefore;
+    return !escResult.alreadyEscalated && !suppressed;
+  };
+  const _postReapOpts = { writeToInbox, sleepSyncFn };
+
+  // (4)+(5) remove + accounting. removeWorktree owns its own backoff loop.
+  try {
+    const removed = _removeFn(worktreePath, gitRoot, parentDir, rmOpts);
+    if (removed) {
+      _bumpStats('evicted');
+      _markStuckSuccess(resolved, { writeToInbox });
+      if (successMetric) { try { shared.bumpWorktreeGcMetric(successMetric); } catch { /* optional */ } }
+      if (typeof onRemovedLog === 'function') log('info', onRemovedLog());
+      return { outcome: 'gc', removed: true, reason: successReason, escalated: false, stuckEscalated: false, reapedPids: [] };
+    }
+    _bumpStats('failed');
+    const escResult = _maybeEscalateStuck(resolved, 'remove returned false', _escalateOpts);
+    if (_shouldWarn(escResult) && typeof onFailLog === 'function') log('warn', onFailLog('false'));
+    const reapedPids = escResult.reapedPids || [];
+    if (enablePostReapRetry && reapedPids.length > 0) {
+      _postReapRetry(worktreePath, gitRoot, parentDir, resolved, _removeFn, _postReapOpts, stats[0] || null, stats[1] || null, log, reapedPids);
+    }
+    return { outcome: 'gc-failed', removed: false, reason: 'remove-failed', escalated: escResult.escalated, stuckEscalated: escResult.escalated, reapedPids };
+  } catch (rmErr) {
+    _bumpStats('failed');
+    const escResult = _maybeEscalateStuck(resolved, rmErr && rmErr.message, _escalateOpts);
+    if (_shouldWarn(escResult) && typeof onFailLog === 'function') log('warn', onFailLog('threw', rmErr && rmErr.message));
+    const reapedPids = escResult.reapedPids || [];
+    if (enablePostReapRetry && reapedPids.length > 0) {
+      _postReapRetry(worktreePath, gitRoot, parentDir, resolved, _removeFn, _postReapOpts, stats[0] || null, stats[1] || null, log, reapedPids);
+    }
+    return { outcome: 'gc-failed', removed: false, reason: 'remove-threw', escalated: escResult.escalated, stuckEscalated: escResult.escalated, reapedPids };
+  }
+}
+
 /**
  * Decide whether a dispatch-end worktree should be GC'd.
  *
@@ -494,41 +650,34 @@ function gcDispatchWorktreeIfOrphan(opts) {
   if (!gitRoot || !worktreeRoot) {
     return { outcome: 'skip', reason: 'no-git-root', removed: false };
   }
-  const _removeFn = typeof removeWorktree === 'function' ? removeWorktree : shared.removeWorktree;
-  const _rmOpts = excludeDispatchId ? { excludeDispatchId } : undefined;
-  const resolved = (() => { try { return path.resolve(worktreePath); } catch { return worktreePath; } })();
-  // W-mqinlicl §6 — reap the ending dispatch's own orphaned descendant tree
-  // BEFORE attempting removal. The owning dispatch is still 'active' at this
-  // point, so it is passed as `ownerDispatchId` (terminal-owner discovery would
-  // miss it) and as `excludeDispatchId` so the reaper's live-guard ignores this
-  // dispatch's own row. Failure here must never block the removal that follows.
-  if (typeof reapHolders === 'function') {
-    try {
-      reapHolders(worktreePath, { excludeDispatchId, ownerDispatchId: excludeDispatchId });
-    } catch (reapErr) {
-      log('warn', `worktree-gc: pre-remove reap threw for ${worktreePath}: ${reapErr && reapErr.message}`);
-    }
-  }
-  try {
-    const removed = _removeFn(worktreePath, gitRoot, worktreeRoot, _rmOpts);
-    if (removed) {
-      _markStuckSuccess(resolved, { writeToInbox });
-      log('info', `worktree-gc: dispatch-end removed ${path.basename(worktreePath)}`);
-      return { outcome: 'gc', reason: decision.reason, removed: true };
-    }
-    // W-mq5o6bvy000x7191 (Layer 4): track stuck dirs even on soft-false returns.
-    const { escalated, alreadyEscalated } = _maybeEscalateStuck(resolved, 'remove returned false', { config, writeToInbox });
-    if (!alreadyEscalated && !_isStuckPathSuppressed(resolved)) {
-      log('warn', `worktree-gc: dispatch-end remove returned false for ${worktreePath}`);
-    }
-    return { outcome: 'gc-failed', reason: 'remove-failed', removed: false, stuckEscalated: escalated };
-  } catch (gcErr) {
-    const { escalated, alreadyEscalated } = _maybeEscalateStuck(resolved, gcErr && gcErr.message, { config, writeToInbox });
-    if (!alreadyEscalated && !_isStuckPathSuppressed(resolved)) {
-      log('warn', `worktree-gc: dispatch-end remove threw for ${worktreePath}: ${gcErr.message}`);
-    }
-    return { outcome: 'gc-failed', reason: 'remove-threw', removed: false, stuckEscalated: escalated };
+  // P-c7e2b405 — dispatch-end usage of the shared reap-then-remove core:
+  // requireOwnerMarker:false (a dispatch GCs its own worktree regardless of
+  // marker), no slow-retry gate (slowRetryMs left null — a fresh worktree must
+  // never be slow-gated), pre-remove reapHolders, and excludeDispatchId threaded
+  // both as the removeWorktree rmOpt and as the reaper's owner/exclude id.
+  const r = reapAndRemoveWorktree({
+    worktreePath,
+    gitRoot,
+    parentDir: worktreeRoot,
+    rmOpts: excludeDispatchId ? { excludeDispatchId } : undefined,
+    reapHolders,
+    excludeDispatchId,
+    ownerDispatchId: excludeDispatchId,
+    config,
+    writeToInbox,
+    removeWorktree,
+    log,
+    successReason: decision.reason,
+    recheckSuppressedAfterEscalate: true,
+    onRemovedLog: () => `worktree-gc: dispatch-end removed ${path.basename(worktreePath)}`,
+    onFailLog: (kind, errMsg) => kind === 'threw'
+      ? `worktree-gc: dispatch-end remove threw for ${worktreePath}: ${errMsg}`
+      : `worktree-gc: dispatch-end remove returned false for ${worktreePath}`,
+  });
+  if (r.outcome === 'gc') {
+    return { outcome: 'gc', reason: r.reason, removed: true };
   }
+  return { outcome: 'gc-failed', reason: r.reason, removed: false, stuckEscalated: r.stuckEscalated };
 }
 
 /**
@@ -570,6 +719,11 @@ function pruneOrphanWorktrees(opts) {
   const _buildWorktreeDirName = typeof opts.buildWorktreeDirName === 'function'
     ? opts.buildWorktreeDirName
     : shared.buildWorktreeDirName;
+  // P-c7e2b405 — in-root pruner now honors the ownership marker identically to
+  // the out-of-root pruner (was the one site that didn't gate on it).
+  const _hasOwnerMarker = typeof opts.hasOwnerMarker === 'function'
+    ? opts.hasOwnerMarker
+    : shared.hasWorktreeOwnerMarker;
   const _listManagedSpecs = typeof opts.listManagedSpecs === 'function'
     ? opts.listManagedSpecs
     : (() => {
@@ -680,59 +834,38 @@ function pruneOrphanWorktrees(opts) {
         }
       }
 
-      try {
-        // W-mq5o6bvy000x7191 (Layer 4): respect slow-cadence retry for paths
-        // that have escalated past `worktreeStuckThreshold`.
-        const wtResolved = path.resolve(wtPath);
-        const slowRetryMs = (opts.config?.engine?.worktreeStuckSlowRetryMs)
-          ?? shared.ENGINE_DEFAULTS.worktreeStuckSlowRetryMs
-          ?? (30 * 60 * 1000);
-        if (!_shouldSlowRetry(wtResolved, slowRetryMs)) {
-          projStats.kept++; result.kept++;
-          continue;
-        }
-        const suppressed = _isStuckPathSuppressed(wtResolved);
-        const removed = _removeWorktree(wtPath, rootDir, wtParent);
-        if (removed) {
-          projStats.evicted++; result.evicted++;
-          _markStuckSuccess(wtResolved, { writeToInbox: opts.writeToInbox });
-          log('info', `worktree-gc: boot-evicted orphan ${name} for project ${project.name || 'default'}`);
-        } else {
-          projStats.failed++; result.failed++;
-          const escResult = _maybeEscalateStuck(wtResolved, 'remove returned false', {
-            config: opts.config, writeToInbox: opts.writeToInbox,
-            reason: 'orphan-sweep',
-            findProcessesWithCwdInside: opts.findProcessesWithCwdInside,
-            killImmediate: opts.killImmediate,
-          });
-          if (!escResult.alreadyEscalated && !suppressed) {
-            log('warn', `worktree-gc: boot-evict returned false for ${wtPath}`);
-          }
-          // W-mq6f2fe0000557fa — if auto-reap killed any holders, retry the
-          // removal once after a brief settle window. Clear the failure
-          // cache entry so the post-reap retry isn't suppressed by the
-          // 3-strike cooldown.
-          if (escResult.reapedPids && escResult.reapedPids.length > 0) {
-            _postReapRetry(wtPath, rootDir, wtParent, wtResolved, _removeWorktree, opts, projStats, result, log, escResult.reapedPids);
-          }
-        }
-      } catch (rmErr) {
-        projStats.failed++; result.failed++;
-        const wtResolved = path.resolve(wtPath);
-        const suppressed = _isStuckPathSuppressed(wtResolved);
-        const escResult = _maybeEscalateStuck(wtResolved, rmErr && rmErr.message, {
-          config: opts.config, writeToInbox: opts.writeToInbox,
-          reason: 'orphan-sweep',
-          findProcessesWithCwdInside: opts.findProcessesWithCwdInside,
-          killImmediate: opts.killImmediate,
-        });
-        if (!escResult.alreadyEscalated && !suppressed) {
-          log('warn', `worktree-gc: boot-evict threw for ${wtPath}: ${rmErr.message}`);
-        }
-        if (escResult.reapedPids && escResult.reapedPids.length > 0) {
-          _postReapRetry(wtPath, rootDir, wtParent, wtResolved, _removeWorktree, opts, projStats, result, log, escResult.reapedPids);
-        }
-      }
+      // P-c7e2b405 — route the slow-retry gate, ownership-marker gate (now
+      // requireOwnerMarker:true to match the out-of-root pruner), remove,
+      // escalate, and post-reap-retry through the shared helper. Counters are
+      // mutated in-place via `stats`.
+      const wtResolved = path.resolve(wtPath);
+      const slowRetryMs = (opts.config?.engine?.worktreeStuckSlowRetryMs)
+        ?? shared.ENGINE_DEFAULTS.worktreeStuckSlowRetryMs
+        ?? (30 * 60 * 1000);
+      reapAndRemoveWorktree({
+        worktreePath: wtPath,
+        gitRoot: rootDir,
+        parentDir: wtParent,
+        resolved: wtResolved,
+        slowRetryMs,
+        requireOwnerMarker: true,
+        escalateReason: 'orphan-sweep',
+        findProcessesWithCwdInside: opts.findProcessesWithCwdInside,
+        killImmediate: opts.killImmediate,
+        config: opts.config,
+        writeToInbox: opts.writeToInbox,
+        sleepSyncFn: opts.sleepSyncFn,
+        stats: [projStats, result],
+        removeWorktree: _removeWorktree,
+        hasOwnerMarker: _hasOwnerMarker,
+        log,
+        enablePostReapRetry: true,
+        onRemovedLog: () => `worktree-gc: boot-evicted orphan ${name} for project ${project.name || 'default'}`,
+        onFailLog: (kind, errMsg) => kind === 'threw'
+          ? `worktree-gc: boot-evict threw for ${wtPath}: ${errMsg}`
+          : `worktree-gc: boot-evict returned false for ${wtPath}`,
+        onMarkerSkipLog: () => `worktree-gc: keeping in-root ${wtResolved} — no engine ownership marker (foreign/hand-made worktree)`,
+      });
     }
     result.perProject[project.name || rootDir] = projStats;
   }
@@ -756,6 +889,9 @@ function pruneOrphanWorktrees(opts) {
  *                       used to compute the inside-root set we DO NOT touch
  *                       here (the existing scanner handles it).
  *   - log / fs / removeWorktree / listManagedSpecs / execSilent — injection
+ *   - parsedTreesByProject — optional Map<resolvedLocalPath, parsedTrees>
+ *     (P-d8f1a3c6). When set for a project, skip the self-shell of
+ *     `git worktree list --porcelain` and reuse the supplied parsed trees.
  *
  * Protection rules mirror `pruneOrphanWorktrees`:
  *   1. The main checkout (path === projectLocalPath) is always kept.
@@ -792,6 +928,15 @@ function pruneOrphanWorktreesFromGitRegistry(opts) {
   const _parseWorktreePorcelain = typeof opts.parseWorktreePorcelain === 'function'
     ? opts.parseWorktreePorcelain
     : shared.parseWorktreePorcelain;
+  // P-d8f1a3c6 — optional pre-parsed worktree-trees map keyed on the resolved
+  // project localPath. When the periodic sweep already shelled + parsed
+  // `git worktree list --porcelain` for a project (and shares the result with
+  // the missing-dir reclaimer), reuse it and skip our own self-shell. Absent
+  // for a project ⇒ fall back to the self-shelling path so every direct caller
+  // and unit test keeps working unchanged.
+  const _parsedTreesByProject = opts.parsedTreesByProject instanceof Map
+    ? opts.parsedTreesByProject
+    : null;
   // W-mqecdoot — positive ownership gate. An out-of-root worktree is only
   // engine-managed if it carries the ownership marker we stamp at creation
   // (shared.writeWorktreeOwnerMarker). Worktrees a human created by hand
@@ -852,23 +997,26 @@ function pruneOrphanWorktreesFromGitRegistry(opts) {
     const wtParentPrefix = wtParentAbs + path.sep;
 
     const projStats = { scanned: 0, kept: 0, evicted: 0, failed: 0, prunedRegistry: 0 };
-    let raw = '';
-    try {
-      raw = String(_execSilent('git --no-optional-locks worktree list --porcelain', {
-        cwd: rootDir, timeout: 15000, windowsHide: true,
-      }) || '');
-    } catch (e) {
-      log('warn', `worktree-gc: git worktree list failed for ${project.name || rootDir}: ${e.message}`);
-      result.perProject[project.name || rootDir] = projStats;
-      continue;
-    }
-
     let trees;
-    try { trees = _parseWorktreePorcelain(raw); }
-    catch (e) {
-      log('warn', `worktree-gc: parse worktree list failed for ${project.name || rootDir}: ${e.message}`);
-      result.perProject[project.name || rootDir] = projStats;
-      continue;
+    if (_parsedTreesByProject && _parsedTreesByProject.has(rootDir)) {
+      trees = _parsedTreesByProject.get(rootDir);
+    } else {
+      let raw = '';
+      try {
+        raw = String(_execSilent('git --no-optional-locks worktree list --porcelain', {
+          cwd: rootDir, timeout: 15000, windowsHide: true,
+        }) || '');
+      } catch (e) {
+        log('warn', `worktree-gc: git worktree list failed for ${project.name || rootDir}: ${e.message}`);
+        result.perProject[project.name || rootDir] = projStats;
+        continue;
+      }
+      try { trees = _parseWorktreePorcelain(raw); }
+      catch (e) {
+        log('warn', `worktree-gc: parse worktree list failed for ${project.name || rootDir}: ${e.message}`);
+        result.perProject[project.name || rootDir] = projStats;
+        continue;
+      }
     }
 
     for (const wt of trees) {
@@ -904,71 +1052,43 @@ function pruneOrphanWorktreesFromGitRegistry(opts) {
         if (anchored) { projStats.kept++; result.kept++; continue; }
       }
 
-      // W-mqecdoot — ownership gate. Only ever evict a worktree the engine
-      // positively created (carries the ownership marker stamped at
-      // `git worktree add` time). No marker → it's a human's hand-made worktree
-      // (or a pre-marker legacy dir); KEEP it and do NOT escalate. The
+      // P-c7e2b405 — ownership-marker gate, slow-retry gate, remove, escalate,
+      // and post-reap-retry now all flow through the shared helper
+      // (requireOwnerMarker:true — W-mqecdoot: only ever evict a worktree the
+      // engine positively created; no marker → human's hand-made worktree, KEEP
+      // and never escalate). parentDir is the dir *containing* this worktree
+      // (not the project's worktreeRoot, since this dir lives out-of-root). The
       // `git worktree prune --expire=now` below still drops registry entries
       // whose dirs are already gone, which is safe regardless of ownership.
-      let owned = false;
-      try { owned = !!_hasOwnerMarker(wtAbs); }
-      catch (_e) { owned = false; }
-      if (!owned) {
-        projStats.kept++; result.kept++;
-        log('debug', `worktree-gc: keeping out-of-root ${wtAbs} — no engine ownership marker (foreign/hand-made worktree)`);
-        continue;
-      }
-
-      // Slow-cadence gate for already-escalated stuck paths
       const slowRetryMs = (opts.config?.engine?.worktreeStuckSlowRetryMs)
         ?? shared.ENGINE_DEFAULTS.worktreeStuckSlowRetryMs
         ?? (30 * 60 * 1000);
-      if (!_shouldSlowRetry(wtAbs, slowRetryMs)) {
-        projStats.kept++; result.kept++; continue;
-      }
-
-      // parentDir for the safety boundary check inside removeWorktree must be
-      // the dir *containing* this worktree (not the project's worktreeRoot,
-      // since that's not where this dir lives).
       const parentDir = path.dirname(wtAbs);
-      const suppressed = _isStuckPathSuppressed(wtAbs);
-      try {
-        const removed = _removeWorktree(wtAbs, rootDir, parentDir);
-        if (removed) {
-          projStats.evicted++; result.evicted++;
-          _markStuckSuccess(wtAbs, { writeToInbox: opts.writeToInbox });
-          try { shared.bumpWorktreeGcMetric('outOfRootEvicted'); } catch { /* optional */ }
-          log('info', `worktree-gc: out-of-root evicted ${wtAbs} for project ${project.name || 'default'}`);
-        } else {
-          projStats.failed++; result.failed++;
-          const escResult = _maybeEscalateStuck(wtAbs, 'remove returned false', {
-            config: opts.config, writeToInbox: opts.writeToInbox,
-            reason: 'orphan-sweep',
-            findProcessesWithCwdInside: opts.findProcessesWithCwdInside,
-            killImmediate: opts.killImmediate,
-          });
-          if (!escResult.alreadyEscalated && !suppressed) {
-            log('warn', `worktree-gc: out-of-root remove returned false for ${wtAbs}`);
-          }
-          if (escResult.reapedPids && escResult.reapedPids.length > 0) {
-            _postReapRetry(wtAbs, rootDir, parentDir, wtAbs, _removeWorktree, opts, projStats, result, log, escResult.reapedPids);
-          }
-        }
-      } catch (rmErr) {
-        projStats.failed++; result.failed++;
-        const escResult = _maybeEscalateStuck(wtAbs, rmErr && rmErr.message, {
-          config: opts.config, writeToInbox: opts.writeToInbox,
-          reason: 'orphan-sweep',
-          findProcessesWithCwdInside: opts.findProcessesWithCwdInside,
-          killImmediate: opts.killImmediate,
-        });
-        if (!escResult.alreadyEscalated && !suppressed) {
-          log('warn', `worktree-gc: out-of-root remove threw for ${wtAbs}: ${rmErr.message}`);
-        }
-        if (escResult.reapedPids && escResult.reapedPids.length > 0) {
-          _postReapRetry(wtAbs, rootDir, parentDir, wtAbs, _removeWorktree, opts, projStats, result, log, escResult.reapedPids);
-        }
-      }
+      reapAndRemoveWorktree({
+        worktreePath: wtAbs,
+        gitRoot: rootDir,
+        parentDir,
+        resolved: wtAbs,
+        slowRetryMs,
+        requireOwnerMarker: true,
+        escalateReason: 'orphan-sweep',
+        findProcessesWithCwdInside: opts.findProcessesWithCwdInside,
+        killImmediate: opts.killImmediate,
+        config: opts.config,
+        writeToInbox: opts.writeToInbox,
+        sleepSyncFn: opts.sleepSyncFn,
+        stats: [projStats, result],
+        removeWorktree: _removeWorktree,
+        hasOwnerMarker: _hasOwnerMarker,
+        log,
+        successMetric: 'outOfRootEvicted',
+        enablePostReapRetry: true,
+        onRemovedLog: () => `worktree-gc: out-of-root evicted ${wtAbs} for project ${project.name || 'default'}`,
+        onFailLog: (kind, errMsg) => kind === 'threw'
+          ? `worktree-gc: out-of-root remove threw for ${wtAbs}: ${errMsg}`
+          : `worktree-gc: out-of-root remove returned false for ${wtAbs}`,
+        onMarkerSkipLog: () => `worktree-gc: keeping out-of-root ${wtAbs} — no engine ownership marker (foreign/hand-made worktree)`,
+      });
     }
 
     // Always finish with `git worktree prune --expire=now` to drop registry
@@ -1019,7 +1139,9 @@ function pruneOrphanWorktreesFromGitRegistry(opts) {
  *
  * Injection points (all optional — default to the real implementations):
  *   projects, log, fs, execSilent, parseWorktreePorcelain, isWorktreePathLive,
- *   db.
+ *   db, parsedTreesByProject (Map<resolvedLocalPath, parsedTrees>; P-d8f1a3c6 —
+ *   when set for a project, skip the self-shell of `git worktree list
+ *   --porcelain` and reuse the supplied parsed trees).
  *
  * Returns `{ scanned, reclaimed, skippedLive, failed, perProject }` where
  * `scanned` counts only the missing-dir candidates considered (dirs that still
@@ -1036,6 +1158,14 @@ function reclaimMissingDirWorktrees(opts) {
   const _parseWorktreePorcelain = typeof opts.parseWorktreePorcelain === 'function'
     ? opts.parseWorktreePorcelain
     : shared.parseWorktreePorcelain;
+  // P-d8f1a3c6 — optional pre-parsed worktree-trees map keyed on the resolved
+  // project localPath, shared with pruneOrphanWorktreesFromGitRegistry so the
+  // periodic sweep only shells `git worktree list --porcelain` once per
+  // project. Absent for a project ⇒ self-shell (back-compat for direct callers
+  // and existing unit tests).
+  const _parsedTreesByProject = opts.parsedTreesByProject instanceof Map
+    ? opts.parsedTreesByProject
+    : null;
   const _isWorktreePathLive = typeof opts.isWorktreePathLive === 'function'
     ? opts.isWorktreePathLive
     : shared.isWorktreePathLive;
@@ -1053,23 +1183,26 @@ function reclaimMissingDirWorktrees(opts) {
     if (!rootExists) continue;
 
     const projStats = { scanned: 0, reclaimed: 0, skippedLive: 0, failed: 0 };
-    let raw = '';
-    try {
-      raw = String(_execSilent('git --no-optional-locks worktree list --porcelain', {
-        cwd: rootDir, timeout: 15000, windowsHide: true,
-      }) || '');
-    } catch (e) {
-      log('warn', `worktree-gc: missing-dir reclaim list failed for ${project.name || rootDir}: ${e.message}`);
-      result.perProject[project.name || rootDir] = projStats;
-      continue;
-    }
-
     let trees;
-    try { trees = _parseWorktreePorcelain(raw); }
-    catch (e) {
-      log('warn', `worktree-gc: missing-dir reclaim parse failed for ${project.name || rootDir}: ${e.message}`);
-      result.perProject[project.name || rootDir] = projStats;
-      continue;
+    if (_parsedTreesByProject && _parsedTreesByProject.has(rootDir)) {
+      trees = _parsedTreesByProject.get(rootDir);
+    } else {
+      let raw = '';
+      try {
+        raw = String(_execSilent('git --no-optional-locks worktree list --porcelain', {
+          cwd: rootDir, timeout: 15000, windowsHide: true,
+        }) || '');
+      } catch (e) {
+        log('warn', `worktree-gc: missing-dir reclaim list failed for ${project.name || rootDir}: ${e.message}`);
+        result.perProject[project.name || rootDir] = projStats;
+        continue;
+      }
+      try { trees = _parseWorktreePorcelain(raw); }
+      catch (e) {
+        log('warn', `worktree-gc: missing-dir reclaim parse failed for ${project.name || rootDir}: ${e.message}`);
+        result.perProject[project.name || rootDir] = projStats;
+        continue;
+      }
     }
 
     let reclaimedHere = 0;
@@ -1137,6 +1270,7 @@ module.exports = {
   pruneOrphanWorktrees,
   pruneOrphanWorktreesFromGitRegistry,
   reclaimMissingDirWorktrees, // W-mqifblkf00149df5 — locked-initializing missing-dir reaper
+  reapAndRemoveWorktree, // P-c7e2b405 — shared reap-then-remove core (exported for testing)
   // exported for testing (W-mq5o6bvy000x7191)
   _resetStuckPathsForTesting,
   _stuckPaths,