@yemi33/minions 0.1.2148 → 0.1.2149

package/dashboard/js/settings.js

@@ -292,12 +292,19 @@ async function openSettings() {
     '<div class="settings-pane-sub">Persistent CC worker pool and git worktree provisioning. Tune these only if you see worktree-create timeouts or slow CC cold-spawns.</div>' +
     '<div class="settings-stack" style="margin-bottom:12px">' +
       settingsToggle('CC Worker Pool', 'set-ccUseWorkerPool', (e.ccUseWorkerPool === undefined ? ((e.ccCli || e.defaultCli) === 'copilot') : !!e.ccUseWorkerPool), 'Route Command Center / doc-chat through a persistent copilot --acp worker per tab instead of spawning a fresh CLI per turn. Copilot-only (Agent Client Protocol transport); Claude does not implement ACP, so this toggle has no effect when CC runtime is Claude. Default ON for copilot (cold-spawn ~20s on Windows); forced OFF for non-copilot CC runtimes regardless of this toggle.') +
+      // W-mq6f2fe0000557fa — opt-in: auto-kill orphan spawn-agent processes
+      // holding a stuck worktree's cwd. Gated by safe-reap criteria (cmdline
+      // matches spawn-agent.js + basename + age > agentTimeout * 2). Default
+      // OFF because killing a foreign process is destructive.
+      settingsToggle('Auto-reap orphan worktree holders', 'set-autoReapOrphanWorktreeHolders', !!e.autoReapOrphanWorktreeHolders,
+        'When ON, the periodic orphan-worktree sweep automatically kills unambiguous orphan `spawn-agent.js` processes holding a stuck worktree\'s cwd (Windows file-lock pattern, e.g. W-mq1k8z6o003acd89 / PID 16828). Safe-reap criteria: cmdline must match spawn-agent.js, reference the worktree basename, AND process age must exceed `engine.agentTimeout * 2`. Default OFF because killing a foreign process is destructive. The holder SCAN runs either way and is appended to the escalation inbox note.') +
     '</div>' +
     '<div class="settings-grid-2">' +
       settingsField('Worktree Create Timeout', 'set-worktreeCreateTimeout', e.worktreeCreateTimeout || 300000, 'ms', 'Timeout for git worktree add (increase for large repos/Windows)') +
       settingsField('Worktree Create Retries', 'set-worktreeCreateRetries', e.worktreeCreateRetries || 1, '', 'Retry count for transient worktree add failures (0-3)') +
       settingsField('Worktree Root', 'set-worktreeRoot', e.worktreeRoot || '../worktrees', '', 'Relative or absolute path for git worktrees; on Windows prefer a short path like C:\\wt') +
       settingsField('Assert-Clean Status Probe Timeout', 'set-assertCleanStatusTimeoutMs', e.assertCleanStatusTimeoutMs || 10000, 'ms', 'Timeout for the `git status --porcelain` preflight probe in assertCleanSharedWorktree. Raise this (e.g. 60000) on GVFS/Plastic-backed monorepos where sparse hydration runs longer than the 10s default. On timeout the engine quarantines the bad worktree and emits a RETRYABLE failure so the next dispatch starts fresh. Clamped 1000–120000ms.') +
+      settingsField('Orphan-holder scan timeout', 'set-orphanHolderScanTimeoutMs', e.orphanHolderScanTimeoutMs || 5000, 'ms', 'Cap on the cross-platform scan (PowerShell / /proc walk / lsof) that identifies the OS process holding a stuck worktree\'s cwd. Bumps up only matter on heavily-loaded hosts where the holder scan races the sweep tick. Clamped 1000–30000ms.') +
     '</div>';
 
   const paneCopilot =
@@ -873,6 +880,8 @@ async function saveSettings() {
       autoFixHumanComments: document.getElementById('set-autoFixHumanComments').checked,
       autoCompletePrs: document.getElementById('set-autoCompletePrs').checked,
       ccUseWorkerPool: !!document.getElementById('set-ccUseWorkerPool')?.checked,
+      autoReapOrphanWorktreeHolders: !!document.getElementById('set-autoReapOrphanWorktreeHolders')?.checked,
+      orphanHolderScanTimeoutMs: document.getElementById('set-orphanHolderScanTimeoutMs')?.value,
       adoPollEnabled: document.getElementById('set-adoPollEnabled').checked,
       ghPollEnabled: document.getElementById('set-ghPollEnabled').checked,
       prPollStatusEvery: document.getElementById('set-prPollStatusEvery').value,

package/dashboard.js

@@ -9361,6 +9361,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           // 2min ceiling (covers even a GVFS-backed sparse hydration without
           // letting a config typo wedge dispatch for an hour).
           assertCleanStatusTimeoutMs: [1000, 120000],
+          // W-mq6f2fe0000557fa — cap on the cross-platform holder scan for the
+          // orphan-worktree GC. 1s floor (PowerShell startup alone is 0.5–1s);
+          // 30s ceiling (the scan runs once per orphan-sweep tick and a slow
+          // scan must not block the rest of the sweep for minutes).
+          orphanHolderScanTimeoutMs: [1000, 30000],
           idleAlertMinutes: [1], shutdownTimeout: [30000], restartGracePeriod: [60000],
           meetingRoundTimeout: [60000],
           // W-mq066js7000fff1f-c (Gap B/C): steering safety-net knobs.

package/engine/ado.js

@@ -395,6 +395,24 @@ function applyAdoPrMetadata(pr, prData) {
     updated = true;
   }
 
+  // #3079 — Track target ref + clear stale merge-conflict dispatch state
+  // when the PR is retargeted. The same-head guard at engine.js:5676 and
+  // the MERGE_CONFLICT fingerprint at shared.js:6595 are now target-aware
+  // (via shared.prMergeConflictGuardKey), but pre-existing
+  // _lastDispatchByCause[MERGE_CONFLICT] / _noOpFixes[MERGE_CONFLICT]
+  // records would still block re-dispatch until something else cleared
+  // them. Reset them explicitly on retarget. First-poll seeding
+  // (no prior targetRefName) is a no-op so we don't strip state immediately
+  // after upsert.
+  const nextTargetRef = String(prData.targetRefName || '').trim();
+  if (nextTargetRef && pr.targetRefName !== nextTargetRef) {
+    if (shared.resetMergeConflictStateOnRetarget(pr, nextTargetRef)) {
+      log('info', `ADO: PR ${pr.id || '?'} retargeted ${pr.targetRefName} → ${nextTargetRef}, clearing stale MERGE_CONFLICT dispatch records`);
+    }
+    pr.targetRefName = nextTargetRef;
+    updated = true;
+  }
+
   return updated;
 }
 
@@ -2600,6 +2618,7 @@ module.exports = {
   fetchAdoPrMetadata,
   fetchSinglePrBuildStatus,
   findOpenPrOnBranch,
+  applyAdoPrMetadata, // #3079 — exported for unit tests of targetRefName + retarget reset
   _resetAdoThrottle, // exported for testing
   _setAdoThrottleForTest, // exported for testing
   _setAdoTokenForTest, // exported for testing

package/engine/dispatch.js

@@ -400,6 +400,7 @@ function isRetryableFailureReason(reason = '', failureClass = '') {
       FAILURE_CLASS.WORKTREE_PREFLIGHT, // pre-spawn worktree validation — recompute will produce the same failure
       FAILURE_CLASS.WORKTREE_DIRTY,     // #2996: reused worktree was dirty and could not be auto-healed — non-retryable for this dispatch attempt; the engine quarantined the worktree so the next discovery cycle creates a fresh one
       FAILURE_CLASS.WORKTREE_DIVERGENT, // #2996: reused worktree's local branch had unpushed commits — engine quarantined + backed up the local ref; non-retryable for this dispatch (next discovery creates fresh worktree on origin/<branch>)
+      FAILURE_CLASS.WORKTREE_QUARANTINE_ENV_BLOCKED, // W-mq5n1zx5: quarantine rename couldn't release the worktree dir even after retry + force-remove fallback. Non-retryable at the dispatch level so the per-agent retry counter isn't bumped (environmental, not the agent's fault); the WI auto-recovery loop in engine.js#discoverFromWorkItems re-queues without touching _retriesByAgent.
       FAILURE_CLASS.INVALID_KEEP_PROCESSES_WORKDIR, // W-mp6k7ywi000fa33c — keep-pids cwd is not a real git worktree; re-running won't fix the structural issue
       FAILURE_CLASS.INVALID_KEEP_PROCESSES_SCHEMA, // W-mp7i902u000l991f — keep-pids.json failed shape validation; re-running with the same wrong file won't fix it
       FAILURE_CLASS.INVALID_MANAGED_SPAWN, // W-mpbhxg3b000u8411 — managed-spawn.json failed validation; re-running with the same wrong file won't fix it
@@ -770,6 +771,7 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
             [FAILURE_CLASS.WORKTREE_PREFLIGHT]: 'worktree preflight rejected (nested in project root or rootDir collapsed to drive root)',
             [FAILURE_CLASS.WORKTREE_DIRTY]: 'reused worktree had uncommitted edits and could not be auto-healed (#2996) — engine quarantined the dir so the next dispatch creates a fresh worktree',
             [FAILURE_CLASS.WORKTREE_DIVERGENT]: 'reused worktree had unpushed local commits ahead of origin (#2996) — engine backed up the local ref and quarantined the dir so the next dispatch starts from origin/<branch>',
+            [FAILURE_CLASS.WORKTREE_QUARANTINE_ENV_BLOCKED]: 'quarantine rename was blocked by the OS (Windows EBUSY/EPERM) even after retry + force-remove fallback — environmental, not the agent\'s fault; auto-recovery loop will re-queue without bumping per-agent retries',
             [FAILURE_CLASS.INVALID_KEEP_PROCESSES_WORKDIR]: 'keep_processes cwd is not a real git worktree (rerun in a `git worktree add` directory)',
             [FAILURE_CLASS.INVALID_KEEP_PROCESSES_SCHEMA]: 'keep-pids.json failed shape validation (wrong keys/types/values — see inbox alert for the canonical shape)',
             [FAILURE_CLASS.INVALID_MANAGED_SPAWN]: 'managed-spawn.json failed validation (bad schema, workdir, or allowlist — see inbox alert)',

package/engine/github.js

@@ -748,6 +748,20 @@ async function pollPrStatus(config) {
       updated = true;
     }
 
+    // #3079 — Track GitHub target branch name + clear stale merge-conflict
+    // dispatch state when the PR is retargeted (e.g. `gh pr edit --base
+    // master` after parent PR merges). Mirrors ado.js applyAdoPrMetadata.
+    // First-poll seeding (no prior baseRefName) is a no-op so we don't
+    // strip state immediately after upsert.
+    const nextBaseRefName = String(prData.base?.ref || '').trim();
+    if (nextBaseRefName && pr.baseRefName !== nextBaseRefName) {
+      if (shared.resetMergeConflictStateOnRetarget(pr, nextBaseRefName)) {
+        log('info', `GitHub: PR ${pr.id} retargeted ${pr.baseRefName} → ${nextBaseRefName}, clearing stale MERGE_CONFLICT dispatch records`);
+      }
+      pr.baseRefName = nextBaseRefName;
+      updated = true;
+    }
+
     // P-w1a3f9b2 — Phase 1.1: plumb mergeable / isDraft / mergeStateStatus /
     // headRefOid onto the PR object so watches captureState (engine/watches.js)
     // and future predicates (Phase 2.1: head-commit-change, mergeable-flipped,

package/engine/lifecycle.js

@@ -2291,6 +2291,15 @@ function recordPrNoOpFixAttempt(target, cause, source, dispatchItem, branchChang
           return out;
         })()
       : {}),
+    // #3079 — MERGE_CONFLICT noops record the composite guard key (source
+    // head + base SHA + target ref name). The same-head guard at
+    // engine.js:5676 reads this back and compares against the current
+    // PR's prMergeConflictGuardKey, so a retarget (target ref change) or
+    // a parent-merge (base SHA change) naturally releases the pause even
+    // when the source head didn't move.
+    ...(cause === shared.PR_FIX_CAUSE.MERGE_CONFLICT
+      ? { mergeConflictKey: shared.prMergeConflictGuardKey(target) }
+      : {}),
   };
   target.lastDispatchedAt = now;
   target.lastDispatchOutcome = 'noop';
@@ -2664,6 +2673,14 @@ function updatePrAfterFixError(pr, project, source, options = {}) {
           || '');
       if (commentKey) next.lastProcessedCommentKey = commentKey;
     }
+    // #3079 — Refresh mergeConflictKey from live target state so a
+    // mid-flight retarget reflects in the agent-error record too. The
+    // engine.js skipConflictFix guard prefers mergeConflictKey over
+    // legacy headSha; without this refresh, the prior record's stale
+    // key could re-fire the suppression even after a retarget.
+    if (cause === shared.PR_FIX_CAUSE.MERGE_CONFLICT) {
+      next.mergeConflictKey = shared.prMergeConflictGuardKey(target);
+    }
     target._lastDispatchByCause[cause] = next;
     result = { cause, indeterminate: true, errorClass };
     log('warn', `Updated ${pr.id} → recorded ${cause} agent-error fix attempt (indeterminate=true) — same-head guard relaxed for next tick${errorMessage ? ` (${errorMessage.slice(0, 80)})` : ''}`);

package/engine/shared.js

@@ -2352,6 +2352,30 @@ const ENGINE_DEFAULTS = {
   autoConsolidateMemory: false, // opt-in: periodically spawn engine/kb-sweep-runner.js from the tick loop (4h cadence). Inbox→notes consolidation already runs every tick via consolidateInbox; this flag only controls the KB sweep.
   prNoOpFixPauseAttempts: 2, // pause one PR automation cause after repeated no-op fixes for unchanged evidence
   quarantineAutoRecoveryMax: 2, // #2996 follow-up: cap on auto-flipping WORKTREE_DIRTY/WORKTREE_DIVERGENT failures back to pending (the quarantine is self-healing so the next dispatch starts clean; the cap prevents infinite loops if quarantine itself keeps failing).
+  // W-mq5n1zx5 — Layer 1a/2b: harden the quarantine rename path against
+  // Windows EBUSY/EPERM races where a lingering `git.exe` descendant (leaked
+  // by a status-probe timeout) still holds packfile handles when we try to
+  // rename the worktree dir out of the way. With these on, the engine
+  // retries the rename with jittered backoff (worst case ≈ baseMs * 2^N + N
+  // jitter), then — if everything still fails — asks git to tear down its
+  // own worktree record via `git worktree remove --force` so the next
+  // dispatch isn't blocked by a half-renamed tree. Each knob is overridable
+  // via `config.engine.<name>`.
+  quarantineRenameRetryAttempts: 6,
+  quarantineRenameRetryBaseMs: 250,
+  quarantineForceRemoveFallback: true,
+  // W-mq5n1zx5 — Layer 1b/2a: pre-empt the EBUSY race itself. (1b)
+  // `--no-optional-locks` tells git to skip the .git/index.lock acquire
+  // around the untracked-cache refresh in status; typical probe duration
+  // under AV drops from 6–12s to <500ms, removing the timeout that
+  // creates the leaked child in the first place. (2a) On Windows only,
+  // before attempting the rename we walk live git.exe processes whose
+  // command line points at the worktree path and Stop-Process them, so
+  // a still-alive descendant from a previous status probe doesn't pin
+  // packfile handles. Both gates are belt-and-suspenders — most
+  // incidents are closed by (1b) alone — but both are cheap and idempotent.
+  statusProbeUseNoOptionalLocks: true,
+  statusProbeKillDescendantsWin32: true,
   completionReportRetentionDays: 90, // retain completion report sidecars beyond capped dispatch history
   completionReportMaxFiles: 5000, // hard cap for completion report sidecars during cleanup
   // P-bfa2c-cors-wildcard: extra Origins permitted to receive an
@@ -2538,6 +2562,17 @@ const ENGINE_DEFAULTS = {
   worktreeStuckThreshold: 10,               // consecutive removal failures before escalation
   worktreeStuckSuppressMs: 60 * 60 * 1000,  // 60min — suppress per-tick warn after escalation
   worktreeStuckSlowRetryMs: 30 * 60 * 1000, // 30min — slow-cadence retry window after escalation
+  // W-mq6f2fe0000557fa — orphan-worktree GC: identify the OS process holding
+  // a stuck worktree's cwd and, behind this opt-in flag, kill it. Default OFF
+  // because killing a foreign process is destructive; flipping on rescues the
+  // engine from the W-mq1k8z6o003acd89 / PID 16828 lock-spin pattern automatically.
+  // Auto-reap only fires for processes whose cmdline matches `spawn-agent.js`
+  // AND whose age exceeds `agentTimeout * 2` AND that have no live dispatch row
+  // — i.e. unambiguous orphan agents the engine forgot about. The holder scan
+  // itself ALWAYS runs on every orphan-sweep escalation (the flag only gates
+  // the kill); holder details are appended to the inbox note either way.
+  autoReapOrphanWorktreeHolders: false,
+  orphanHolderScanTimeoutMs: 5000,          // 5s ceiling for the cross-platform holder scan (PowerShell / /proc walk / lsof)
   ccMaxTurns: 50, // max tool-use turns per CC/doc-chat call before CLI stops (per response, not per session)
   ccTurnTimeoutMs: 300000, // W-mpmwxni2000c25c7-b/-d: 5min per-turn no-progress watchdog. The window resets on every liveness signal — token chunk, tool-call notification, tool-update — so an actively-streaming CC/doc-chat turn (long shell command, deep search, sub-agent loop) survives indefinitely up to the outer CC_CALL_TIMEOUT_MS (~1h) ceiling. Only true silence past this window with no progress fires the cancel: the in-flight LLM call is aborted and the handler surfaces `{code:'cc-turn-timeout', retryable:true}` via the typed error envelope so the UI can stop the spinner and offer Retry. Clamped to [10000, 3600000] in the settings POST handler. Independent of CC_CALL_TIMEOUT_MS. Non-streaming doc-chat is the lone wall-clock exception (no progress hooks); see _raceCcDocChatTimeout in dashboard.js for the dual factory/promise shape.
   docSessionMaxEntries: 200, // cap doc-chat session map/disk store by least-recent activity (LRU; sessions are non-expiring otherwise)
@@ -3682,6 +3717,7 @@ const FAILURE_CLASS = {
   WORKTREE_PREFLIGHT: 'worktree-preflight', // Pre-spawn worktree validation rejected (nested-in-project, drive-root collapse) — never retryable
   WORKTREE_DIRTY: 'worktree-dirty',         // #2996: reused worktree had uncommitted edits and the engine could not auto-heal (or already quarantined). Non-retryable for this dispatch — next discovery cycle creates a fresh worktree.
   WORKTREE_DIVERGENT: 'worktree-divergent', // #2996: reused worktree's local branch was N commits ahead of origin (unsafe to reset, may contain unpushed agent work). Engine quarantined the worktree + backed up the local ref; non-retryable for this dispatch.
+  WORKTREE_QUARANTINE_ENV_BLOCKED: 'worktree-quarantine-env-blocked', // W-mq5n1zx5: quarantine rename was attempted but the OS refused to release the worktree dir (Windows EBUSY/EPERM/EACCES from a lingering git.exe descendant). Engine retried with jittered backoff and (when enabled) `git worktree remove --force`; if all paths failed we surface this dedicated class so the WI auto-recovery loop can re-queue WITHOUT bumping the per-agent retry counter (the failure is environmental, not the agent's fault).
   DEPENDENCY_MERGE_SETUP: 'dependency-merge-setup', // Dependency pre-merge plumbing (stash/status/reset) failed before a real file conflict was verified. Retryable so a fresh worktree can recover.
   INVALID_KEEP_PROCESSES_WORKDIR: 'invalid-keep-processes-workdir', // W-mp6k7ywi000fa33c: keep-pids.json declared a cwd that is not a real git worktree (likely a selective copy of the repo) — never retryable; agent must rerun in a real worktree
   INVALID_KEEP_PROCESSES_SCHEMA: 'invalid-keep-processes-schema', // W-mp7i902u000l991f: keep-pids.json failed validation for a reason other than workdir (pids-missing, ttl-too-long, expires_at-missing, pids-too-many, port-invalid, etc.) — agent wrote the wrong shape; never retryable until they fix the file
@@ -6239,6 +6275,189 @@ function listAllProcesses() {
   return process.platform === 'win32' ? _winListProcesses() : _unixListProcesses();
 }
 
+// W-mq6f2fe0000557fa — orphan-worktree GC: identify OS processes whose cwd
+// is at or inside `dir`. Cross-platform with a fail-open contract: on any
+// error or timeout we return [] (the caller continues with its existing
+// escalation path and an unenriched note).
+//
+// Return shape: [{ pid, cmdline, startedAt, ageMs }, ...]
+//   - pid: numeric OS pid
+//   - cmdline: full command line as a single string (best-effort; possibly truncated)
+//   - startedAt: ms-since-epoch process start time (0 when unknown)
+//   - ageMs: Date.now() - startedAt (0 when startedAt is 0)
+//
+// Platform notes:
+//   - Windows: PowerShell `Get-CimInstance Win32_Process` filtered by the
+//     worktree basename appearing in CommandLine. (Win32_Process does not
+//     expose the working directory; the basename match is the most-reliable
+//     heuristic — every spawn-agent invocation embeds the dispatch id, which
+//     is the worktree basename, in its argv.)
+//   - Linux: walk `/proc/*/cwd` and keep PIDs whose readlinkSync resolves
+//     under `dir`. Cmdline read from `/proc/<pid>/cmdline` (NUL-separated).
+//     Start time derived from stat() mtime of the cwd entry as a proxy.
+//   - macOS: `lsof -F p -d cwd` filtered by directory, then `ps -p <pid>` for
+//     cmdline + start time.
+function findProcessesWithCwdInside(dir, opts = {}) {
+  if (!dir || typeof dir !== 'string') return [];
+  let resolved;
+  try { resolved = path.resolve(dir); } catch { return []; }
+  if (!resolved) return [];
+  const timeoutMs = Number(opts.timeoutMs) > 0
+    ? Number(opts.timeoutMs)
+    : (ENGINE_DEFAULTS.orphanHolderScanTimeoutMs || 5000);
+  const now = Date.now();
+
+  try {
+    if (process.platform === 'win32') {
+      return _findWindowsProcessesWithCwdInside(resolved, timeoutMs, now);
+    }
+    if (process.platform === 'linux') {
+      return _findLinuxProcessesWithCwdInside(resolved, timeoutMs, now);
+    }
+    return _findMacProcessesWithCwdInside(resolved, timeoutMs, now);
+  } catch { return []; }
+}
+
+function _findWindowsProcessesWithCwdInside(resolved, timeoutMs, now) {
+  // Win32_Process exposes CommandLine but not the cwd. Match by basename of
+  // the worktree dir (the dispatch id like W-mq1k8z6o003acd89) appearing in
+  // the cmdline — every spawn-agent prompt-file path embeds it.
+  const basename = path.basename(resolved);
+  if (!basename || basename.length < 3) return [];
+  // PowerShell-quote: outer escape ' as ''
+  const psBasename = basename.replace(/'/g, "''");
+  const psResolved = resolved.replace(/'/g, "''");
+  // Use -like with wildcards on BOTH basename and full path so a process
+  // whose cmdline carries the worktree dir (but a different basename
+  // anywhere in argv) also matches.
+  const script = `Get-CimInstance Win32_Process | Where-Object { ($_.CommandLine -like '*${psBasename}*') -or ($_.CommandLine -like '*${psResolved}*') } | ForEach-Object { [PSCustomObject]@{ pid = $_.ProcessId; cmdline = $_.CommandLine; startedAt = if ($_.CreationDate) { [int64](([datetimeoffset]$_.CreationDate).ToUnixTimeMilliseconds()) } else { 0 } } } | ConvertTo-Json -Compress -Depth 2`;
+  let raw;
+  try {
+    raw = _execSync(
+      `powershell -NoProfile -NonInteractive -Command "${script}"`,
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: timeoutMs, windowsHide: true, maxBuffer: 4 * 1024 * 1024 }
+    );
+  } catch { return []; }
+  if (!raw || !String(raw).trim()) return [];
+  let parsed;
+  try { parsed = JSON.parse(raw); }
+  catch { return []; }
+  const arr = Array.isArray(parsed) ? parsed : [parsed];
+  const out = [];
+  for (const r of arr) {
+    if (!r) continue;
+    const pid = Number(r.pid);
+    if (!Number.isInteger(pid) || pid <= 0) continue;
+    const startedAt = Number(r.startedAt) || 0;
+    out.push({
+      pid,
+      cmdline: r.cmdline ? String(r.cmdline) : '',
+      startedAt,
+      ageMs: startedAt > 0 ? Math.max(0, now - startedAt) : 0,
+    });
+  }
+  return out;
+}
+
+function _findLinuxProcessesWithCwdInside(resolved, _timeoutMs, now) {
+  // /proc walk: scan numeric entries, readlink cwd, keep matches.
+  let entries;
+  try { entries = fs.readdirSync('/proc'); }
+  catch { return []; }
+  const prefix = resolved + path.sep;
+  const out = [];
+  for (const e of entries) {
+    if (!/^\d+$/.test(e)) continue;
+    const pid = Number(e);
+    let cwd;
+    try { cwd = fs.readlinkSync(`/proc/${pid}/cwd`); }
+    catch { continue; }
+    if (!cwd) continue;
+    if (cwd !== resolved && !cwd.startsWith(prefix)) continue;
+    let cmdline = '';
+    try {
+      const buf = fs.readFileSync(`/proc/${pid}/cmdline`);
+      cmdline = buf.toString('utf8').replace(/\0/g, ' ').trim();
+    } catch { /* cmdline read can fail on race */ }
+    let startedAt = 0;
+    try {
+      const st = fs.statSync(`/proc/${pid}`);
+      startedAt = st && st.ctimeMs ? Math.floor(st.ctimeMs) : 0;
+    } catch { /* stat can fail on race */ }
+    out.push({
+      pid,
+      cmdline,
+      startedAt,
+      ageMs: startedAt > 0 ? Math.max(0, now - startedAt) : 0,
+    });
+  }
+  return out;
+}
+
+function _findMacProcessesWithCwdInside(resolved, timeoutMs, now) {
+  // `lsof -a -d cwd -F pn` emits PID then cwd path. Filter for dir matches,
+  // then run a single `ps` pass to enrich cmdline + start time.
+  let raw;
+  try {
+    raw = _execSync('lsof -a -d cwd -F pn 2>/dev/null', {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024,
+    });
+  } catch { return []; }
+  if (!raw) return [];
+  const prefix = resolved + path.sep;
+  const pids = new Set();
+  let currentPid = null;
+  for (const line of String(raw).split(/\r?\n/)) {
+    if (!line) continue;
+    const tag = line[0];
+    const val = line.slice(1);
+    if (tag === 'p') {
+      const n = Number(val);
+      currentPid = Number.isInteger(n) && n > 0 ? n : null;
+    } else if (tag === 'n' && currentPid != null) {
+      if (val === resolved || val.startsWith(prefix)) pids.add(currentPid);
+    }
+  }
+  if (pids.size === 0) return [];
+  const out = [];
+  for (const pid of pids) {
+    let line;
+    try {
+      line = String(_execSync(`ps -p ${pid} -o lstart=,command=`, {
+        stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000, encoding: 'utf8',
+      }) || '').trim();
+    } catch { line = ''; }
+    let startedAt = 0;
+    let cmdline = '';
+    if (line) {
+      // ps lstart= emits "Mon Jun  9 07:04:33 2026" (24 chars), then cmdline.
+      const lstart = line.slice(0, 24).trim();
+      cmdline = line.slice(24).trim();
+      const parsed = Date.parse(lstart);
+      if (!Number.isNaN(parsed)) startedAt = parsed;
+    }
+    out.push({
+      pid,
+      cmdline,
+      startedAt,
+      ageMs: startedAt > 0 ? Math.max(0, now - startedAt) : 0,
+    });
+  }
+  return out;
+}
+
+// W-mq6f2fe0000557fa — clear the per-path failure cooldown entry so the
+// post-holder-reap retry can attempt removeWorktree even though the path
+// has already failed >= 3 times. Without this, the cooldown silently
+// suppresses the retry and the orphan dir is left stuck.
+function clearWorktreeFailureCache(wtPath) {
+  if (!wtPath) return false;
+  try {
+    const resolved = path.resolve(wtPath);
+    return _removeWorktreeFailures.delete(resolved);
+  } catch { return false; }
+}
+
 // Cross-check a single PID's command line for a Minions agent invocation
 // (`claude` or `copilot`, including the `node spawn-agent.js --runtime <name>`
 // wrapper and `gh copilot` fallback). Used by orphan/recycled-PID safety:
@@ -6573,6 +6792,61 @@ function _prHeadSha(pr) {
   return String(pr?.headRefOid || pr?.headSha || pr?._adoSourceCommit || pr?._adoHeadCommit || '').trim();
 }
 
+// Target-branch base SHA, normalized across hosts. GitHub PRs carry `baseSha`
+// (engine/github.js:746-749); ADO PRs carry `_adoTargetCommit`
+// (engine/ado.js:1168-1172, inline in pollPrStatus).
+function _prBaseSha(pr) {
+  return String(pr?.baseSha || pr?._adoTargetCommit || '').trim();
+}
+
+// Target ref name, normalized across hosts. GitHub PRs carry `baseRefName`
+// (e.g. "master"); ADO PRs carry `targetRefName` (e.g. "refs/heads/main").
+function _prTargetRefName(pr) {
+  return String(pr?.baseRefName || pr?.targetRefName || '').trim();
+}
+
+// #3079 — Composite key the engine uses to gate merge-conflict re-dispatch.
+// The same-head guard at engine.js:5676 previously compared only source head
+// SHA, missing the case where a PR is retargeted (e.g. parent branch → main)
+// without the source moving. Including the base SHA and target ref name makes
+// the guard target-aware so retargets naturally release the pause.
+function prMergeConflictGuardKey(pr) {
+  return `${_prHeadSha(pr)}|${_prBaseSha(pr)}|${_prTargetRefName(pr)}`;
+}
+
+// #3079 — Helper invoked by the ADO + GitHub poller metadata-apply paths.
+// When the PR's target ref changes (user retargeted via gh pr edit --base or
+// ADO PR edit), clear the stale MERGE_CONFLICT records so the next tick can
+// re-evaluate the conflict against the new target. Other causes
+// (BUILD_FAILURE, REVIEW_FEEDBACK, HUMAN_FEEDBACK) are untouched — they are
+// not target-sensitive. First-poll seeding (no prior target ref recorded)
+// is a no-op so we don't strip state immediately after an upsert.
+//
+// Returns true when state was actually mutated (callers may use this to set
+// the surrounding "updated" flag and trigger a persist).
+function resetMergeConflictStateOnRetarget(pr, newTargetRef) {
+  if (!pr) return false;
+  const next = String(newTargetRef || '').trim();
+  if (!next) return false;
+  const prior = _prTargetRefName(pr);
+  // First-poll seeding: no prior value → record new value via the caller,
+  // do NOT clear merge-conflict state.
+  if (!prior) return false;
+  if (prior === next) return false;
+  let changed = false;
+  if (pr._lastDispatchByCause && pr._lastDispatchByCause[PR_FIX_CAUSE.MERGE_CONFLICT]) {
+    delete pr._lastDispatchByCause[PR_FIX_CAUSE.MERGE_CONFLICT];
+    if (Object.keys(pr._lastDispatchByCause).length === 0) delete pr._lastDispatchByCause;
+    changed = true;
+  }
+  if (pr._noOpFixes && pr._noOpFixes[PR_FIX_CAUSE.MERGE_CONFLICT]) {
+    delete pr._noOpFixes[PR_FIX_CAUSE.MERGE_CONFLICT];
+    if (Object.keys(pr._noOpFixes).length === 0) delete pr._noOpFixes;
+    changed = true;
+  }
+  return changed;
+}
+
 function prFixEvidenceFingerprint(pr, cause = PR_FIX_CAUSE.UNKNOWN) {
   const review = pr?.minionsReview || {};
   const feedback = pr?.humanFeedback || {};
@@ -6596,6 +6870,16 @@ function prFixEvidenceFingerprint(pr, cause = PR_FIX_CAUSE.UNKNOWN) {
     evidence.mergeConflict = !!pr?._mergeConflict;
     evidence.mergeStatus = pr?.mergeStatus || '';
     evidence.mergeConflictDetail = pr?._mergeConflictDetail || '';
+    // #3079 — same rationale as BUILD_FAILURE / REVIEW_FEEDBACK in #2979:
+    // without head/base/target fields the fingerprint was sticky across a
+    // rebase + force-push AND across a PR retarget, so existing
+    // _noOpFixes[MERGE_CONFLICT] pauses never released. Adding head + base
+    // SHA + target ref name gives MERGE_CONFLICT the same natural-unsticking
+    // property the other auto-fix causes already have.
+    evidence.headRefOid = _prHeadSha(pr);
+    evidence.baseSha = _prBaseSha(pr);
+    evidence.targetRefName = _prTargetRefName(pr);
+    evidence.lastPushedAt = pr?.lastPushedAt || '';
   } else {
     evidence.reviewStatus = pr?.reviewStatus || '';
     evidence.lastReviewedAt = pr?.lastReviewedAt || '';
@@ -7221,6 +7505,8 @@ module.exports = {
   PR_FIX_CAUSE,
   getPrFixAutomationCause,
   prFixEvidenceFingerprint,
+  prMergeConflictGuardKey,
+  resetMergeConflictStateOnRetarget,
   getPrNoOpFixRecord,
   isPrNoOpFixCausePaused,
   getPrPausedCauses,
@@ -7233,6 +7519,8 @@ module.exports = {
   killByPidsImmediate,
   isProcessCommandLineMatchingAgent,
   listAllProcesses,
+  findProcessesWithCwdInside,
+  clearWorktreeFailureCache,
   listProcessDescendants,
   listProcessReachable,
   removeWorktree,

package/engine/worktree-gc.js

@@ -79,18 +79,60 @@ function _markStuckSuccess(resolvedPath, opts = {}) {
     try {
       const writer = typeof opts.writeToInbox === 'function' ? opts.writeToInbox : shared.writeToInbox;
       const basename = path.basename(resolvedPath);
-      const body = [
-        `# Worktree recovered: ${basename}`,
-        '',
-        `Previously stuck worktree dir **${resolvedPath}** has been successfully removed`,
-        `after escalation. Suppression cleared.`,
-      ].join('\n');
-      writer('engine', `worktree-recovered-${basename}`, body);
+      // W-mq6f2fe0000557fa — when the recovery is the direct result of an
+      // auto-reap kill, write a distinct slug + body so operators can see
+      // which orphan-sweep escalations were resolved by the engine itself
+      // vs. naturally by an external holder release.
+      const viaReap = opts.recoveryReason === 'holder-reap';
+      const reapedPids = Array.isArray(opts.reapedPids) ? opts.reapedPids : [];
+      const slug = viaReap
+        ? `worktree-recovered-${basename}-via-holder-reap`
+        : `worktree-recovered-${basename}`;
+      const bodyLines = viaReap
+        ? [
+          `# Worktree recovered via holder-reap: ${basename}`,
+          '',
+          `Previously stuck worktree dir **${resolvedPath}** was successfully removed`,
+          `after the engine auto-killed the orphan spawn-agent holder(s)`,
+          `${reapedPids.length > 0 ? `(PID${reapedPids.length > 1 ? 's' : ''} ${reapedPids.join(', ')})` : ''}`.trim(),
+          `under the \`engine.autoReapOrphanWorktreeHolders\` flag (W-mq6f2fe0000557fa).`,
+          `Suppression cleared.`,
+        ]
+        : [
+          `# Worktree recovered: ${basename}`,
+          '',
+          `Previously stuck worktree dir **${resolvedPath}** has been successfully removed`,
+          `after escalation. Suppression cleared.`,
+        ];
+      writer('engine', slug, bodyLines.join('\n'));
     } catch { /* note best-effort */ }
   }
   return wasEscalated;
 }
 
+// W-mq6f2fe0000557fa — gate: is this holder an unambiguous orphan spawn-agent
+// process we can safely kill? Requires ALL of:
+//   (a) cmdline contains 'spawn-agent.js' (only minions agent wrappers qualify)
+//   (b) cmdline references the worktree basename (extra confirmation it's
+//       OUR spawn-agent and not an unrelated process that happens to mention
+//       the path)
+//   (c) ageMs > agentTimeoutMs * 2 (the worktree was definitely abandoned by
+//       its dispatch; agentTimeout default is 5h, so 10h)
+//
+// The orphan-sweep code path already guarantees no live dispatch row claims
+// the path — we'd never be here otherwise — so the "no live dispatch" check
+// is implicit, not duplicated here.
+function _isSafeReapHolder(holder, basename, minAgeMs) {
+  if (!holder || !holder.pid || !holder.cmdline) return false;
+  const cmd = String(holder.cmdline);
+  if (!/spawn-agent\.js/i.test(cmd)) return false;
+  if (basename && !cmd.includes(basename)) return false;
+  const age = Number(holder.ageMs) || 0;
+  if (age <= 0) return false; // unknown age — refuse to kill
+  if (age < minAgeMs) return false;
+  return true;
+}
+
 function _maybeEscalateStuck(resolvedPath, errorMsg, opts = {}) {
   const cfgEng = (opts.config && opts.config.engine) || {};
   const threshold = cfgEng.worktreeStuckThreshold || shared.ENGINE_DEFAULTS.worktreeStuckThreshold || 10;
@@ -100,7 +142,7 @@ function _maybeEscalateStuck(resolvedPath, errorMsg, opts = {}) {
   rec.failures++;
   rec.lastAttempt = now;
   rec.lastError = errorMsg || rec.lastError || 'unknown';
-  if (rec.failures < threshold) return { escalated: false, alreadyEscalated: false };
+  if (rec.failures < threshold) return { escalated: false, alreadyEscalated: false, holders: [], reapedPids: [] };
 
   const alreadyEscalated = rec.escalatedAt > 0;
   if (!alreadyEscalated) {
@@ -112,15 +154,57 @@ function _maybeEscalateStuck(resolvedPath, errorMsg, opts = {}) {
     rec.suppressedUntil = now + suppressMs;
   }
 
+  // W-mq6f2fe0000557fa — orphan-sweep enrichment + opt-in auto-reap. Scans
+  // and reap-attempts run on EVERY escalated tick (no per-day dedup) so that
+  // a fresh holder appearing after the first escalation still gets killed.
+  // The inbox NOTE is still dedup'd per UTC day below.
+  let holders = [];
+  let reapedPids = [];
+  const isOrphanSweep = opts.reason === 'orphan-sweep';
+  if (isOrphanSweep) {
+    try {
+      const findHoldersFn = typeof opts.findProcessesWithCwdInside === 'function'
+        ? opts.findProcessesWithCwdInside
+        : shared.findProcessesWithCwdInside;
+      const scanTimeoutMs = cfgEng.orphanHolderScanTimeoutMs
+        ?? shared.ENGINE_DEFAULTS.orphanHolderScanTimeoutMs
+        ?? 5000;
+      holders = findHoldersFn(resolvedPath, { timeoutMs: scanTimeoutMs }) || [];
+    } catch { holders = []; }
+
+    if (cfgEng.autoReapOrphanWorktreeHolders === true && holders.length > 0) {
+      const basename = path.basename(resolvedPath);
+      const agentTimeoutMs = Number(cfgEng.agentTimeout)
+        || Number(shared.ENGINE_DEFAULTS.agentTimeout)
+        || (5 * 60 * 60 * 1000);
+      const minAgeMs = agentTimeoutMs * 2;
+      const killFn = typeof opts.killImmediate === 'function'
+        ? opts.killImmediate
+        : shared.killImmediate;
+      for (const h of holders) {
+        if (!_isSafeReapHolder(h, basename, minAgeMs)) continue;
+        try {
+          killFn({ pid: h.pid });
+          reapedPids.push(h.pid);
+        } catch { /* fail-open — keep trying other holders */ }
+      }
+      if (reapedPids.length > 0) {
+        try { shared.bumpWorktreeGcMetric('orphanHoldersReaped'); } catch { /* optional */ }
+      }
+    }
+  }
+
   // Dedup inbox note per UTC day.
   const today = new Date(now).toISOString().slice(0, 10);
-  if (rec.lastNoteDate === today) return { escalated: !alreadyEscalated, alreadyEscalated };
+  if (rec.lastNoteDate === today) {
+    return { escalated: !alreadyEscalated, alreadyEscalated, holders, reapedPids };
+  }
   rec.lastNoteDate = today;
 
   try {
     const writer = typeof opts.writeToInbox === 'function' ? opts.writeToInbox : shared.writeToInbox;
     const basename = path.basename(resolvedPath);
-    const body = [
+    const bodyParts = [
       `# Worktree stuck: ${basename}`,
       '',
       `Worktree dir **${resolvedPath}** has failed removal ${rec.failures} consecutive times.`,
@@ -153,16 +237,116 @@ function _maybeEscalateStuck(resolvedPath, errorMsg, opts = {}) {
       '',
       `Per-tick warn spam is suppressed for the next`,
       `\`ENGINE_DEFAULTS.worktreeStuckSuppressMs\` (default 60min).`,
-    ].join('\n');
-    writer('engine', `worktree-stuck-${basename}`, body);
+    ];
+
+    // W-mq6f2fe0000557fa — append the holder section for orphan-sweep callers.
+    if (isOrphanSweep) {
+      bodyParts.push('', '## Live holders');
+      bodyParts.push('');
+      if (holders.length === 0) {
+        bodyParts.push(
+          '_No holder process found via cwd scan._',
+          '',
+          'If the dir is still stuck, the holder may be a non-process resource (',
+          'antivirus scan-in-progress, OneDrive sync, indexer); try again after',
+          '~60s, or run `handle.exe` interactively for a deeper search.'
+        );
+      } else {
+        for (const h of holders) {
+          const tail = String(h.cmdline || '').replace(/\r?\n/g, ' ').slice(0, 300);
+          const ageStr = h.ageMs ? `${Math.floor(h.ageMs / 1000)}s` : 'unknown';
+          bodyParts.push(`- **PID ${h.pid}** (age: ${ageStr})`);
+          bodyParts.push('  ```');
+          bodyParts.push(`  ${tail}`);
+          bodyParts.push('  ```');
+        }
+        bodyParts.push('');
+        if (cfgEng.autoReapOrphanWorktreeHolders === true) {
+          if (reapedPids.length > 0) {
+            bodyParts.push(
+              `## Auto-reap`,
+              '',
+              `Engine auto-killed ${reapedPids.length} unambiguous orphan`,
+              `spawn-agent process${reapedPids.length === 1 ? '' : 'es'}: PID${reapedPids.length === 1 ? '' : 's'} ${reapedPids.join(', ')}.`,
+              `If the kill released the cwd lock, the next sweep tick will`,
+              `successfully remove the worktree and emit a`,
+              `\`worktree-recovered-${basename}-via-holder-reap\` recovery note.`
+            );
+          } else {
+            bodyParts.push(
+              `## Auto-reap`,
+              '',
+              `\`engine.autoReapOrphanWorktreeHolders\` is ON but no holder`,
+              `qualified for auto-kill (cmdline must match \`spawn-agent.js\`,`,
+              `reference the worktree basename, and process age must exceed`,
+              `\`engine.agentTimeout * 2\`). Manual intervention may be needed.`
+            );
+          }
+        } else {
+          bodyParts.push(
+            `_To auto-kill orphan spawn-agent processes holding this worktree,_`,
+            `_flip \`engine.autoReapOrphanWorktreeHolders\` ON in dashboard Settings._`
+          );
+        }
+      }
+    }
+
+    writer('engine', `worktree-stuck-${basename}`, bodyParts.join('\n'));
   } catch { /* note best-effort */ }
 
-  return { escalated: !alreadyEscalated, alreadyEscalated };
+  return { escalated: !alreadyEscalated, alreadyEscalated, holders, reapedPids };
 }
 
 // Test-only reset hook. Production code never calls this.
 function _resetStuckPathsForTesting() { _stuckPaths.clear(); }
 
+// W-mq6f2fe0000557fa — post-auto-reap retry. Called only when
+// `_maybeEscalateStuck` reports `reapedPids.length > 0`. Clears the per-path
+// failure cooldown (otherwise the post-3-strike suppression in
+// `shared.removeWorktree` silently skips the retry), waits briefly for the
+// OS to release the killed processes' file handles, then attempts ONE more
+// removal. On success, writes the recovered-via-holder-reap note via
+// `_markStuckSuccess` with the reaped-pid attribution.
+function _postReapRetry(wtPath, gitRoot, parentDir, resolvedPath, _removeWorktree, opts, projStats, result, log, reapedPids) {
+  try { shared.clearWorktreeFailureCache(resolvedPath); } catch { /* optional */ }
+  // Brief settle window for OS to release file handles from killed processes.
+  try {
+    const sleepFn = typeof opts.sleepSyncFn === 'function'
+      ? opts.sleepSyncFn
+      : (ms) => {
+        try {
+          require('child_process').execFileSync(process.execPath, ['-e', `setTimeout(()=>process.exit(0), ${Number(ms) || 0})`], { stdio: 'ignore' });
+        } catch { /* timeout / spawn fail — proceed anyway */ }
+      };
+    sleepFn(2000);
+  } catch { /* sleep failures should not block the retry */ }
+
+  try {
+    const removed = _removeWorktree(wtPath, gitRoot, parentDir);
+    if (removed) {
+      // Down-count the failure we recorded just before; this dispatch
+      // ultimately succeeded after the auto-reap.
+      if (projStats) { projStats.failed = Math.max(0, projStats.failed - 1); projStats.evicted++; }
+      if (result) { result.failed = Math.max(0, result.failed - 1); result.evicted++; }
+      _markStuckSuccess(resolvedPath, {
+        writeToInbox: opts.writeToInbox,
+        recoveryReason: 'holder-reap',
+        reapedPids,
+      });
+      try { shared.bumpWorktreeGcMetric('recoveredViaHolderReap'); } catch { /* optional */ }
+      if (typeof log === 'function') {
+        log('info', `worktree-gc: removed ${wtPath} after auto-reaping holder(s) ${reapedPids.join(', ')}`);
+      }
+      return true;
+    }
+  } catch (retryErr) {
+    if (typeof log === 'function') {
+      log('warn', `worktree-gc: post-reap retry threw for ${wtPath}: ${retryErr && retryErr.message}`);
+    }
+  }
+  return false;
+}
+
 /**
  * Decide whether a dispatch-end worktree should be GC'd.
  *
@@ -494,19 +678,39 @@ function pruneOrphanWorktrees(opts) {
           log('info', `worktree-gc: boot-evicted orphan ${name} for project ${project.name || 'default'}`);
         } else {
           projStats.failed++; result.failed++;
-          const { alreadyEscalated } = _maybeEscalateStuck(wtResolved, 'remove returned false', { config: opts.config, writeToInbox: opts.writeToInbox });
-          if (!alreadyEscalated && !suppressed) {
+          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 { alreadyEscalated } = _maybeEscalateStuck(wtResolved, rmErr && rmErr.message, { config: opts.config, writeToInbox: opts.writeToInbox });
-        if (!alreadyEscalated && !suppressed) {
+        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);
+        }
       }
     }
     result.perProject[project.name || rootDir] = projStats;
@@ -693,17 +897,33 @@ function pruneOrphanWorktreesFromGitRegistry(opts) {
           log('info', `worktree-gc: out-of-root evicted ${wtAbs} for project ${project.name || 'default'}`);
         } else {
           projStats.failed++; result.failed++;
-          const { alreadyEscalated } = _maybeEscalateStuck(wtAbs, 'remove returned false', { config: opts.config, writeToInbox: opts.writeToInbox });
-          if (!alreadyEscalated && !suppressed) {
+          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 { alreadyEscalated } = _maybeEscalateStuck(wtAbs, rmErr && rmErr.message, { config: opts.config, writeToInbox: opts.writeToInbox });
-        if (!alreadyEscalated && !suppressed) {
+        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);
+        }
       }
     }
 

package/engine.js

@@ -918,6 +918,109 @@ async function pruneStaleWorktreeForBranch(rootDir, branchName, gitOpts) {
   return removed;
 }
 
+// W-mq5n1zx5 — Layer 1b: status-probe command builder. Honors the
+// ENGINE_DEFAULTS.statusProbeUseNoOptionalLocks toggle so operators can
+// disable the flag if a future git release breaks something. Default ON:
+// `--no-optional-locks` tells git to skip the .git/index.lock acquire
+// around the untracked-cache refresh that runs inside `status`. Without
+// the flag, a 6–12s probe under aggressive AV scanning is normal; with
+// it, typical probes drop to <500ms, which removes the timeout that
+// leaks the git.exe descendant that later pins packfile handles and
+// breaks the quarantine rename.
+function _statusPorcelainCmd() {
+  return ENGINE_DEFAULTS.statusProbeUseNoOptionalLocks
+    ? 'git --no-optional-locks status --porcelain'
+    : '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-mq5n1zx5 — Layer 2a: on Windows, kill any live `git.exe` descendants
+// whose command line points at the quarantine target path. We never
+// tracked the PID of the `git status --porcelain` child that the probe
+// timed out on, so we can't kill by PID — instead we shell out to
+// PowerShell's CIM cmdlets to find matching processes and Stop-Process
+// them. Cheap (<2s) and idempotent — if no descendants are alive, the
+// CIM query returns nothing and exits 0. POSIX is a no-op (the EBUSY
+// race is Windows-specific). Best-effort; failure is logged but never
+// blocks the quarantine.
+function _killGitDescendantsForWorktree(worktreePath) {
+  if (process.platform !== 'win32') return { killed: 0, skipped: true };
+  if (!ENGINE_DEFAULTS.statusProbeKillDescendantsWin32) return { killed: 0, skipped: true };
+  if (!worktreePath) return { killed: 0, skipped: true };
+  // PowerShell expects single-quoted literals; escape any embedded single
+  // quote by doubling it (PowerShell's standard single-quote escape).
+  const safePath = String(worktreePath).replace(/'/g, "''");
+  const ps = [
+    "$ErrorActionPreference='SilentlyContinue';",
+    `$matches = Get-CimInstance Win32_Process | Where-Object { $_.Name -eq 'git.exe' -and $_.CommandLine -like '*${safePath}*' };`,
+    "if ($matches) { $matches | ForEach-Object { Stop-Process -Id $_.ProcessId -Force; $_.ProcessId }; }",
+  ].join(' ');
+  try {
+    const out = shared.execSilent(`powershell -NoProfile -Command "${ps.replace(/"/g, '\\"')}"`, { timeout: 2000, encoding: 'utf8' });
+    const killed = String(out || '').split(/\r?\n/).map(s => s.trim()).filter(Boolean).length;
+    if (killed > 0) log('info', `_killGitDescendantsForWorktree: killed ${killed} git.exe descendant(s) holding ${worktreePath}`);
+    return { killed };
+  } catch (e) {
+    log('warn', `_killGitDescendantsForWorktree: powershell probe failed: ${e.message}`);
+    return { killed: 0, error: e.message };
+  }
+}
+
+// W-mq5n1zx5 — Layer 3a: bump the rolling counters for quarantine rename
+// outcomes (attempts, success, successAfterRetry, fallbackForceRemove,
+// totalFailure). Best-effort; metrics failures must not break the
+// quarantine path. The shape lives under metrics._engine.worktreeQuarantineOutcomes
+// so it sits beside the other _engine.* engine-internal telemetry.
+function _bumpQuarantineOutcome(key, delta = 1) {
+  try {
+    shared.mutateMetrics((metrics) => {
+      if (!metrics._engine) metrics._engine = {};
+      if (!metrics._engine.worktreeQuarantineOutcomes) {
+        metrics._engine.worktreeQuarantineOutcomes = {
+          attempts: 0, success: 0, successAfterRetry: 0,
+          fallbackForceRemove: 0, totalFailure: 0,
+        };
+      }
+      const o = metrics._engine.worktreeQuarantineOutcomes;
+      o[key] = (o[key] || 0) + delta;
+      return metrics;
+    });
+  } catch (e) {
+    log('warn', `_bumpQuarantineOutcome(${key}): ${e.message}`);
+  }
+}
+
+
 // ─── assertCleanSharedWorktree (#2439) ──────────────────────────────────────
 // Engine-side preflight that prevents shared-branch (and PR-targeted reused —
 // see opts.quarantineOnUnsafe, issue #2996) dispatches from spawning into a
@@ -980,7 +1083,7 @@ async function assertCleanSharedWorktree(rootDir, worktreePath, branchName, disp
   // 1. Status probe (filesystem)
   let statusOut = '';
   try {
-    const r = await execAsync('git status --porcelain', { ...gitOpts, cwd: worktreePath, timeout: statusTimeoutMs });
+    const r = await execAsync(_statusPorcelainCmd(), { ...gitOpts, cwd: worktreePath, timeout: statusTimeoutMs });
     statusOut = (r || '').toString().trim();
   } catch (e) {
     // W-mq1habhf: previously this bailed out with the bad worktree intact,
@@ -1186,7 +1289,7 @@ async function assertCleanSharedWorktree(rootDir, worktreePath, branchName, disp
 
   // 7. Re-verify
   try {
-    const r2 = await execAsync('git status --porcelain', { ...gitOpts, cwd: worktreePath, timeout: statusTimeoutMs });
+    const r2 = await execAsync(_statusPorcelainCmd(), { ...gitOpts, cwd: worktreePath, timeout: statusTimeoutMs });
     const after = (r2 || '').toString().trim();
     if (after) {
       result.reason = 'dirty-after-clean';
@@ -1218,9 +1321,23 @@ async function assertCleanSharedWorktree(rootDir, worktreePath, branchName, disp
 // branch (assertCleanSharedWorktree returns 'other-dispatch-active' before
 // invoking this). Renaming an active worktree out from under a running
 // agent would be catastrophic.
+//
+// W-mq5n1zx5 — layered defense against Windows EBUSY: (Layer 2a) kill
+// lingering git.exe descendants whose command-line points at the worktree
+// before touching the path; (Layer 1a) retry the rename with jittered
+// backoff; (Layer 2b) if every retry still fails, fall back to
+// `git worktree remove --force` so git tears down its own metadata + dir
+// rather than leaving a half-quarantined tree behind; (Layer 3a) emit
+// outcome counters to metrics._engine.worktreeQuarantineOutcomes;
+// (Layer 3b) when EVERY path fails, write a dedicated inbox alert naming
+// the manual recovery command. The throw-or-return contract is unchanged
+// for callers: a thrown error means the caller's `result.quarantineError`
+// 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 = {}) {
   const ts = Date.now();
   const quarantinedPath = `${worktreePath}-quarantine-${ts}`;
+  _bumpQuarantineOutcome('attempts', 1);
 
   // Capture HEAD sha BEFORE renaming so we can back up the local branch ref.
   let headSha = '';
@@ -1231,24 +1348,112 @@ async function _quarantineDirtyWorktree(rootDir, worktreePath, branchName, gitOp
     log('warn', `_quarantineDirtyWorktree: rev-parse HEAD failed for ${worktreePath}: ${e.message} — backup ref will be skipped`);
   }
 
-  // Rename the worktree dir. Once this succeeds the worktree is functionally
-  // quarantined; subsequent failures only affect ref bookkeeping.
   // W-mq5rwwss000f30a7 — never quarantine (=rename out from under) a worktree
   // that a live dispatch still claims. Quarantine breaks the agent's cwd just
-  // as completely as removeWorktree would.
+  // as completely as removeWorktree would. Check before any destructive work
+  // (including the kill-descendants sweep below) so we don't disturb a live
+  // agent's git child processes either.
   if (shared.isWorktreePathLive(worktreePath)) {
     log('warn', `_quarantineDirtyWorktree: skip — live dispatch in ${worktreePath}`);
     shared._writeWorktreeSkipLiveInboxNote(worktreePath, '_quarantineDirtyWorktree');
     return { quarantinedPath: null, backupRef: null, skipped: true };
   }
-  fs.renameSync(worktreePath, quarantinedPath);
 
-  // Prune git's stale worktree metadata so the next `git worktree add` for
-  // the same branch isn't blocked by "branch is already used by worktree".
+  // W-mq5n1zx5 Layer 2a: pre-emptively kill any git.exe descendants whose
+  // command line points at the worktree. The status-probe child that timed
+  // out earlier may still be alive holding packfile handles; if so, the
+  // rename below will fail with EBUSY/EPERM until the descendant exits.
+  // POSIX is a no-op. Best-effort; failure here is non-fatal.
+  _killGitDescendantsForWorktree(worktreePath);
+
+  // 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.
+  let renameAttempts = 0;
+  let renameError = null;
   try {
-    await shared.shellSafeGit(['worktree', 'prune'], { ...gitOpts, cwd: rootDir, timeout: 15000 });
+    const r = await _renameWithRetry(worktreePath, quarantinedPath);
+    renameAttempts = r.attempts || 1;
   } catch (e) {
-    log('warn', `_quarantineDirtyWorktree: worktree prune after rename: ${e.message}`);
+    renameError = e;
+  }
+
+  // W-mq5n1zx5 Layer 2b: if the rename retries exhausted, fall back to
+  // `git worktree remove --force`. This DESTROYS the worktree contents
+  // (no forensics dir), so it's last-resort only — gated on the
+  // quarantineForceRemoveFallback engine default. The next dispatch will
+  // create a fresh worktree on the origin tip, which is the same outcome
+  // the rename path would produce, just without the recovery dir.
+  let forceRemoved = false;
+  let forceRemoveError = null;
+  if (renameError && ENGINE_DEFAULTS.quarantineForceRemoveFallback) {
+    log('warn', `_quarantineDirtyWorktree: rename failed after ${renameAttempts || ENGINE_DEFAULTS.quarantineRenameRetryAttempts} attempt(s) (${renameError.code || renameError.message}); falling back to git worktree remove --force`);
+    try {
+      await shared.shellSafeGit(['worktree', 'remove', '--force', worktreePath], { ...gitOpts, cwd: rootDir, timeout: 30000 });
+      forceRemoved = true;
+      log('warn', `_quarantineDirtyWorktree: git worktree remove --force succeeded for ${worktreePath} (no quarantine dir preserved)`);
+    } catch (e) {
+      forceRemoveError = e;
+      log('error', `_quarantineDirtyWorktree: git worktree remove --force ALSO failed: ${e.message}`);
+    }
+  }
+
+  // If neither the rename retries nor the force-remove fallback succeeded,
+  // we are env-blocked: the worktree dir is still on disk and git still
+  // thinks it owns it. Write a dedicated inbox alert (Layer 3b) and rethrow
+  // the original rename error so the caller's quarantineError branch fires.
+  if (renameError && !forceRemoved) {
+    _bumpQuarantineOutcome('totalFailure', 1);
+    const sanitizedRefSegmentEnv = sanitizeBranch(branchName).replace(/\//g, '-');
+    const failBody = [
+      '# Engine quarantine TOTAL FAILURE — manual recovery required (W-mq5n1zx5)',
+      '',
+      `- Dispatch: ${diag.dispatchId || '<unknown>'}`,
+      `- Branch: ${branchName}`,
+      `- Worktree path (STILL PRESENT): ${worktreePath}`,
+      `- Reason: ${diag.reason || 'unsafe'}`,
+      `- Rename attempts: ${renameAttempts || ENGINE_DEFAULTS.quarantineRenameRetryAttempts}`,
+      `- Last rename error: ${renameError.code || ''} ${renameError.message}`,
+      `- Force-remove fallback: ${ENGINE_DEFAULTS.quarantineForceRemoveFallback ? `tried, failed (${forceRemoveError ? forceRemoveError.message : 'unknown'})` : 'disabled'}`,
+      '',
+      '## Manual recovery',
+      '',
+      '1. Find any live `git.exe` (or other) processes still holding the dir:',
+      `   \`Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -like '*${worktreePath}*' }\``,
+      '2. Stop them: `Stop-Process -Id <pid> -Force`',
+      '3. Force-remove the dir:',
+      `   Windows: \`Remove-Item -Recurse -Force "${worktreePath}"\` (or \`rmdir /s /q "${worktreePath}"\` from cmd.exe)`,
+      `   POSIX:   \`rm -rf "${worktreePath}"\``,
+      `4. Prune git's stale worktree metadata: \`git -C "${rootDir}" worktree prune\``,
+      '',
+      'After this, the next dispatch for the branch will create a fresh worktree.',
+    ].join('\n');
+    try {
+      shared.writeToInbox('engine', `worktree-quarantine-failed-${diag.dispatchId || sanitizedRefSegmentEnv}`, failBody);
+    } catch (e) {
+      log('warn', `_quarantineDirtyWorktree: totalFailure writeToInbox failed: ${e.message}`);
+    }
+    throw renameError;
+  }
+
+  // Track outcome bucket for the successful path (rename or force-remove).
+  if (forceRemoved) {
+    _bumpQuarantineOutcome('fallbackForceRemove', 1);
+  } else if (renameAttempts > 1) {
+    _bumpQuarantineOutcome('successAfterRetry', 1);
+  }
+  _bumpQuarantineOutcome('success', 1);
+
+  // Prune git's stale worktree metadata so the next `git worktree add` for
+  // the same branch isn't blocked by "branch is already used by worktree".
+  // Skipped on the force-removed path — `git worktree remove --force` already
+  // wipes its own metadata entry.
+  if (!forceRemoved) {
+    try {
+      await shared.shellSafeGit(['worktree', 'prune'], { ...gitOpts, cwd: rootDir, timeout: 15000 });
+    } catch (e) {
+      log('warn', `_quarantineDirtyWorktree: worktree prune after rename: ${e.message}`);
+    }
   }
 
   // Backup the local branch HEAD to refs/minions/quarantine/<sanitized>/<ts>
@@ -1293,7 +1498,9 @@ async function _quarantineDirtyWorktree(rootDir, worktreePath, branchName, gitOp
     `- Dispatch: ${diag.dispatchId || '<unknown>'}`,
     `- Branch: ${branchName}`,
     `- Original worktree: ${worktreePath}`,
-    `- Quarantined to: ${quarantinedPath}`,
+    forceRemoved
+      ? `- Force-removed via \`git worktree remove --force\` (no quarantine dir preserved — W-mq5n1zx5 Layer 2b)`
+      : `- Quarantined to: ${quarantinedPath}${renameAttempts > 1 ? ` (rename took ${renameAttempts} attempt(s) — W-mq5n1zx5 Layer 1a)` : ''}`,
     `- Reason: ${diag.reason || 'unsafe'}`,
     `- Local commits ahead of origin: ${diag.ahead || 0}`,
     `- Local commits behind origin: ${diag.behind || 0}`,
@@ -1305,12 +1512,20 @@ async function _quarantineDirtyWorktree(rootDir, worktreePath, branchName, gitOp
     '',
     backupRefCreated
       ? `The local branch HEAD was backed up to \`${backupRef}\` (${headSha.slice(0, 12)}) and \`refs/heads/${branchName}\` was reset to \`refs/remotes/origin/${branchName}\`.`
-      : `Backup ref was NOT created (HEAD sha unavailable). The local branch ref was still reset to \`refs/remotes/origin/${branchName}\` if possible. Inspect the quarantined directory directly to recover unpushed work.`,
+      : `Backup ref was NOT created (HEAD sha unavailable). The local branch ref was still reset to \`refs/remotes/origin/${branchName}\` if possible.${forceRemoved ? ' Worktree contents were destroyed by the force-remove fallback — no quarantine dir to inspect.' : ' Inspect the quarantined directory directly to recover unpushed work.'}`,
     '',
-    `1. Inspect the quarantined diff: \`git -C "${rootDir}" diff refs/remotes/origin/${branchName}${backupRefCreated ? ` ${backupRef}` : ''} -- .\``,
-    `2. Cherry-pick the commits you want from \`${backupRefCreated ? backupRef : `<inspect ${quarantinedPath}>`}\` onto a fresh ${branchName} worktree.`,
-    `3. Inspect uncommitted edits inside the quarantined dir directly: \`${quarantinedPath}\`.`,
-    `4. Delete the quarantined dir when done: \`Remove-Item -Recurse -Force "${quarantinedPath}"\` (Windows) or \`rm -rf "${quarantinedPath}"\` (POSIX).`,
+    forceRemoved
+      ? `1. The worktree dir was force-removed; there is no quarantine dir to inspect. If the local branch ref still has divergent commits, recover from \`${backupRefCreated ? backupRef : 'reflog'}\`.`
+      : `1. Inspect the quarantined diff: \`git -C "${rootDir}" diff refs/remotes/origin/${branchName}${backupRefCreated ? ` ${backupRef}` : ''} -- .\``,
+    forceRemoved
+      ? ''
+      : `2. Cherry-pick the commits you want from \`${backupRefCreated ? backupRef : `<inspect ${quarantinedPath}>`}\` onto a fresh ${branchName} worktree.`,
+    forceRemoved
+      ? ''
+      : `3. Inspect uncommitted edits inside the quarantined dir directly: \`${quarantinedPath}\`.`,
+    forceRemoved
+      ? ''
+      : `4. Delete the quarantined dir when done: \`Remove-Item -Recurse -Force "${quarantinedPath}"\` (Windows) or \`rm -rf "${quarantinedPath}"\` (POSIX).`,
     backupRefCreated ? `5. Delete the backup ref when done: \`git -C "${rootDir}" update-ref -d ${backupRef}\`.` : '',
   ].filter(Boolean).join('\n');
   try {
@@ -1319,8 +1534,13 @@ async function _quarantineDirtyWorktree(rootDir, worktreePath, branchName, gitOp
     log('warn', `_quarantineDirtyWorktree: writeToInbox failed: ${e.message}`);
   }
 
-  log('warn', `Quarantined dirty worktree ${worktreePath} → ${quarantinedPath} (branch ${branchName}, ${diag.ahead || 0} ahead, ${diag.behind || 0} behind, ${dirtyFiles.length} dirty files)`);
-  return { quarantinedPath, backupRef: backupRefCreated ? backupRef : null };
+  log('warn', `Quarantined dirty worktree ${worktreePath} → ${forceRemoved ? '<force-removed>' : quarantinedPath} (branch ${branchName}, ${diag.ahead || 0} ahead, ${diag.behind || 0} behind, ${dirtyFiles.length} dirty files${renameAttempts > 1 ? `, rename retries=${renameAttempts}` : ''}${forceRemoved ? ', force-remove fallback' : ''})`);
+  return {
+    quarantinedPath: forceRemoved ? null : quarantinedPath,
+    backupRef: backupRefCreated ? backupRef : null,
+    forceRemoved,
+    renameAttempts,
+  };
 }
 
 async function recoverPartialWorktree(rootDir, worktreePath, branchName, gitOpts) {
@@ -2070,8 +2290,23 @@ async function spawnAgent(dispatchItem, config) {
         // no-upstream / dirty-after-clean stay non-retryable because they
         // protect potentially-unpushed agent work.
         const isStatusProbeFailed = cleanResult.reason === 'status-failed';
-        const failureClassValue = isDivergent ? FAILURE_CLASS.WORKTREE_DIVERGENT : FAILURE_CLASS.WORKTREE_DIRTY;
-        const failureClassName = isDivergent ? 'WORKTREE_DIVERGENT' : 'WORKTREE_DIRTY';
+        // W-mq5n1zx5 Layer 1c: when quarantine itself errored (rename retries
+        // + force-remove fallback all failed) the worktree dir is still on
+        // disk and the failure is purely environmental — a lingering git.exe
+        // descendant or AV scan holding handles. Route through a dedicated
+        // WORKTREE_QUARANTINE_ENV_BLOCKED class so the dispatch-side retry
+        // counter doesn't bump (agentRetryable:false → non-retryable branch
+        // → no _retriesByAgent / _retryCount mutation) and the WI auto-
+        // recovery loop in discoverFromWorkItems re-queues this item under
+        // the existing _quarantineRecoveryCount cap. This stops env failures
+        // from burning the per-agent retry budget the way they did before.
+        const isQuarantineEnvBlocked = !!(cleanResult.quarantineError && !cleanResult.quarantined);
+        const failureClassValue = isQuarantineEnvBlocked
+          ? FAILURE_CLASS.WORKTREE_QUARANTINE_ENV_BLOCKED
+          : (isDivergent ? FAILURE_CLASS.WORKTREE_DIVERGENT : FAILURE_CLASS.WORKTREE_DIRTY);
+        const failureClassName = isQuarantineEnvBlocked
+          ? 'WORKTREE_QUARANTINE_ENV_BLOCKED'
+          : (isDivergent ? 'WORKTREE_DIVERGENT' : 'WORKTREE_DIRTY');
         const reasonMsg = cleanResult.quarantined
           ? `${failureClassName}: reused worktree at ${worktreePath} was dirty/divergent (${cleanResult.reason}; ${cleanResult.ahead || 0} ahead, ${cleanResult.behind || 0} behind, ${cleanResult.dirtyFiles?.length || 0} dirty file(s)${previewFiles ? ': ' + previewFiles : ''}) — quarantined to ${cleanResult.quarantinedPath}. Next dispatch will start fresh.`
           : `${failureClassName}: reused worktree at ${worktreePath} is dirty/divergent (${cleanResult.reason}; ${cleanResult.ahead || 0} ahead, ${cleanResult.behind || 0} behind, ${cleanResult.dirtyFiles?.length || 0} file(s)${previewFiles ? ': ' + previewFiles : ''}). Quarantine ${cleanResult.quarantineError ? 'errored: ' + cleanResult.quarantineError : (cleanResult.quarantineSkipped ? 'was skipped — another live dispatch claims the worktree (see notes/inbox/ engine-worktree-skip-live note).' : 'was not attempted (' + cleanResult.reason + ').')}`;
@@ -2081,7 +2316,7 @@ async function spawnAgent(dispatchItem, config) {
           id,
           DISPATCH_RESULT.ERROR,
           reasonMsg.slice(0, 500),
-          `Engine preflight refused to dispatch into a dirty/divergent reused worktree (#2996). Reason: ${cleanResult.reason}.${cleanResult.quarantined ? ` Worktree quarantined to ${cleanResult.quarantinedPath}; backup ref ${cleanResult.backupRef || '(skipped)'}. See notes/inbox/ for recovery instructions.` : (cleanResult.quarantineSkipped ? ' Quarantine was skipped because another live dispatch claims this worktree path; this dispatch will not auto-retry until the live claimant clears.' : '')}`,
+          `Engine preflight refused to dispatch into a dirty/divergent reused worktree (#2996). Reason: ${cleanResult.reason}.${cleanResult.quarantined ? ` Worktree quarantined to ${cleanResult.quarantinedPath}; backup ref ${cleanResult.backupRef || '(skipped)'}. See notes/inbox/ for recovery instructions.` : (cleanResult.quarantineSkipped ? ' Quarantine was skipped because another live dispatch claims this worktree path; this dispatch will not auto-retry until the live claimant clears.' : '')}${isQuarantineEnvBlocked ? ' Environmental quarantine failure (Windows EBUSY); WI auto-recovery loop will re-queue without bumping per-agent retry counter.' : ''}`,
           { agentRetryable: isStatusProbeFailed && cleanResult.quarantined, failureClass: failureClassValue },
         );
         cleanupTempAgent(agentId);
@@ -2260,7 +2495,10 @@ async function spawnAgent(dispatchItem, config) {
           let stashed = false;
           if (!depMergeFailed && !skipDepMerge && prunedDeps.length > 0) {
             try {
-              const statusOut = gitOutputToString(await shared.shellSafeGit(['status', '--porcelain'], { ..._gitOpts, cwd: worktreePath })).trim();
+              const statusArgs = ENGINE_DEFAULTS.statusProbeUseNoOptionalLocks
+                ? ['--no-optional-locks', 'status', '--porcelain']
+                : ['status', '--porcelain'];
+              const statusOut = gitOutputToString(await shared.shellSafeGit(statusArgs, { ..._gitOpts, cwd: worktreePath })).trim();
               if (statusOut) {
                 await shared.shellSafeGit(['stash', 'push', '--include-untracked', '-m', 'engine: stash before dep re-merge'], { ..._gitOpts, cwd: worktreePath });
                 stashed = true;
@@ -2501,7 +2739,7 @@ async function spawnAgent(dispatchItem, config) {
   if (worktreePath && fs.existsSync(worktreePath)) {
     _phaseT.dirtyProbeStart = Date.now();
     try {
-      const dirtyResult = await execAsync('git status --porcelain', { ..._gitOpts, cwd: worktreePath, timeout: 10000 });
+      const dirtyResult = await execAsync(_statusPorcelainCmd(), { ..._gitOpts, cwd: worktreePath, timeout: 10000 });
       const dirtyOutput = (dirtyResult.stdout || '').trim();
       if (dirtyOutput) {
         const dirtyFiles = dirtyOutput.split('\n').map(l => l.trim()).filter(Boolean);
@@ -5666,19 +5904,28 @@ async function discoverFromPrs(config, project) {
       // starvation guarantee.
       const conflictCauseKey = getPrAutomationCauseKey('merge-conflict', pr);
       const key = getPrAutomationDispatchKey(`conflict-fix-${project?.name || 'default'}-${prDisplayId}`, conflictCauseKey);
-      // W-mpritzcr0004afc5 (#2955): per-cause same-head guard mirroring the
-      // build-failure block above. `_conflictFixedAt` is a 10-min wall-clock
-      // suppression for ADO/GH mergeStatus lag; `_lastDispatchByCause` is a
-      // headSha-pinned suppression for repeated agent noops on an unchanged
-      // base+head pair. Both must fire (their windows are independent).
+      // W-mpritzcr0004afc5 (#2955) + #3079: per-cause same-head guard mirroring
+      // the build-failure block above. `_conflictFixedAt` is a 10-min wall-clock
+      // suppression for ADO/GH mergeStatus lag; `_lastDispatchByCause` is now
+      // a (head+base+targetRef)-pinned suppression for repeated agent noops on
+      // an unchanged source+base+target tuple. #3079: prior version compared
+      // only headSha, so retargeting a PR (e.g. parent-branch → main after
+      // parent merge) never released the pause even though the base SHA and
+      // target ref had changed and conflicts may have become resolvable.
+      const currentGuardKey = shared.prMergeConflictGuardKey(pr);
       const currentHeadSha = String(pr.headSha || pr._adoSourceCommit || pr._adoHeadCommit || '').trim();
       const lastConflictDispatch = pr._lastDispatchByCause?.[shared.PR_FIX_CAUSE.MERGE_CONFLICT];
-      const skipConflictFix = !!(lastConflictDispatch?.outcome === 'noop'
-        && lastConflictDispatch.headSha
+      // Prefer the new mergeConflictKey (post-#3079); fall back to legacy
+      // headSha compare so PRs paused before this fix don't loop forever.
+      const lastGuardKey = lastConflictDispatch?.mergeConflictKey;
+      const guardKeyMatches = !!(lastGuardKey && currentGuardKey && lastGuardKey === currentGuardKey);
+      const legacyHeadMatches = !lastGuardKey && !!(lastConflictDispatch?.headSha
         && currentHeadSha
         && lastConflictDispatch.headSha === currentHeadSha);
+      const skipConflictFix = !!(lastConflictDispatch?.outcome === 'noop'
+        && (guardKeyMatches || legacyHeadMatches));
       if (skipConflictFix) {
-        log('info', `Skipping conflict-fix for ${pr.id}: last merge-conflict dispatch was noop on the same head ${currentHeadSha.slice(0, 8)} (${(lastConflictDispatch.reason || '').slice(0, 120)})`);
+        log('info', `Skipping conflict-fix for ${pr.id}: last merge-conflict dispatch was noop on the same source+base+target (${(lastConflictDispatch.reason || '').slice(0, 120)})`);
         continue;
       }
       // Suppress re-dispatch for 10 min after last attempt — ADO/GitHub recomputes
@@ -6151,8 +6398,10 @@ function discoverFromWorkItems(config, project) {
       const fr = String(item.failReason || '');
       const isQuarantineFail = item._failureClass === FAILURE_CLASS.WORKTREE_DIRTY
         || item._failureClass === FAILURE_CLASS.WORKTREE_DIVERGENT
+        || item._failureClass === FAILURE_CLASS.WORKTREE_QUARANTINE_ENV_BLOCKED
         || /\bWORKTREE_DIRTY\b/.test(fr)
-        || /\bWORKTREE_DIVERGENT\b/.test(fr);
+        || /\bWORKTREE_DIVERGENT\b/.test(fr)
+        || /\bWORKTREE_QUARANTINE_ENV_BLOCKED\b/.test(fr);
       if (isQuarantineFail) {
         item._quarantineRecoveryCount = (item._quarantineRecoveryCount || 0) + 1;
         const cap = ENGINE_DEFAULTS.quarantineAutoRecoveryMax || 2;
@@ -8282,6 +8531,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)
   pruneStaleWorktreeForBranch, // exported for testing
   findExistingWorktree, // exported for testing
   probeBranchOnRemote, // exported for testing (W-mphnm6a1000281b8)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2148",
+  "version": "0.1.2149",
   "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"