@askexenow/exe-os 0.9.340 → 0.9.342

package/dist/{chunk-XCTGRD4S.js → chunk-CE7F6RHG.js}

@@ -1,50 +1,68 @@
+import {
+  isPaneBusy
+} from "./chunk-4CMVFVFC.js";
 import {
   recordSessionKill
-} from "./chunk-T4KZ2Z2N.js";
+} from "./chunk-L4A5DL6Z.js";
 import {
   updateTask
-} from "./chunk-542EWGY3.js";
+} from "./chunk-QYZJHTNE.js";
+import {
+  checkDispatchStatus,
+  readTerminalLauncherFailure,
+  releaseDispatchClaim,
+  tryAcquireDispatchClaim
+} from "./chunk-O7LWR36Z.js";
 import {
   countPendingReviews,
   ensureEmployeeAsync,
   extractRootExe,
   getSessionState,
+  getSessionStateAsync,
   isExeSession,
+  isValidSessionScope,
   queryTaskRows,
   queueIntercom,
   sendIntercomAsync,
+  sessionHasPendingInputAsync,
   sessionScopeFilter,
   strictSessionScopeFilter,
   writeNotification
-} from "./chunk-PLRIJALF.js";
+} from "./chunk-UP75Z5X7.js";
 import {
+  LEASE_MINUTES,
   isLeaseExpired
 } from "./chunk-E23LNUWJ.js";
 import {
   listSessions
-} from "./chunk-UIV2WPBT.js";
-import {
-  listTmuxSessions,
-  parseContextPercentage
-} from "./chunk-SSTLTIF3.js";
+} from "./chunk-KGWRTRKC.js";
 import {
   getTransport
-} from "./chunk-RMOBQ6A5.js";
+} from "./chunk-AD2VCHSS.js";
+import {
+  capturePaneLinesAsync,
+  listTmuxSessions,
+  parseContextPercentage,
+  parseContextPercentageAsync
+} from "./chunk-SKGMF2SO.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-FUIIVSW6.js";
+} from "./chunk-2WAVZ5UJ.js";
 import {
   getAgentRuntime
-} from "./chunk-65SVQELL.js";
+} from "./chunk-HA5R6USD.js";
+import {
+  BUSY_PATTERN
+} from "./chunk-GWDSB25T.js";
 import {
   baseAgentName,
   getCoordinatorName,
   isCoordinatorName,
   shouldAutoInstance
-} from "./chunk-HEPR6QTL.js";
+} from "./chunk-AOHXREB7.js";
 import {
   loadConfigSync
-} from "./chunk-7Y5UDEVM.js";
+} from "./chunk-WZHZCDDO.js";
 
 // src/lib/daemon-orchestration.ts
 import { execFile, execFileSync, execSync } from "child_process";
@@ -54,6 +72,43 @@ import { existsSync as existsSync2, readFileSync, writeFileSync, unlinkSync, sta
 import { homedir, loadavg, freemem, cpus as osCpus, platform } from "os";
 import { join, basename } from "path";
 
+// src/lib/session-pane-snapshot.ts
+var CONTEXT_BAR = /[█░]+\s*(\d+)%/;
+var PROMPT_INPUT_LINE = /(?:^|\s|│)\s*[❯›>]\s?(.*)$/u;
+var PROMPT_PLACEHOLDER = /^Try\s+["'“]/u;
+function parseContextFromPane(paneText) {
+  for (const line of paneText.split("\n")) {
+    const m = line.match(CONTEXT_BAR);
+    if (m) return parseInt(m[1], 10);
+  }
+  return null;
+}
+function isPaneWorking(paneText) {
+  return /Running…/.test(paneText) || BUSY_PATTERN.test(paneText);
+}
+function extractPaneInputBuffer(paneText) {
+  const lines = paneText.split("\n");
+  const tail = lines.slice(-12);
+  for (let i = tail.length - 1; i >= 0; i--) {
+    const line = tail[i];
+    if (!line || line.trim().length === 0) continue;
+    const m = PROMPT_INPUT_LINE.exec(line);
+    if (!m) continue;
+    const content = (m[1] ?? "").replace(/[│]\s*$/u, "").trim();
+    if (content.length === 0) return "";
+    if (PROMPT_PLACEHOLDER.test(content)) return "";
+    return content;
+  }
+  return "";
+}
+function derivePaneSnapshot(paneText) {
+  return {
+    contextPct: parseContextFromPane(paneText),
+    working: isPaneWorking(paneText),
+    inputBuffer: extractPaneInputBuffer(paneText)
+  };
+}
+
 // src/lib/agent-signals.ts
 import { existsSync, openSync, closeSync, readSync, statSync } from "fs";
 import os from "os";
@@ -182,6 +237,7 @@ function getAvailableMemoryGB() {
 var execFileAsync = promisify(execFile);
 var IDLE_NUDGE_DEDUP_MS = Number(process.env.EXE_NUDGE_INTERVAL_MS) || 6e4;
 var SESSION_TTL_HOURS = Number(process.env.EXE_SESSION_TTL_HOURS) || 8;
+var UNREACHABLE_ACTIVE_TASK_TTL_HOURS = Number(process.env.EXE_UNREACHABLE_ACTIVE_TASK_TTL_HOURS) || 1;
 var SESSION_CONTEXT_THRESHOLD_PCT = Number(process.env.EXE_CONTEXT_KILL_PCT) || 80;
 var IDLE_KILL_INTERCOM_ACK_WINDOW_MS = Number(process.env.EXE_INTERCOM_ACK_WINDOW_MS) || 6e4;
 function shouldNudgeEmployee(sessionState, hasOpenTasks2, lastNudgeMs, nowMs, dedupMs) {
@@ -198,6 +254,19 @@ function classifyTtlKillReason(ageHours, contextPct) {
   if (contextPct !== null && contextPct > SESSION_CONTEXT_THRESHOLD_PCT) return "ttl_context";
   return null;
 }
+function isUnreachableActiveTaskSession(input) {
+  if (input.ageHours < UNREACHABLE_ACTIVE_TASK_TTL_HOURS) return false;
+  if (input.state === "offline" || input.state === "no_claude") return true;
+  if (input.hasPendingInput && input.state !== "thinking" && input.state !== "tool") return true;
+  return false;
+}
+var WEDGE_RECOVERY_TICKS_REQUIRED = Math.max(
+  1,
+  Number(process.env.EXE_WEDGE_RECOVERY_TICKS) || 2
+);
+function clearInputBufferArgs(sessionName) {
+  return ["send-keys", "-t", sessionName, "C-u"];
+}
 function shouldKillIdleSession(input) {
   if (!input.enabled) return false;
   if (isExeSession(input.sessionName)) return false;
@@ -240,38 +309,121 @@ async function pollIdleEmployees(deps, lastNudge) {
   }
   return nudged;
 }
-async function checkSessionTTL(deps) {
+async function checkSessionTTL(deps, wedgeObservations = /* @__PURE__ */ new Map()) {
   const registered = deps.listRegisteredSessions().filter(
     (s) => !isCoordinatorName(s.agentId) && !isExeSession(s.windowName)
   );
   if (registered.length === 0) return [];
   let liveSessions;
   try {
-    liveSessions = new Set(deps.listTmuxSessions());
+    liveSessions = new Set(await deps.listTmuxSessions());
   } catch (e) {
     process.stderr.write("[daemon-orch] list tmux sessions for TTL check: " + (e instanceof Error ? e.message : String(e)) + "\n");
     return [];
   }
   const killed = [];
   for (const entry of registered) {
-    if (!liveSessions.has(entry.windowName)) continue;
+    if (!liveSessions.has(entry.windowName)) {
+      wedgeObservations.delete(entry.windowName);
+      continue;
+    }
     if (isCoordinatorName(entry.agentId) || isExeSession(entry.windowName)) continue;
-    const createdEpoch = deps.getSessionCreatedEpoch(entry.windowName);
+    const createdEpoch = await deps.getSessionCreatedEpoch(entry.windowName);
     if (createdEpoch === null) continue;
     const ageHours = (Date.now() / 1e3 - createdEpoch) / 3600;
-    const contextPct = deps.parseContextPercentage(entry.windowName);
+    const snapshot = await deps.captureSessionSnapshot?.(entry.windowName) ?? null;
+    const contextPct = snapshot ? snapshot.contextPct : await deps.parseContextPercentage(entry.windowName);
     const killReason = classifyTtlKillReason(ageHours, contextPct);
+    if (killReason === null && snapshot) {
+      const tooYoung = entry.registeredAt ? Date.now() - new Date(entry.registeredAt).getTime() < 5 * 60 * 1e3 : false;
+      const buffer = snapshot.inputBuffer;
+      const wedgeCandidate = !tooYoung && !snapshot.working && buffer.length > 0;
+      if (!wedgeCandidate) {
+        wedgeObservations.delete(entry.windowName);
+      } else {
+        const prev = wedgeObservations.get(entry.windowName);
+        if (!prev || prev.buffer !== buffer) {
+          wedgeObservations.set(entry.windowName, { buffer, ticks: 1, cleared: false });
+        } else {
+          const ticks = prev.ticks + 1;
+          if (ticks < WEDGE_RECOVERY_TICKS_REQUIRED) {
+            wedgeObservations.set(entry.windowName, { buffer, ticks, cleared: prev.cleared });
+          } else {
+            let hasActive = false;
+            try {
+              hasActive = deps.hasActiveTasks ? await deps.hasActiveTasks(entry.agentId) : false;
+            } catch {
+              hasActive = false;
+            }
+            const scope = entry.windowName.includes("-") ? entry.windowName.slice(entry.windowName.indexOf("-") + 1) : null;
+            if (!hasActive) {
+              wedgeObservations.delete(entry.windowName);
+            } else if (!prev.cleared && deps.clearInputBuffer) {
+              deps.clearInputBuffer(entry.windowName);
+              wedgeObservations.set(entry.windowName, { buffer, ticks: 0, cleared: true });
+              process.stderr.write(
+                `[exed] Session TTL: wedged-input CLEAR (C-u) for ${entry.windowName} (buffer stable ${ticks} ticks) \u2014 clearing stuck buffer so the queued nudge lands
+`
+              );
+              recordOrchestrationEventBestEffort({
+                eventType: "session.wedge_clear",
+                source: "daemon-orchestration.checkSessionTTL",
+                agentId: entry.agentId,
+                tmuxSession: entry.windowName,
+                sessionScope: scope,
+                payload: { ageHours: parseFloat(ageHours.toFixed(2)), contextPct, trigger: "pending_input_wedge", wedgeTicks: ticks }
+              });
+            } else {
+              wedgeObservations.delete(entry.windowName);
+              process.stderr.write(
+                `[exed] Session TTL: wedged-input KILL for ${entry.windowName} (buffer byte-identical through clear + dwell) \u2014 killing to respawn active task
+`
+              );
+              deps.recordKill?.({ sessionName: entry.windowName, agentId: entry.agentId, reason: "unreachable" });
+              recordOrchestrationEventBestEffort({
+                eventType: "session.unreachable_kill",
+                source: "daemon-orchestration.checkSessionTTL",
+                agentId: entry.agentId,
+                tmuxSession: entry.windowName,
+                sessionScope: scope,
+                payload: {
+                  ageHours: parseFloat(ageHours.toFixed(2)),
+                  contextPct,
+                  killReason: "unreachable",
+                  trigger: "pending_input_wedge",
+                  wedgeTicks: ticks
+                }
+              });
+              deps.killSession(entry.windowName);
+              killed.push(entry.windowName);
+              continue;
+            }
+          }
+        }
+      }
+    }
     if (killReason !== null) {
       const isContextFull = contextPct !== null && contextPct > 85;
+      let telemetryReason = killReason;
       if (deps.hasActiveTasks && !isContextFull) {
         try {
           const active = await deps.hasActiveTasks(entry.agentId);
           if (active) {
-            process.stderr.write(
-              `[exed] Session TTL: SKIPPING ${entry.windowName} (age=${ageHours.toFixed(1)}h, reason=${killReason}) \u2014 agent has active tasks
+            const state = await deps.getSessionState?.(entry.windowName) ?? null;
+            const pendingInput = await deps.hasPendingInput?.(entry.windowName) ?? false;
+            if (isUnreachableActiveTaskSession({ ageHours, state, hasPendingInput: pendingInput })) {
+              telemetryReason = "unreachable";
+              process.stderr.write(
+                `[exed] Session TTL: unreachable override for ${entry.windowName} (age=${ageHours.toFixed(1)}h, state=${state ?? "unknown"}, pendingInput=${pendingInput}) \u2014 killing despite active tasks
 `
-            );
-            continue;
+              );
+            } else {
+              process.stderr.write(
+                `[exed] Session TTL: SKIPPING ${entry.windowName} (age=${ageHours.toFixed(1)}h, reason=${killReason}) \u2014 agent has active tasks
+`
+              );
+              continue;
+            }
           }
         } catch {
           process.stderr.write(
@@ -288,23 +440,23 @@ async function checkSessionTTL(deps) {
         );
       }
       process.stderr.write(
-        `[exed] Session TTL: killing ${entry.windowName} (age=${ageHours.toFixed(1)}h, context=${contextPct}%, reason=${killReason})
+        `[exed] Session TTL: killing ${entry.windowName} (age=${ageHours.toFixed(1)}h, context=${contextPct}%, reason=${telemetryReason})
 `
       );
       deps.recordKill?.({
         sessionName: entry.windowName,
         agentId: entry.agentId,
-        reason: killReason
+        reason: telemetryReason
       });
       recordOrchestrationEventBestEffort({
-        eventType: killReason === "ttl_age" ? "session.ttl_kill" : "session.context_kill",
+        eventType: telemetryReason === "ttl_age" ? "session.ttl_kill" : telemetryReason === "ttl_context" ? "session.context_kill" : "session.unreachable_kill",
         source: "daemon-orchestration.checkSessionTTL",
         agentId: entry.agentId,
         tmuxSession: entry.windowName,
         sessionScope: entry.windowName.includes("-") ? entry.windowName.slice(entry.windowName.indexOf("-") + 1) : null,
-        payload: { ageHours: parseFloat(ageHours.toFixed(2)), contextPct, killReason }
+        payload: { ageHours: parseFloat(ageHours.toFixed(2)), contextPct, killReason: telemetryReason }
       });
-      deps.killSession(entry.windowName);
+      await deps.killSession(entry.windowName);
       killed.push(entry.windowName);
     }
   }
@@ -478,6 +630,20 @@ async function pollReviewNudge(deps, state) {
           `[review-nudge] ${row.count} review(s) scoped to dead coordinator "${row.scope}" folded into live coordinator "${attributed}" (project "${row.projectName}")
 `
         );
+        const corruptedLiteral = row.scope;
+        if (deps.repairCorruptedScope && !isValidSessionScope(row.scope)) {
+          try {
+            const repaired = await deps.repairCorruptedScope(corruptedLiteral, row.projectName ?? null, attributed);
+            if (repaired > 0) {
+              process.stderr.write(
+                `[review-nudge] REPAIRED ${repaired} row(s) with corrupted session_scope ${JSON.stringify(corruptedLiteral.slice(0, 60))} \u2192 "${attributed}" (bug 4941abba)
+`
+              );
+            }
+          } catch (e) {
+            process.stderr.write("[review-nudge] corrupted-scope repair failed: " + (e instanceof Error ? e.message : String(e)) + "\n");
+          }
+        }
       } else {
         const lastAlert = _deadScopeReviewAlertAt.get(row.scope) ?? 0;
         if (now - lastAlert < DEAD_SCOPE_REVIEW_ALERT_MS) continue;
@@ -550,8 +716,26 @@ function saveNudgeState(state) {
   const entries = Array.from(state.lastNudge.entries());
   writeFileSync(NUDGE_STATE_PATH, JSON.stringify(entries), "utf8");
 }
-function createReviewNudgeRealDeps(_getClient) {
+function createReviewNudgeRealDeps(getClient) {
   return {
+    // Bug 4941abba: additive cleanup — re-scope rows carrying a corrupted
+    // session_scope (leaked shell fragment) to the live coordinator the fold
+    // logic attributed them to. Scoped to the exact corrupted literal + the
+    // same project the attribution was decided on. UPDATE only; never
+    // destructive to user data.
+    repairCorruptedScope: async (corruptedScope, projectName, newScope) => {
+      if (!isValidSessionScope(newScope)) return 0;
+      const client = getClient();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const res = projectName === null ? await client.execute({
+        sql: `UPDATE tasks SET session_scope = ?, updated_at = ? WHERE session_scope = ? AND project_name IS NULL`,
+        args: [newScope, now, corruptedScope]
+      }) : await client.execute({
+        sql: `UPDATE tasks SET session_scope = ?, updated_at = ? WHERE session_scope = ? AND project_name = ?`,
+        args: [newScope, now, corruptedScope, projectName]
+      });
+      return Number(res?.rowsAffected ?? 0);
+    },
     listTmuxSessions: () => listTmuxSessions(),
     getSessionState: (sessionName) => getSessionState(sessionName),
     countReviewsForScope: async (sessionScope) => {
@@ -622,7 +806,12 @@ function createIdleNudgeRealDeps(_getClient) {
       if (rows.length === 0) return null;
       return rows[0];
     },
-    sendIntercom: (sessionName) => sendIntercomAsync(sessionName),
+    // Bug f9302cc0: the daemon's idle nudge targets the employee session whose
+    // scoped task was just verified (queryOpenTask filters by the employee's
+    // own scope). Derive the caller scope from the TARGET session so the
+    // isolation gate compares task-lane against task-lane instead of blocking
+    // on unrelated ambient daemon context.
+    sendIntercom: (sessionName) => sendIntercomAsync(sessionName, { callerSessionScope: extractRootExe(sessionName) }),
     killSession: (sessionName) => {
       getTransport().kill(sessionName);
     },
@@ -638,8 +827,21 @@ function createIdleNudgeRealDeps(_getClient) {
 function createSessionTTLRealDeps(getClient) {
   return {
     listRegisteredSessions: () => listSessions(),
-    listTmuxSessions: () => listTmuxSessions(),
-    getSessionCreatedEpoch: (sessionName) => {
+    // Bug 1c870c78: TTL runs on a 5-min timer — list sessions async (execFile).
+    listTmuxSessions: async () => {
+      try {
+        const socket = process.env.EXE_TMUX_SOCKET;
+        const socketArgs = socket ? ["-L", socket] : [];
+        const { stdout } = await execFileAsync("tmux", [...socketArgs, "list-sessions", "-F", "#{session_name}"], {
+          encoding: "utf8",
+          timeout: 3e3
+        });
+        return String(stdout ?? "").trim().split("\n").filter(Boolean);
+      } catch {
+        return [];
+      }
+    },
+    getSessionCreatedEpoch: async (sessionName) => {
       try {
         const sessions = listSessions();
         const entry = sessions.find((s) => s.windowName === sessionName);
@@ -650,20 +852,60 @@ function createSessionTTLRealDeps(getClient) {
       } catch {
       }
       try {
-        const out = execFileSync(
+        const { stdout } = await execFileAsync(
           "tmux",
           ["display-message", "-t", sessionName, "-p", "#{session_created}"],
-          { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 3e3 }
-        ).trim();
-        const epoch = parseInt(out, 10);
+          { encoding: "utf8", timeout: 3e3 }
+        );
+        const epoch = parseInt(String(stdout ?? "").trim(), 10);
         return isNaN(epoch) ? null : epoch;
       } catch {
         return null;
       }
     },
-    parseContextPercentage: (sessionName) => parseContextPercentage(sessionName),
-    killSession: (sessionName) => {
-      getTransport().kill(sessionName);
+    // UNION (fix/wake-daemon-20260711 x fix/phantom-goalhook-20260711). wake-daemon
+    // moves the TTL-timer deps onto async twins (bug 1c870c78) precisely so the
+    // daemon event loop is never blocked by a sync tmux subprocess — a stall here
+    // is the 14-38s event-loop block that drops every MCP client. phantom-goalhook
+    // (de5d9fe8) landed captureSessionSnapshot/clearInputBuffer on the SAME timer
+    // while that async work was in flight, so they arrived SYNC. Keeping both
+    // verbatim would re-introduce exactly the stall wake-daemon exists to remove,
+    // and would text-merge clean while doing it. Both are async here.
+    parseContextPercentage: (sessionName) => parseContextPercentageAsync(sessionName),
+    getSessionState: (sessionName) => getSessionStateAsync(sessionName),
+    hasPendingInput: (sessionName) => sessionHasPendingInputAsync(sessionName),
+    // de5d9fe8: SINGLE pane capture → context %, working-state, and input-buffer
+    // content. Used by checkSessionTTL for BOTH context % and the wedge check, so
+    // the wedge path adds no extra capture on the tick. Now async (capturePaneLinesAsync).
+    captureSessionSnapshot: async (sessionName) => {
+      try {
+        const transport = getTransport();
+        if (!transport.isAlive(sessionName)) return null;
+        const lines = await capturePaneLinesAsync(sessionName, 12);
+        return derivePaneSnapshot(lines.join("\n"));
+      } catch {
+        return null;
+      }
+    },
+    // de5d9fe8: non-destructive recovery — clear the stuck input buffer (C-u, no
+    // Enter) so the queued nudge can land. Never submits anything. execFileSync ->
+    // execFileAsync: this runs on a timer tick and must not block the event loop.
+    clearInputBuffer: async (sessionName) => {
+      try {
+        await execFileAsync("tmux", clearInputBufferArgs(sessionName), { timeout: 2e3 });
+      } catch {
+      }
+    },
+    // Bug 1c870c78: async kill on the TTL timer — TmuxTransport.killAsync runs
+    // kill-session via execFileAsync. Fall back to sync kill for transports that
+    // don't implement killAsync (e.g. test mocks).
+    killSession: async (sessionName) => {
+      const t = getTransport();
+      if (typeof t.killAsync === "function") {
+        await t.killAsync(sessionName);
+      } else {
+        t.kill(sessionName);
+      }
     },
     hasActiveTasks: getClient ? async (agentId) => {
       const rows = await queryTaskRows({
@@ -701,11 +943,13 @@ function createIdleKillRealDeps(getClient, intercomAckWindowMs) {
 var AUTO_WAKE_COOLDOWN_MS = 5 * 60 * 1e3;
 var AUTO_WAKE_MAX_RETRIES = 3;
 var DEAD_SCOPE_SKIP_THRESHOLD = 10;
+var DISPATCH_PENDING_FRESH_MS = 90 * 1e3;
 var AUTO_WAKE_STATE_PATH = join(homedir(), ".exe-os", "session-cache", "auto-wake-state.json");
 var CRASH_LOOP_WINDOW_MS = 15 * 60 * 1e3;
 var CRASH_LOOP_THRESHOLD = 3;
 var BACKOFF_BASE_MS = 2 * 60 * 1e3;
 var BACKOFF_CAP_MS = 30 * 60 * 1e3;
+var AUTO_WAKE_MAX_SPAWNS_PER_TICK = 4;
 var CPU_PRESSURE_THRESHOLD = 80;
 var FREE_RAM_MIN_GB = 4;
 function loadAutoWakeState() {
@@ -772,6 +1016,26 @@ function _resetAutoWakeState() {
   } catch {
   }
 }
+var TERMINAL_LAUNCHER_FAILURE_GATE = "terminal_launcher_failure";
+function readTerminalFailureForAgent(agentId, scope, opts) {
+  const readerOpts = {
+    ...opts?.now != null ? { now: opts.now } : {},
+    ...opts?.baseDir ? { baseDir: opts.baseDir } : {}
+  };
+  const normalize = opts?.baseAgent ?? baseAgentName;
+  try {
+    const direct = readTerminalLauncherFailure(agentId, scope, readerOpts);
+    if (direct) return direct;
+    const base = normalize(agentId);
+    if (base && base !== agentId) {
+      const b = readTerminalLauncherFailure(base, scope, readerOpts);
+      if (b) return b;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 function checkAutoWakeGates(key, nowMs) {
   try {
     const blockWindowMs = parseInt(process.env.EXE_AUTOWAKE_BLOCK_WINDOW_MS ?? "", 10) || 15e3;
@@ -782,6 +1046,16 @@ function checkAutoWakeGates(key, nowMs) {
     }
   } catch {
   }
+  if (key !== "__global__") {
+    const sep = key.indexOf("::");
+    if (sep > 0) {
+      const agentId = key.slice(0, sep);
+      const scope = key.slice(sep + 2);
+      if (scope && readTerminalFailureForAgent(agentId, scope, { now: nowMs })) {
+        return TERMINAL_LAUNCHER_FAILURE_GATE;
+      }
+    }
+  }
   const loopCount = _autoWakeState.crashLoopCount[key] ?? 0;
   if (loopCount > 0) {
     const backoffMs = Math.min(BACKOFF_BASE_MS * Math.pow(2, loopCount - 1), BACKOFF_CAP_MS);
@@ -827,16 +1101,37 @@ async function readTaskDeliverable(getClient, taskId) {
     return null;
   }
 }
+async function annotateEnforcementNote(getClient, taskId, note) {
+  try {
+    const client = getClient();
+    const stamped = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${note}`;
+    await client.execute({
+      sql: `UPDATE tasks
+            SET enforcement_note = CASE
+              WHEN enforcement_note IS NULL OR enforcement_note = '' THEN ?
+              ELSE enforcement_note || char(10) || ?
+            END
+            WHERE id = ?`,
+      args: [stamped, stamped, taskId]
+    });
+  } catch {
+  }
+}
 async function markTaskBlockedAbandoned(getClient, taskId, reason) {
   try {
-    await updateTask({ taskId, status: "blocked", result: reason });
+    await updateTask({ taskId, status: "blocked", result: reason, preserveResultIfPresent: true });
   } catch {
     const client = getClient();
     await client.execute({
-      sql: `UPDATE tasks SET status = 'blocked', result = ?, updated_at = ? WHERE id = ?`,
+      sql: `UPDATE tasks
+            SET status = 'blocked',
+                result = CASE WHEN result IS NULL OR trim(result, char(32)||char(9)||char(10)||char(13)) = '' THEN ? ELSE result END,
+                updated_at = ?
+            WHERE id = ?`,
       args: [reason, (/* @__PURE__ */ new Date()).toISOString(), taskId]
     });
   }
+  await annotateEnforcementNote(getClient, taskId, reason);
 }
 function shouldAutoWake(input) {
   if (isCoordinatorName(input.agentId)) return false;
@@ -881,14 +1176,17 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
     process.stderr.write("[daemon-orch] list tmux sessions for orphan poll: " + (e instanceof Error ? e.message : String(e)) + "\n");
     return [];
   }
+  const normalizeAgentForWake = deps.baseAgent ?? baseAgentName;
   const liveAgentScopedCounts = /* @__PURE__ */ new Map();
   for (const session of liveSessions) {
     const agent = deps.parseAgentFromSession(session);
     if (agent) {
       const dashIdx = session.indexOf("-");
       const scope = dashIdx >= 0 ? session.slice(dashIdx + 1) : session;
-      const scopedKey = `${agent}::${scope}`;
-      liveAgentScopedCounts.set(scopedKey, (liveAgentScopedCounts.get(scopedKey) ?? 0) + 1);
+      for (const name of /* @__PURE__ */ new Set([agent, normalizeAgentForWake(agent)])) {
+        const scopedKey = `${name}::${scope}`;
+        liveAgentScopedCounts.set(scopedKey, (liveAgentScopedCounts.get(scopedKey) ?? 0) + 1);
+      }
     }
   }
   const coordinatorSessions = liveSessions.filter((s) => isExeSession(s));
@@ -900,7 +1198,6 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
     return [];
   }
   const coordinatorSet = new Set(coordinatorSessions);
-  const VALID_SESSION_SCOPE = /^[a-zA-Z0-9_]+$/;
   const agentTasks = /* @__PURE__ */ new Map();
   let deadScopeStateDirty = false;
   let registryForResolution = [];
@@ -925,10 +1222,11 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
       continue;
     }
     const rawScope = t.sessionScope;
+    const rawScopeText = rawScope == null ? "" : String(rawScope);
     const taskProject = t.projectName ?? null;
-    if (rawScope && !VALID_SESSION_SCOPE.test(rawScope)) {
+    if (rawScope && !isValidSessionScope(rawScope)) {
       process.stderr.write(
-        `[auto-wake] REPAIRING corrupted session_scope for ${t.agentId} task ${t.taskId}: "${rawScope.slice(0, 60)}"
+        `[auto-wake] REPAIRING corrupted session_scope for ${t.agentId} task ${t.taskId}: "${rawScopeText.slice(0, 60)}"
 `
       );
       const match = deps.reparentTask ? uniqueCoordinatorForProject(coordinatorSessions, getRegistryForResolution(), taskProject) : null;
@@ -1079,16 +1377,24 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
   }
   if (deadScopeStateDirty) saveAutoWakeState(_autoWakeState);
   const woken = [];
+  let spawnAttempts = 0;
   for (const [key, tasks] of agentTasks) {
     const agentId = key.split("::")[0];
     const sessionScope = tasks[0].sessionScope;
+    const scope = key.slice(agentId.length + 2);
+    const baseKey = `${normalizeAgentForWake(agentId)}::${scope}`;
+    const runningInstances = Math.max(
+      liveAgentScopedCounts.get(key) ?? 0,
+      liveAgentScopedCounts.get(baseKey) ?? 0
+    );
+    const hasRunningSession = liveAgentScopedCounts.has(key) || liveAgentScopedCounts.has(baseKey);
     if (!shouldAutoWake({
       agentId,
-      hasRunningSession: liveAgentScopedCounts.has(key),
+      hasRunningSession,
       lastSpawnMs: _autoWakeLastSpawn.get(key) ?? 0,
       nowMs,
       cooldownMs: AUTO_WAKE_COOLDOWN_MS,
-      runningInstances: liveAgentScopedCounts.get(key) ?? 0,
+      runningInstances,
       pendingTaskGroups: tasks.length
     })) {
       continue;
@@ -1118,24 +1424,52 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
       continue;
     }
     const agentGate = checkGate(key, nowMs);
-    if (agentGate) {
+    if (agentGate && agentGate !== TERMINAL_LAUNCHER_FAILURE_GATE) {
       process.stderr.write(`[auto-wake] AGENT GATE BLOCKED: ${agentId} \u2014 ${agentGate}
 `);
       continue;
     }
     const topTask = tasks[0];
+    if (deps.checkDispatchStatus) {
+      try {
+        const dispatch = deps.checkDispatchStatus(topTask.taskId);
+        if (dispatch.status === "pending" && dispatch.signal?.dispatchedAt) {
+          const ageMs = nowMs - new Date(dispatch.signal.dispatchedAt).getTime();
+          if (ageMs < DISPATCH_PENDING_FRESH_MS) {
+            process.stderr.write(
+              `[auto-wake] SKIP ${agentId} task ${topTask.taskId} \u2014 create_task dispatched ${Math.max(0, Math.round(ageMs / 1e3))}s ago (base session still booting); not double-spawning
+`
+            );
+            continue;
+          }
+        }
+      } catch (e) {
+        process.stderr.write(
+          "[auto-wake] dispatch-ack read failed (fail-open) for task " + topTask.taskId + ": " + (e instanceof Error ? e.message : String(e)) + "\n"
+        );
+      }
+    }
+    let terminalFailure = null;
+    if (deps.readTerminalFailure) {
+      try {
+        terminalFailure = deps.readTerminalFailure(agentId, scope);
+      } catch (e) {
+        terminalFailure = null;
+        process.stderr.write(
+          "[auto-wake] terminal-failure read failed (fail-open) for task " + topTask.taskId + ": " + (e instanceof Error ? e.message : String(e)) + "\n"
+        );
+      }
+    }
     const retries = _autoWakeTaskRetries.get(topTask.taskId) ?? 0;
-    if (retries >= AUTO_WAKE_MAX_RETRIES) {
+    if (retries >= AUTO_WAKE_MAX_RETRIES || terminalFailure) {
+      const reviewReason = terminalFailure ? `Terminal launcher failure (${terminalFailure.runtime}) \u2014 ${terminalFailure.reason}` : `Auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times \u2014 session ended after producing a deliverable. Needs manual review.`;
+      const abandonReason = terminalFailure ? `Terminal launcher failure (${terminalFailure.runtime}) \u2014 ${terminalFailure.reason}${terminalFailure.detail ? ` [${terminalFailure.detail}]` : ""}` : `Auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times \u2014 session ended with NO deliverable. Blocked for manual re-dispatch (not a completed review).`;
       let routed = "needs_review";
       try {
-        routed = await routeUnrecoverableTask(
-          deps,
-          topTask.taskId,
-          `Auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times \u2014 session ended after producing a deliverable. Needs manual review.`,
-          `Auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times \u2014 session ended with NO deliverable. Blocked for manual re-dispatch (not a completed review).`
-        );
+        routed = await routeUnrecoverableTask(deps, topTask.taskId, reviewReason, abandonReason);
         process.stderr.write(
-          `[auto-wake] ${agentId} task ${topTask.taskId} exceeded ${AUTO_WAKE_MAX_RETRIES} retries \u2014 marked ${routed}
+          terminalFailure ? `[auto-wake] ${agentId} task ${topTask.taskId} \u2014 terminal launcher failure, marked ${routed}: ${terminalFailure.reason}
+` : `[auto-wake] ${agentId} task ${topTask.taskId} exceeded ${AUTO_WAKE_MAX_RETRIES} retries \u2014 marked ${routed}
 `
         );
       } catch (e) {
@@ -1143,18 +1477,43 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
       }
       try {
         const attention = routed === "blocked" ? "needs re-dispatch (no deliverable)" : "needs review";
+        const cause = terminalFailure ? `launcher reported a terminal failure: ${terminalFailure.reason}` : `auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times. Session could not be recovered.`;
         await writeNotification({
           agentId,
           agentRole: "employee",
           event: "orphan_task",
           project: String(topTask.sessionScope ?? ""),
-          summary: `\u26A0\uFE0F Task ${topTask.taskId} for ${agentId} ${attention} \u2014 auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times. Session could not be recovered.`,
+          summary: `\u26A0\uFE0F Task ${topTask.taskId} for ${agentId} ${attention} \u2014 ${cause}`,
           sessionScope
         });
       } catch {
       }
       continue;
     }
+    if (spawnAttempts >= AUTO_WAKE_MAX_SPAWNS_PER_TICK) {
+      process.stderr.write(
+        `[auto-wake] TICK CAP: ${AUTO_WAKE_MAX_SPAWNS_PER_TICK} spawns already this tick \u2014 deferring ${agentId} task ${topTask.taskId} to next tick
+`
+      );
+      continue;
+    }
+    spawnAttempts++;
+    if (deps.acquireDispatchClaim) {
+      let claimed = true;
+      try {
+        claimed = deps.acquireDispatchClaim(topTask.taskId, agentId);
+      } catch {
+        claimed = true;
+      }
+      if (!claimed) {
+        spawnAttempts--;
+        process.stderr.write(
+          `[auto-wake] SKIP ${agentId} task ${topTask.taskId} \u2014 another dispatcher holds the spawn claim; not double-spawning
+`
+        );
+        continue;
+      }
+    }
     process.stderr.write(
       `[auto-wake] ${agentId} has ${tasks.length} pending task(s) but no session \u2014 spawning in ${sessionScope} (attempt ${retries + 1} for task ${topTask.taskId})
 `
@@ -1166,6 +1525,10 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
           `[auto-wake] Failed to spawn ${agentId}: ${result.error ?? "unknown"}
 `
         );
+        try {
+          deps.releaseDispatchClaim?.(topTask.taskId, agentId, "auto-wake spawn failed");
+        } catch {
+        }
         recordOrchestrationEventBestEffort({
           eventType: "auto_wake.spawn_failed",
           source: "daemon-orchestration.pollOrphanedTasks",
@@ -1200,6 +1563,10 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
         `[auto-wake] Error spawning ${agentId}: ${err instanceof Error ? err.message : String(err)}
 `
       );
+      try {
+        deps.releaseDispatchClaim?.(topTask.taskId, agentId, "auto-wake spawn error");
+      } catch {
+      }
       recordOrchestrationEventBestEffort({
         eventType: "auto_wake.spawn_error",
         source: "daemon-orchestration.pollOrphanedTasks",
@@ -1227,15 +1594,23 @@ var STUCK_TASK_GRACE_MS = 5 * 60 * 1e3;
 async function releaseStuckTasks(deps, nowMs = Date.now()) {
   let liveSessions;
   try {
-    liveSessions = deps.listTmuxSessions();
+    liveSessions = deps.listTmuxSessionsAsync ? await deps.listTmuxSessionsAsync() : deps.listTmuxSessions();
   } catch (e) {
     process.stderr.write("[daemon-orch] list tmux sessions for stuck tasks: " + (e instanceof Error ? e.message : String(e)) + "\n");
     return [];
   }
+  if (liveSessions.length === 0 && deps.tmuxSessionsVerified?.() === false) {
+    process.stderr.write("[stuck-release] Skipping in_progress reclaim: tmux session list was not verified (probe failed/timeout). Preserving tasks.\n");
+    return [];
+  }
+  const liveSessionSet = new Set(liveSessions);
   const liveAgents = /* @__PURE__ */ new Set();
+  const liveInstanceAgents = /* @__PURE__ */ new Set();
   for (const session of liveSessions) {
     const agent = deps.parseAgentFromSession(session);
     if (agent) liveAgents.add(agent);
+    const dash = session.indexOf("-");
+    if (dash > 0) liveInstanceAgents.add(session.slice(0, dash));
   }
   for (const session of liveSessions) {
     if (isExeSession(session)) {
@@ -1252,13 +1627,42 @@ async function releaseStuckTasks(deps, nowMs = Date.now()) {
   }
   const released = [];
   const STALE_TASK_ESCALATION_MS = 60 * 60 * 1e3;
+  const BUSY_DEFER_CAP_MS = LEASE_MINUTES * 60 * 1e3;
+  const normalizeAgent = deps.baseAgent ?? baseAgentName;
+  const paneBusyCache = /* @__PURE__ */ new Map();
+  const claimedPaneBusy = async (session) => {
+    const cached = paneBusyCache.get(session);
+    if (cached !== void 0) return cached;
+    let busy = false;
+    try {
+      busy = deps.isClaimedPaneBusy ? await deps.isClaimedPaneBusy(session) : false;
+    } catch {
+      busy = false;
+    }
+    paneBusyCache.set(session, busy);
+    return busy;
+  };
   for (const t of tasks) {
     const updatedMs = new Date(t.updatedAt).getTime();
     if (isNaN(updatedMs)) continue;
     const ageMinutes = Math.round((nowMs - updatedMs) / 6e4);
-    if (!liveAgents.has(t.agentId)) {
+    const base = normalizeAgent(t.agentId);
+    const isInstanceQualified = base !== t.agentId;
+    const claimedAlive = t.claimedSession ? liveSessionSet.has(t.claimedSession) : false;
+    const agentAlive = isInstanceQualified ? claimedAlive || liveInstanceAgents.has(t.agentId) : claimedAlive || liveAgents.has(t.agentId) || liveAgents.has(base) || liveInstanceAgents.has(t.agentId);
+    if (!agentAlive) {
       const leaseExpired = isLeaseExpired(t.leaseExpiresAt, nowMs);
       if (!leaseExpired && nowMs - updatedMs < STUCK_TASK_GRACE_MS) continue;
+      const busyDeferExhausted = leaseExpired || nowMs - updatedMs > BUSY_DEFER_CAP_MS;
+      if (deps.isClaimedPaneBusy && t.claimedSession && !busyDeferExhausted) {
+        if (await claimedPaneBusy(t.claimedSession)) {
+          process.stderr.write(
+            `[stuck-release] Task ${t.taskId} (${t.agentId}) \u2014 claimed pane ${t.claimedSession} is BUSY; deferring reclaim (bounded by lease/${Math.round(BUSY_DEFER_CAP_MS / 6e4)}m)
+`
+          );
+          continue;
+        }
+      }
       const reviewReason = leaseExpired ? `Auto-closed: agent "${t.agentId}" task lease expired (${t.leaseExpiresAt}); deliverable present. Needs manual review.` : `Auto-closed: agent "${t.agentId}" session ended after producing a deliverable (in_progress for ${ageMinutes}m, no live session). Needs manual review.`;
       const abandonReason = leaseExpired ? `Abandoned: agent "${t.agentId}" task lease expired (${t.leaseExpiresAt}) with NO deliverable. Blocked for manual re-dispatch.` : `Abandoned: agent "${t.agentId}" session ended with NO deliverable (in_progress for ${ageMinutes}m, no live session). Blocked for manual re-dispatch.`;
       try {
@@ -1312,15 +1716,51 @@ async function releaseStuckTasks(deps, nowMs = Date.now()) {
   return released;
 }
 function createStuckTaskRealDeps(getClient) {
+  let lastTmuxListVerified = false;
+  const listSync = () => {
+    try {
+      const socket = process.env.EXE_TMUX_SOCKET;
+      const socketArgs = socket ? ["-L", socket] : [];
+      const out = execFileSync("tmux", [...socketArgs, "list-sessions", "-F", "#{session_name}"], {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 3e3
+      });
+      lastTmuxListVerified = true;
+      return out.trim().split("\n").filter(Boolean);
+    } catch {
+      lastTmuxListVerified = false;
+      return [];
+    }
+  };
   return {
-    listTmuxSessions: () => listTmuxSessions(),
+    // Retained as a fallback; releaseStuckTasks prefers listTmuxSessionsAsync.
+    listTmuxSessions: listSync,
+    // Blocker 6: async list-sessions so the stuck-release timer never blocks the
+    // event loop on a sync execFileSync("tmux").
+    listTmuxSessionsAsync: async () => {
+      try {
+        const socket = process.env.EXE_TMUX_SOCKET;
+        const socketArgs = socket ? ["-L", socket] : [];
+        const { stdout } = await execFileAsync("tmux", [...socketArgs, "list-sessions", "-F", "#{session_name}"], {
+          encoding: "utf8",
+          timeout: 3e3
+        });
+        lastTmuxListVerified = true;
+        return (stdout ?? "").trim().split("\n").filter(Boolean);
+      } catch {
+        lastTmuxListVerified = false;
+        return [];
+      }
+    },
+    tmuxSessionsVerified: () => lastTmuxListVerified,
     queryInProgressTasks: async () => {
       const { loadDeviceId } = await import("./lib/license.js");
       const deviceId = loadDeviceId();
       const client = getClient();
       const nowIso = (/* @__PURE__ */ new Date()).toISOString();
       const rows = await client.execute({
-        sql: `SELECT id, assigned_to, session_scope, updated_at, lease_expires_at
+        sql: `SELECT id, assigned_to, session_scope, updated_at, lease_expires_at, assigned_tmux
               FROM tasks
               WHERE status = 'in_progress'
                 AND (device_id = ? OR device_id IS NULL OR lease_expires_at < ?)
@@ -1333,19 +1773,26 @@ function createStuckTaskRealDeps(getClient) {
         agentId: String(r.assigned_to),
         sessionScope: r.session_scope ? String(r.session_scope) : null,
         updatedAt: String(r.updated_at),
-        leaseExpiresAt: r.lease_expires_at ? String(r.lease_expires_at) : null
+        leaseExpiresAt: r.lease_expires_at ? String(r.lease_expires_at) : null,
+        // Blocker 1: the exact session that holds the claim.
+        claimedSession: r.assigned_tmux ? String(r.assigned_tmux) : null
       }));
     },
     markTaskNeedsReview: async (taskId, reason) => {
       try {
-        await updateTask({ taskId, status: "needs_review", result: reason });
+        await updateTask({ taskId, status: "needs_review", result: reason, preserveResultIfPresent: true });
       } catch {
         const client = getClient();
         await client.execute({
-          sql: `UPDATE tasks SET status = 'needs_review', result = ?, updated_at = ? WHERE id = ?`,
+          sql: `UPDATE tasks
+                SET status = 'needs_review',
+                    result = CASE WHEN result IS NULL OR trim(result, char(32)||char(9)||char(10)||char(13)) = '' THEN ? ELSE result END,
+                    updated_at = ?
+                WHERE id = ?`,
           args: [reason, (/* @__PURE__ */ new Date()).toISOString(), taskId]
         });
       }
+      await annotateEnforcementNote(getClient, taskId, reason);
     },
     getTaskDeliverable: (taskId) => readTaskDeliverable(getClient, taskId),
     markTaskAbandoned: (taskId, reason) => markTaskBlockedAbandoned(getClient, taskId, reason),
@@ -1354,6 +1801,22 @@ function createStuckTaskRealDeps(getClient) {
       const agentPart = sessionName.split("-")[0];
       return baseAgentName(agentPart);
     },
+    baseAgent: (agentId) => baseAgentName(agentId),
+    isClaimedPaneBusy: async (claimedSession) => {
+      if (!claimedSession) return false;
+      try {
+        const socket = process.env.EXE_TMUX_SOCKET;
+        const socketArgs = socket ? ["-L", socket] : [];
+        const { stdout } = await execFileAsync(
+          "tmux",
+          [...socketArgs, "capture-pane", "-t", claimedSession, "-p", "-S", "-12"],
+          { encoding: "utf8", timeout: 3e3 }
+        );
+        return isPaneBusy(stdout ?? "");
+      } catch {
+        return false;
+      }
+    },
     notifyOrphan: async (taskId, agentId, sessionScope) => {
       await writeNotification({
         agentId,
@@ -1667,9 +2130,27 @@ function createAutoWakeRealDeps(getClient, projectDir, listTmuxSessionsAsync) {
         projectName: r.project_name ? String(r.project_name) : null
       }));
     },
+    // DEFECT 1 (dup-spawn): honor create_task's fresh dispatch signal so auto-wake
+    // never double-spawns a task whose base session is still booting.
+    checkDispatchStatus: (taskId) => checkDispatchStatus(taskId),
+    // Bug b2b1dc31: honor a launcher's terminal-failure marker (both key forms +
+    // TTL + fail open) so a permanently-doomed config is routed to blocked with
+    // the launcher's real reason instead of respawned into the misleading block.
+    readTerminalFailure: (agentId, scope) => readTerminalFailureForAgent(agentId, scope),
+    // Round-3: the real task-keyed spawn claim, so auto-wake contends on the SAME
+    // atomic lock as create_task / nudge / resume — one spawner per task.
+    acquireDispatchClaim: (taskId, assignedTo) => tryAcquireDispatchClaim(taskId, assignedTo),
+    releaseDispatchClaim: (taskId, assignedTo, reason) => releaseDispatchClaim(taskId, assignedTo, reason),
     // C1: registry lookup + re-parent for dead-scope escalation.
     listRegisteredSessions: () => listSessions(),
     reparentTask: async (taskId, newSessionScope) => {
+      if (!isValidSessionScope(newSessionScope)) {
+        process.stderr.write(
+          `[auto-wake] ERROR: refusing to re-parent task ${taskId} to corrupted scope ${JSON.stringify(String(newSessionScope).slice(0, 60))} (bug 4941abba)
+`
+        );
+        throw new Error(`invalid session_scope for re-parent: not a valid session token`);
+      }
       const client = getClient();
       await client.execute({
         sql: `UPDATE tasks SET session_scope = ?, updated_at = ? WHERE id = ?`,
@@ -1694,14 +2175,19 @@ function createAutoWakeRealDeps(getClient, projectDir, listTmuxSessionsAsync) {
     },
     markTaskNeedsReview: async (taskId, reason) => {
       try {
-        await updateTask({ taskId, status: "needs_review", result: reason });
+        await updateTask({ taskId, status: "needs_review", result: reason, preserveResultIfPresent: true });
       } catch {
         const client = getClient();
         await client.execute({
-          sql: `UPDATE tasks SET status = 'needs_review', result = ?, updated_at = ? WHERE id = ?`,
+          sql: `UPDATE tasks
+                SET status = 'needs_review',
+                    result = CASE WHEN result IS NULL OR trim(result, char(32)||char(9)||char(10)||char(13)) = '' THEN ? ELSE result END,
+                    updated_at = ?
+                WHERE id = ?`,
           args: [reason, (/* @__PURE__ */ new Date()).toISOString(), taskId]
         });
       }
+      await annotateEnforcementNote(getClient, taskId, reason);
     },
     getTaskDeliverable: (taskId) => readTaskDeliverable(getClient, taskId),
     markTaskAbandoned: (taskId, reason) => markTaskBlockedAbandoned(getClient, taskId, reason),
@@ -1709,7 +2195,8 @@ function createAutoWakeRealDeps(getClient, projectDir, listTmuxSessionsAsync) {
       if (!sessionName.includes("-")) return null;
       const agentPart = sessionName.split("-")[0];
       return baseAgentName(agentPart);
-    }
+    },
+    baseAgent: (agentId) => baseAgentName(agentId)
   };
 }
 var COO_CONTEXT_THRESHOLD_PCT = Number(process.env.EXE_COO_CONTEXT_THRESHOLD_PCT) || 85;
@@ -2355,7 +2842,7 @@ async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
         });
         continue;
       }
-      if (deps.isWorktreeDirty(wt.path)) {
+      if (await deps.isWorktreeDirty(wt.path)) {
         const ageH2 = Math.round(ageMs / 36e5);
         if (ageMs >= WORKTREE_DIRTY_MAX_AGE_MS && deps.archiveDirtyWorktree) {
           process.stderr.write(
@@ -2456,13 +2943,21 @@ async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
 }
 async function createWorktreeReaperRealDeps() {
   const { getPaneCwdAsync } = await import("./lib/tmux-status.js");
-  const { getGitRoot, isWorktreeDirty: isDirty } = await import("./worktree-GVF2I5FP.js");
+  const { getGitRootAsync, isWorktreeDirtyAsync } = await import("./worktree-LL62PLQB.js");
   const { statSync: statSync3 } = await import("fs");
   const { basename: basename2 } = await import("path");
   const { promisify: promisify2 } = await import("util");
   const { execFile: execFileCb } = await import("child_process");
   const execFileAsync2 = promisify2(execFileCb);
-  const sessions = listTmuxSessions();
+  let sessions = [];
+  try {
+    const { stdout } = await execFileAsync2("tmux", ["list-sessions", "-F", "#{session_name}"], {
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    sessions = String(stdout ?? "").split("\n").map((s) => s.trim()).filter(Boolean);
+  } catch {
+  }
   const cwdMap = /* @__PURE__ */ new Map();
   const cwdPromises = sessions.map(async (s) => {
     try {
@@ -2472,9 +2967,15 @@ async function createWorktreeReaperRealDeps() {
     }
   });
   await Promise.all(cwdPromises);
+  const gitRootCache = /* @__PURE__ */ new Map();
+  const rootPromises = [...cwdMap.values()].map(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 cwd of cwdMap.values()) {
-    const root = getGitRoot(cwd);
+  for (const root of gitRootCache.values()) {
     if (root) repoRoots.add(root);
   }
   const worktreeCache = /* @__PURE__ */ new Map();
@@ -2504,7 +3005,7 @@ async function createWorktreeReaperRealDeps() {
     listTmuxSessions: () => sessions,
     getPaneCwd: (s) => cwdMap.get(s),
     listWorktrees: (repoRoot) => worktreeCache.get(repoRoot) ?? [],
-    isWorktreeDirty: (wtPath) => isDirty(wtPath),
+    isWorktreeDirty: (wtPath) => isWorktreeDirtyAsync(wtPath),
     getDirMtimeMs: (dirPath) => {
       try {
         return statSync3(dirPath).mtimeMs;
@@ -2582,7 +3083,9 @@ async function createWorktreeReaperRealDeps() {
       if (!dirName) return null;
       return baseAgentName(dirName);
     },
-    getGitRoot: (dir) => getGitRoot(dir),
+    // 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,
     archiveDirtyWorktree: async (_repoRoot, wtPath, _branch, agentName) => {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
       const quarantineBranch = `quarantine/${agentName}-${timestamp}`;
@@ -2671,7 +3174,7 @@ async function gcStaleCheckpoints() {
 }
 async function pollTaskGroupBarriers() {
   try {
-    const { checkAndFireBarriers } = await import("./tasks-crud-UGK5A25L.js");
+    const { checkAndFireBarriers } = await import("./tasks-crud-HBDKE6C5.js");
     const firedGroupIds = await checkAndFireBarriers();
     if (firedGroupIds.length === 0) return 0;
     const { getClient } = await import("./lib/database.js");
@@ -2698,10 +3201,10 @@ async function pollTaskGroupBarriers() {
         if (sessionScope) {
           try {
             if (isCoordinatorName(coordinator) && isExeSession(sessionScope)) {
-              await sendIntercomAsync(sessionScope, { force: true, reason: "completion" });
+              await sendIntercomAsync(sessionScope, { force: true, reason: "completion", callerSessionScope: sessionScope });
             } else {
               const { employeeSessionName } = await import("./lib/tmux-routing.js");
-              await sendIntercomAsync(employeeSessionName(coordinator, sessionScope), { force: true, reason: "completion" });
+              await sendIntercomAsync(employeeSessionName(coordinator, sessionScope), { force: true, reason: "completion", callerSessionScope: sessionScope });
             }
           } catch {
           }
@@ -2748,6 +3251,9 @@ export {
   shouldNudgeEmployee,
   shouldKillSession,
   classifyTtlKillReason,
+  isUnreachableActiveTaskSession,
+  WEDGE_RECOVERY_TICKS_REQUIRED,
+  clearInputBufferArgs,
   shouldKillIdleSession,
   pollIdleEmployees,
   checkSessionTTL,
@@ -2766,10 +3272,14 @@ export {
   AUTO_WAKE_COOLDOWN_MS,
   AUTO_WAKE_MAX_RETRIES,
   DEAD_SCOPE_SKIP_THRESHOLD,
+  DISPATCH_PENDING_FRESH_MS,
   CRASH_LOOP_WINDOW_MS,
   CRASH_LOOP_THRESHOLD,
+  AUTO_WAKE_MAX_SPAWNS_PER_TICK,
   pruneAutoWakeState,
   _resetAutoWakeState,
+  TERMINAL_LAUNCHER_FAILURE_GATE,
+  readTerminalFailureForAgent,
   checkAutoWakeGates,
   shouldAutoWake,
   pollOrphanedTasks,