@askexenow/exe-os 0.9.362 → 0.9.365

package/dist/{chunk-TP7RXGMP.js → chunk-ZRKEUCUZ.js}

@@ -1,12 +1,12 @@
 import {
   isPaneBusy
-} from "./chunk-PDJWHL63.js";
+} from "./chunk-ZEKCHV43.js";
 import {
   recordSessionKill
-} from "./chunk-VDMFVUSY.js";
+} from "./chunk-ANPE3TT3.js";
 import {
   updateTask
-} from "./chunk-7H3AZNQ7.js";
+} from "./chunk-AGQAGOQN.js";
 import {
   BUSY_PATTERN,
   countPendingReviews,
@@ -23,26 +23,26 @@ import {
   sessionScopeFilter,
   strictSessionScopeFilter,
   writeNotification
-} from "./chunk-SQM4ZTL2.js";
+} from "./chunk-ORNCMRIX.js";
 import {
   LEASE_MINUTES,
   isLeaseExpired
 } from "./chunk-E23LNUWJ.js";
 import {
   listSessions
-} from "./chunk-D5CY4E7I.js";
-import {
-  getTransport
-} from "./chunk-UXLO7VHX.js";
+} from "./chunk-EHHMNKOA.js";
 import {
   capturePaneLinesAsync,
   listTmuxSessions,
   parseContextPercentage,
   parseContextPercentageAsync
 } from "./chunk-GBNB4EWD.js";
+import {
+  getTransport
+} from "./chunk-UXLO7VHX.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-PV5BIXT6.js";
+} from "./chunk-WR75WUEP.js";
 import {
   checkDispatchStatus,
   readTerminalLauncherFailure,
@@ -51,27 +51,32 @@ import {
 } from "./chunk-AJIXH5JF.js";
 import {
   getAgentRuntime
-} from "./chunk-KDMVVHZH.js";
+} from "./chunk-XTWHNLGD.js";
+import {
+  killIfSameProcess,
+  processStartedAt,
+  recordKillIntent
+} from "./chunk-LNOS24GV.js";
 import {
   baseAgentName,
   getCoordinatorName,
   isCoordinatorName,
   shouldAutoInstance
-} from "./chunk-HLU52KTO.js";
+} from "./chunk-BRLS5OLZ.js";
 import {
   eventLoopBlockedMarkerPath
 } from "./chunk-JY5GAZYC.js";
 import {
   loadConfigSync
-} from "./chunk-BRIZ6OZ3.js";
+} from "./chunk-QMSEL5YS.js";
 
 // src/lib/daemon-orchestration.ts
 import { execFile, execFileSync, execSync } from "child_process";
 import { promisify } from "util";
 import { randomUUID } from "crypto";
-import { existsSync as existsSync2, readFileSync, writeFileSync, unlinkSync, statSync as statSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync, unlinkSync, statSync as statSync2 } from "fs";
 import { homedir, loadavg, freemem, cpus as osCpus, platform } from "os";
-import { join, basename } from "path";
+import { join, basename, dirname } from "path";
 
 // src/lib/session-pane-snapshot.ts
 var CONTEXT_BAR = /[█░]+\s*(\d+)%/;
@@ -209,29 +214,41 @@ async function collectAgentSignals(client, agentId, sessionName, intercomAckWind
 
 // src/lib/daemon-orchestration.ts
 var cpuCount = () => osCpus().length;
-function getAvailableMemoryGB() {
-  if (platform() === "darwin") {
+function parseVmStatAvailableGB(vmStatOutput) {
+  const pageSizeMatch = vmStatOutput.match(/page size of (\d+)/);
+  const pageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : 16384;
+  const parsePages = (label) => {
+    const re = new RegExp(`${label}:\\s+([\\d]+)\\.`);
+    const m = vmStatOutput.match(re);
+    return m ? parseInt(m[1], 10) : 0;
+  };
+  const freePages = parsePages("Pages free");
+  const inactivePages = parsePages("Pages inactive");
+  const purgeablePages = parsePages("Pages purgeable");
+  const availableBytes = (freePages + inactivePages + purgeablePages) * pageSize;
+  return availableBytes / 1024 ** 3;
+}
+var VM_STAT_TTL_MS = 1e4;
+var _vmStatAvailableGB = null;
+var _vmStatSampledAt = 0;
+var _vmStatRefreshing = false;
+function refreshVmStatAvailableGB() {
+  if (_vmStatRefreshing) return;
+  _vmStatRefreshing = true;
+  execFile("vm_stat", [], { encoding: "utf8", timeout: 3e3 }, (err, stdout) => {
+    _vmStatRefreshing = false;
+    if (err) return;
     try {
-      const vmStatOutput = execFileSync("vm_stat", [], {
-        encoding: "utf8",
-        timeout: 3e3,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      const pageSizeMatch = vmStatOutput.match(/page size of (\d+)/);
-      const pageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : 16384;
-      const parsePages = (label) => {
-        const re = new RegExp(`${label}:\\s+([\\d]+)\\.`);
-        const m = vmStatOutput.match(re);
-        return m ? parseInt(m[1], 10) : 0;
-      };
-      const freePages = parsePages("Pages free");
-      const inactivePages = parsePages("Pages inactive");
-      const purgeablePages = parsePages("Pages purgeable");
-      const availableBytes = (freePages + inactivePages + purgeablePages) * pageSize;
-      return availableBytes / 1024 ** 3;
+      _vmStatAvailableGB = parseVmStatAvailableGB(String(stdout));
+      _vmStatSampledAt = Date.now();
     } catch {
-      return freemem() / 1024 ** 3;
     }
+  });
+}
+function getAvailableMemoryGB() {
+  if (platform() === "darwin") {
+    if (Date.now() - _vmStatSampledAt > VM_STAT_TTL_MS) refreshVmStatAvailableGB();
+    return _vmStatAvailableGB ?? freemem() / 1024 ** 3;
   }
   return freemem() / 1024 ** 3;
 }
@@ -2670,16 +2687,49 @@ var HOOK_PROCESS_PATTERNS = [
   "exe-heartbeat-hook.js"
 ];
 var AGENT_CLI_EXECUTABLES = /* @__PURE__ */ new Set(["claude", "codex", "opencode"]);
-function getProcessExecutable(args) {
-  const first = args.trim().split(/\s+/)[0] ?? "";
-  return first.split("/").pop() ?? first;
-}
-function getProcessCommandPrefix(args) {
-  return args.split(/\s+--system-prompt\b/)[0] ?? args;
+var RUNTIME_EXECUTABLES = /* @__PURE__ */ new Set([
+  "node",
+  "nodejs",
+  "bun",
+  "deno",
+  "npx",
+  "python",
+  "python2",
+  "python3",
+  "sh",
+  "bash",
+  "zsh",
+  "dash",
+  "env"
+]);
+function getProcessIdentityTokens(args) {
+  const tokens = args.trim().split(/\s+/);
+  const argv0 = tokens[0] ?? "";
+  const identity = [argv0];
+  if (!RUNTIME_EXECUTABLES.has(basenameOf(argv0))) return identity;
+  for (let i = 1; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.startsWith("-")) continue;
+    identity.push(token);
+    break;
+  }
+  return identity;
+}
+function basenameOf(token) {
+  return token.split("/").pop() ?? token;
+}
+function identityMatchesPattern(identity, pattern) {
+  return identity.some((token) => token === pattern || token.endsWith(`/${pattern}`));
+}
+function isAgentCliProcess(args) {
+  return getProcessIdentityTokens(args).some(
+    (token) => AGENT_CLI_EXECUTABLES.has(basenameOf(token).replace(/\.(?:js|mjs|cjs)$/, ""))
+  );
 }
 var ZOMBIE_AGENT_MAX_AGE_SECS = 300;
 var REAPER_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
 function reapZombieAgentProcesses(deps) {
+  const readStartedAt = deps.getStartedAtMs ?? processStartedAt;
   let liveSessions;
   try {
     liveSessions = new Set(deps.listTmuxSessions());
@@ -2827,6 +2877,20 @@ function reapZombieAgentProcesses(deps) {
     const rssKb = deps.getRssKb ? deps.getRssKb(pid) : null;
     const rssMb = rssKb ? Math.round(rssKb / 1024) : "?";
     const desc = `PID ${pid} (age=${ageSecs}s, RSS=${rssMb}MB, ${info.args.slice(0, 80)})`;
+    const startedAt = readStartedAt(pid);
+    const wrapperStartedAt = wrapperPid > 1 ? readStartedAt(wrapperPid) : null;
+    const guard = (reason) => ({
+      sender: "zombie-reaper",
+      reason,
+      kill: (p, s) => deps.killProcess(p, s),
+      startedAt: readStartedAt
+    });
+    recordKillIntent({
+      targetPid: pid,
+      signal: "SIGTERM",
+      sender: "zombie-reaper",
+      reason: `matched agent pattern, no live tmux session (age=${ageSecs}s) :: ${info.args.slice(0, 200)}`
+    });
     try {
       deps.killProcess(pid, "SIGTERM");
     } catch {
@@ -2837,6 +2901,12 @@ function reapZombieAgentProcesses(deps) {
 `);
     if (wrapperPid > 1 && procMap.has(wrapperPid)) {
       try {
+        recordKillIntent({
+          targetPid: wrapperPid,
+          signal: "SIGTERM",
+          sender: "zombie-reaper",
+          reason: `wrapper of zombie agent PID ${pid} :: ${procMap.get(wrapperPid)?.args.slice(0, 200) ?? ""}`
+        });
         deps.killProcess(wrapperPid, "SIGTERM");
         process.stderr.write(`[zombie-agent-reaper] Killed wrapper PID ${wrapperPid}
 `);
@@ -2844,17 +2914,11 @@ function reapZombieAgentProcesses(deps) {
       }
     }
     deps.scheduleKill(pid, ORPHAN_SIGKILL_DELAY_MS, () => {
-      try {
-        deps.killProcess(pid, "SIGKILL");
-      } catch {
-      }
+      killIfSameProcess(pid, startedAt, "SIGKILL", guard(`zombie agent survived SIGTERM :: ${info.args.slice(0, 200)}`));
     });
     if (wrapperPid > 1) {
       deps.scheduleKill(wrapperPid, ORPHAN_SIGKILL_DELAY_MS, () => {
-        try {
-          deps.killProcess(wrapperPid, "SIGKILL");
-        } catch {
-        }
+        killIfSameProcess(wrapperPid, wrapperStartedAt, "SIGKILL", guard(`wrapper of zombie agent PID ${pid} survived SIGTERM`));
       });
     }
   }
@@ -2978,6 +3042,7 @@ function parseEtime(etime) {
   return 0;
 }
 function reapOrphanedMcpProcesses(deps) {
+  const readStartedAt = deps.getStartedAtMs ?? processStartedAt;
   let lines;
   try {
     lines = deps.listProcesses();
@@ -2994,27 +3059,42 @@ function reapOrphanedMcpProcesses(deps) {
     const etime = match[3];
     const args = match[4];
     if (pid === deps.selfPid) continue;
-    if (AGENT_CLI_EXECUTABLES.has(getProcessExecutable(args))) continue;
-    const matchScope = getProcessCommandPrefix(args);
-    const isPpid1Orphan = ppid === 1 && ORPHAN_PATTERNS.some((pat) => matchScope.includes(pat));
+    const identity = getProcessIdentityTokens(args);
+    const isPpid1Orphan = ppid === 1 && ORPHAN_PATTERNS.some((pat) => identityMatchesPattern(identity, pat));
     const ageSecs = parseEtime(etime);
-    const isAgedHookOrphan = ageSecs > ORPHAN_MAX_AGE_SECS && HOOK_PROCESS_PATTERNS.some((pat) => matchScope.includes(pat));
+    const isAgedHookOrphan = ageSecs > ORPHAN_MAX_AGE_SECS && HOOK_PROCESS_PATTERNS.some((pat) => identityMatchesPattern(identity, pat));
     if (!isPpid1Orphan && !isAgedHookOrphan) continue;
+    if (isAgentCliProcess(args)) {
+      process.stderr.write(
+        `[orphan-reaper] Protected PID ${pid} \u2014 agent CLI (${identity.join(" ").slice(0, 100)})
+`
+      );
+      continue;
+    }
+    const reason = isPpid1Orphan ? "ppid=1" : `age=${ageSecs}s`;
+    const startedAt = readStartedAt(pid);
+    recordKillIntent({
+      targetPid: pid,
+      signal: "SIGTERM",
+      sender: "orphan-reaper",
+      reason: `matched ${isPpid1Orphan ? "ORPHAN_PATTERNS" : "HOOK_PROCESS_PATTERNS"} (${reason}) :: ${args.slice(0, 200)}`
+    });
     try {
       deps.killProcess(pid, "SIGTERM");
     } catch {
       continue;
     }
-    const reason = isPpid1Orphan ? "ppid=1" : `age=${ageSecs}s`;
     const desc = `PID ${pid} (${reason}, ${args.slice(0, 100)})`;
     reaped.push(desc);
     process.stderr.write(`[orphan-reaper] Killed ${desc}
 `);
     deps.scheduleKill(pid, ORPHAN_SIGKILL_DELAY_MS, () => {
-      try {
-        deps.killProcess(pid, "SIGKILL");
-      } catch {
-      }
+      killIfSameProcess(pid, startedAt, "SIGKILL", {
+        sender: "orphan-reaper",
+        reason: `orphan survived SIGTERM (${reason}) :: ${args.slice(0, 200)}`,
+        kill: (p, s) => deps.killProcess(p, s),
+        startedAt: readStartedAt
+      });
     });
   }
   return reaped;
@@ -3070,8 +3150,77 @@ var WORKTREE_REAPER_INTERVAL_MS = 30 * 60 * 1e3;
 var WORKTREE_MIN_AGE_MS = 60 * 60 * 1e3;
 var WORKTREE_MAX_PRUNES_PER_TICK = 5;
 var WORKTREE_DIRTY_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var WORKTREE_ARCHIVE_FAILURE_MAX_ATTEMPTS = 3;
+var WORKTREE_ARCHIVE_FAILURE_STATE_PATH = join(homedir(), ".exe-os", "session-cache", "worktree-reaper-archive-failures.json");
+function worktreeArchiveFailureKey(repoRoot, wtPath, branch) {
+  return JSON.stringify([repoRoot, wtPath, branch]);
+}
+function normalizeArchiveFailureState(raw) {
+  const entries = {};
+  if (!raw || typeof raw !== "object") return { entries };
+  const src = raw.entries;
+  if (!src || typeof src !== "object") return { entries };
+  for (const [key, val] of Object.entries(src)) {
+    if (!val || typeof val !== "object") continue;
+    const e = val;
+    if (typeof e.attempts !== "number" || !Number.isFinite(e.attempts) || e.attempts < 0 || typeof e.firstFailureAt !== "number" || !Number.isFinite(e.firstFailureAt) || typeof e.lastFailureAt !== "number" || !Number.isFinite(e.lastFailureAt) || typeof e.mtimeMs !== "number" || !Number.isFinite(e.mtimeMs)) continue;
+    entries[key] = {
+      attempts: Math.floor(e.attempts),
+      firstFailureAt: e.firstFailureAt,
+      lastFailureAt: e.lastFailureAt,
+      mtimeMs: e.mtimeMs,
+      ...typeof e.lastError === "string" ? { lastError: e.lastError.slice(0, 500) } : {}
+    };
+  }
+  return { entries };
+}
+function loadWorktreeArchiveFailureState(statePath = WORKTREE_ARCHIVE_FAILURE_STATE_PATH) {
+  try {
+    if (!existsSync2(statePath)) return { entries: {} };
+    return normalizeArchiveFailureState(JSON.parse(readFileSync(statePath, "utf8")));
+  } catch {
+    return { entries: {} };
+  }
+}
+function saveWorktreeArchiveFailureState(state, statePath = WORKTREE_ARCHIVE_FAILURE_STATE_PATH) {
+  mkdirSync(dirname(statePath), { recursive: true });
+  writeFileSync(statePath, JSON.stringify({ entries: state.entries }, null, 2), "utf8");
+}
+function archiveFailureEntryFor(state, key, mtimeMs) {
+  const entry = state.entries[key];
+  if (!entry) return null;
+  if (entry.mtimeMs !== mtimeMs) return null;
+  return entry;
+}
+function shouldSkipWorktreeArchiveAfterFailures(state, key, mtimeMs, maxAttempts = WORKTREE_ARCHIVE_FAILURE_MAX_ATTEMPTS) {
+  const entry = archiveFailureEntryFor(state, key, mtimeMs);
+  if (!entry) return null;
+  return entry.attempts >= maxAttempts ? entry : null;
+}
+function recordWorktreeArchiveFailure(state, key, mtimeMs, nowMs, err) {
+  const prev = archiveFailureEntryFor(state, key, mtimeMs);
+  const text = err instanceof Error ? err.message : String(err);
+  const entry = {
+    attempts: (prev?.attempts ?? 0) + 1,
+    firstFailureAt: prev?.firstFailureAt ?? nowMs,
+    lastFailureAt: nowMs,
+    mtimeMs,
+    lastError: text.slice(0, 500)
+  };
+  state.entries[key] = entry;
+  return entry;
+}
+function clearWorktreeArchiveFailure(state, key) {
+  if (!(key in state.entries)) return false;
+  delete state.entries[key];
+  return true;
+}
 async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
   const result = { pruned: [], skipped: [] };
+  const archiveFailureState = deps.loadArchiveFailureState?.() ?? { entries: {} };
+  const rawArchiveFailureMaxAttempts = deps.archiveFailureMaxAttempts ?? WORKTREE_ARCHIVE_FAILURE_MAX_ATTEMPTS;
+  const archiveFailureMaxAttempts = Number.isFinite(rawArchiveFailureMaxAttempts) && rawArchiveFailureMaxAttempts > 0 ? Math.floor(rawArchiveFailureMaxAttempts) : WORKTREE_ARCHIVE_FAILURE_MAX_ATTEMPTS;
+  let archiveFailureStateChanged = false;
   let sessions;
   try {
     sessions = deps.listTmuxSessions();
@@ -3129,7 +3278,39 @@ async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
       }
       if (await deps.isWorktreeDirty(wt.path)) {
         const ageH2 = Math.round(ageMs / 36e5);
+        let archiveFailureReason = null;
         if (ageMs >= WORKTREE_DIRTY_MAX_AGE_MS && deps.archiveDirtyWorktree) {
+          const archiveFailureKey = worktreeArchiveFailureKey(repoRoot, wt.path, wt.branch);
+          const suppressed = shouldSkipWorktreeArchiveAfterFailures(
+            archiveFailureState,
+            archiveFailureKey,
+            mtimeMs,
+            archiveFailureMaxAttempts
+          );
+          if (suppressed) {
+            process.stderr.write(
+              `[worktree-reaper] Archive retry limit reached for ${wt.path} (${suppressed.attempts}/${archiveFailureMaxAttempts} failures; last=${suppressed.lastError ?? "unknown"}). Skipping future archive attempts until the worktree changes or ${WORKTREE_ARCHIVE_FAILURE_STATE_PATH} is cleared.
+`
+            );
+            result.skipped.push({
+              path: wt.path,
+              reason: `uncommitted changes (archive retry limit reached ${suppressed.attempts}/${archiveFailureMaxAttempts})`
+            });
+            recordOrchestrationEventBestEffort({
+              eventType: "worktree.skipped",
+              source: "daemon-orchestration.reapOrphanedWorktrees",
+              severity: "warn",
+              agentId: agentName,
+              payload: {
+                reason: "archive retry limit reached",
+                branch: wt.branch,
+                ageHours: ageH2,
+                attempts: suppressed.attempts,
+                maxAttempts: archiveFailureMaxAttempts
+              }
+            });
+            continue;
+          }
           process.stderr.write(
             `[worktree-reaper] Dirty orphan worktree aged out (${ageH2}h > ${WORKTREE_DIRTY_MAX_AGE_MS / 36e5}h), archiving: ${wt.path} (agent: ${agentName})
 `
@@ -3137,6 +3318,9 @@ async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
           try {
             const archived = await deps.archiveDirtyWorktree(repoRoot, wt.path, wt.branch, agentName);
             if (archived) {
+              if (clearWorktreeArchiveFailure(archiveFailureState, archiveFailureKey)) {
+                archiveFailureStateChanged = true;
+              }
               const removed2 = await deps.removeWorktree(repoRoot, wt.path);
               if (removed2) {
                 await deps.deleteBranch(repoRoot, wt.branch);
@@ -3154,25 +3338,64 @@ async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
                 result.pruned.push(wt.path);
                 continue;
               }
+              archiveFailureReason = "git worktree remove failed after archive";
+            } else {
+              const failure = recordWorktreeArchiveFailure(
+                archiveFailureState,
+                archiveFailureKey,
+                mtimeMs,
+                nowMs,
+                new Error("archive returned false")
+              );
+              archiveFailureStateChanged = true;
+              archiveFailureReason = `uncommitted changes (archive failed ${failure.attempts}/${archiveFailureMaxAttempts}${failure.attempts >= archiveFailureMaxAttempts ? "; retry limit reached" : ""})`;
+              if (failure.attempts >= archiveFailureMaxAttempts) {
+                process.stderr.write(
+                  `[worktree-reaper] Archive retry limit reached for ${wt.path} (${failure.attempts}/${archiveFailureMaxAttempts} failures). Future ticks will skip git archive attempts until the worktree changes.
+`
+                );
+              }
             }
           } catch (err) {
+            const failure = recordWorktreeArchiveFailure(
+              archiveFailureState,
+              archiveFailureKey,
+              mtimeMs,
+              nowMs,
+              err
+            );
+            archiveFailureStateChanged = true;
+            archiveFailureReason = `uncommitted changes (archive failed ${failure.attempts}/${archiveFailureMaxAttempts}${failure.attempts >= archiveFailureMaxAttempts ? "; retry limit reached" : ""})`;
             process.stderr.write(
               `[worktree-reaper] Failed to archive dirty orphan ${wt.path}: ${err instanceof Error ? err.message : String(err)}
 `
             );
+            if (failure.attempts >= archiveFailureMaxAttempts) {
+              process.stderr.write(
+                `[worktree-reaper] Archive retry limit reached for ${wt.path} (${failure.attempts}/${archiveFailureMaxAttempts} failures). Future ticks will skip git archive attempts until the worktree changes.
+`
+              );
+            }
           }
         }
         process.stderr.write(
           `[worktree-reaper] WARNING: Orphan worktree has uncommitted changes, skipping: ${wt.path} (agent: ${agentName}, age: ${ageH2}h)
 `
         );
-        result.skipped.push({ path: wt.path, reason: ageMs >= WORKTREE_DIRTY_MAX_AGE_MS ? "uncommitted changes (archive failed)" : "uncommitted changes" });
+        result.skipped.push({
+          path: wt.path,
+          reason: archiveFailureReason ?? (ageMs >= WORKTREE_DIRTY_MAX_AGE_MS ? "uncommitted changes (archive failed)" : "uncommitted changes")
+        });
         recordOrchestrationEventBestEffort({
           eventType: "worktree.skipped",
           source: "daemon-orchestration.reapOrphanedWorktrees",
           severity: "warn",
           agentId: agentName,
-          payload: { reason: "uncommitted changes", ageHours: ageH2, agedOut: ageMs >= WORKTREE_DIRTY_MAX_AGE_MS }
+          payload: {
+            reason: archiveFailureReason ?? "uncommitted changes",
+            ageHours: ageH2,
+            agedOut: ageMs >= WORKTREE_DIRTY_MAX_AGE_MS
+          }
         });
         continue;
       }
@@ -3224,11 +3447,17 @@ async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
       }
     }
   }
+  if (archiveFailureStateChanged) {
+    try {
+      deps.saveArchiveFailureState?.(archiveFailureState);
+    } catch {
+    }
+  }
   return result;
 }
 async function createWorktreeReaperRealDeps() {
   const { getPaneCwdAsync } = await import("./lib/tmux-status.js");
-  const { getGitRootAsync, isWorktreeDirtyAsync } = await import("./worktree-ZWA35PKW.js");
+  const { getGitRootAsync, isWorktreeDirtyAsync } = await import("./worktree-H3YFJ3NU.js");
   const { statSync: statSync3 } = await import("fs");
   const { basename: basename2 } = await import("path");
   const { promisify: promisify2 } = await import("util");
@@ -3243,28 +3472,39 @@ async function createWorktreeReaperRealDeps() {
     sessions = String(stdout ?? "").split("\n").map((s) => s.trim()).filter(Boolean);
   } catch {
   }
+  const REAPER_FANOUT = 4;
+  const runPooled = async (items, fn) => {
+    let next = 0;
+    const worker = async () => {
+      for (; ; ) {
+        const i = next++;
+        if (i >= items.length) return;
+        await fn(items[i]);
+      }
+    };
+    const lanes = Math.max(1, Math.min(REAPER_FANOUT, items.length));
+    await Promise.all(Array.from({ length: lanes }, () => worker()));
+  };
   const cwdMap = /* @__PURE__ */ new Map();
-  const cwdPromises = sessions.map(async (s) => {
+  await runPooled(sessions, async (s) => {
     try {
       const cwd = await getPaneCwdAsync(s);
       if (cwd) cwdMap.set(s, cwd);
     } catch {
     }
   });
-  await Promise.all(cwdPromises);
   const gitRootCache = /* @__PURE__ */ new Map();
-  const rootPromises = [...cwdMap.values()].map(async (cwd) => {
+  await runPooled([...new Set(cwdMap.values())], async (cwd) => {
     if (gitRootCache.has(cwd)) return;
     const root = await getGitRootAsync(cwd);
     gitRootCache.set(cwd, root);
   });
-  await Promise.all(rootPromises);
   const repoRoots = /* @__PURE__ */ new Set();
   for (const root of gitRootCache.values()) {
     if (root) repoRoots.add(root);
   }
   const worktreeCache = /* @__PURE__ */ new Map();
-  const wtPromises = [...repoRoots].map(async (repoRoot) => {
+  await runPooled([...repoRoots], async (repoRoot) => {
     try {
       const { stdout } = await execFileAsync2("git", ["worktree", "list", "--porcelain"], {
         cwd: repoRoot,
@@ -3285,7 +3525,6 @@ async function createWorktreeReaperRealDeps() {
     } catch {
     }
   });
-  await Promise.all(wtPromises);
   return {
     listTmuxSessions: () => sessions,
     getPaneCwd: (s) => cwdMap.get(s),
@@ -3371,6 +3610,8 @@ async function createWorktreeReaperRealDeps() {
     // Pure cache lookup — the async prefetch above populated gitRootCache for
     // every live session cwd, so the reaper never shells out on the event loop.
     getGitRoot: (dir) => gitRootCache.get(dir) ?? null,
+    loadArchiveFailureState: () => loadWorktreeArchiveFailureState(),
+    saveArchiveFailureState: (state) => saveWorktreeArchiveFailureState(state),
     archiveDirtyWorktree: async (_repoRoot, wtPath, _branch, agentName) => {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
       const quarantineBranch = `quarantine/${agentName}-${timestamp}`;
@@ -3459,7 +3700,7 @@ async function gcStaleCheckpoints() {
 }
 async function pollTaskGroupBarriers() {
   try {
-    const { checkAndFireBarriers } = await import("./tasks-crud-NVNF3NRA.js");
+    const { checkAndFireBarriers } = await import("./tasks-crud-W7VGWRUV.js");
     const firedGroupIds = await checkAndFireBarriers();
     if (firedGroupIds.length === 0) return 0;
     const { getClient } = await import("./lib/database.js");
@@ -3600,6 +3841,13 @@ export {
   createOrphanReaperRealDeps,
   createOrphanReaperRealDepsAsync,
   WORKTREE_REAPER_INTERVAL_MS,
+  WORKTREE_ARCHIVE_FAILURE_MAX_ATTEMPTS,
+  worktreeArchiveFailureKey,
+  loadWorktreeArchiveFailureState,
+  saveWorktreeArchiveFailureState,
+  shouldSkipWorktreeArchiveAfterFailures,
+  recordWorktreeArchiveFailure,
+  clearWorktreeArchiveFailure,
   reapOrphanedWorktrees,
   createWorktreeReaperRealDeps,
   gcStaleCheckpoints,