@askexenow/exe-os 0.9.279 → 0.9.281

package/dist/chunk-4T2F5SJA.js

@@ -0,0 +1,2078 @@
+import {
+  recordSessionKill
+} from "./chunk-6MDKSLYM.js";
+import {
+  updateTask
+} from "./chunk-J2PDHWJV.js";
+import {
+  ensureEmployeeAsync,
+  extractRootExe,
+  getSessionState,
+  isExeSession,
+  queryTaskRows,
+  sendIntercomAsync,
+  sessionScopeFilter,
+  strictSessionScopeFilter,
+  writeNotification
+} from "./chunk-IPZ4JWBG.js";
+import {
+  queueIntercom
+} from "./chunk-4FVVJ7ME.js";
+import {
+  listSessions
+} from "./chunk-FGMF5K2G.js";
+import {
+  getTransport
+} from "./chunk-MVW62NIZ.js";
+import {
+  listTmuxSessions,
+  parseContextPercentage
+} from "./chunk-SSTLTIF3.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-X46O77S4.js";
+import {
+  getAgentRuntime
+} from "./chunk-PMVOUPTY.js";
+import {
+  baseAgentName,
+  getCoordinatorName,
+  isCoordinatorName,
+  shouldAutoInstance
+} from "./chunk-ZJP3ZONM.js";
+import {
+  loadConfigSync
+} from "./chunk-T3B5RK4H.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 { homedir, loadavg, freemem, cpus as osCpus, platform } from "os";
+import { join } from "path";
+
+// src/lib/agent-signals.ts
+import { existsSync, openSync, closeSync, readSync, statSync } from "fs";
+import os from "os";
+import path from "path";
+var CONSERVATIVE_ON_ERROR = true;
+var INTERCOM_ACK_TAIL_BYTES = 64 * 1024;
+function readTailUtf8(filePath, maxBytes) {
+  const stat = statSync(filePath);
+  const start = Math.max(0, stat.size - maxBytes);
+  const length = stat.size - start;
+  const fd = openSync(filePath, "r");
+  try {
+    const buf = Buffer.alloc(length);
+    readSync(fd, buf, 0, length, start);
+    return buf.toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+async function hasOpenTasks(client, agentId, sessionScope) {
+  try {
+    const scope = sessionScopeFilter(sessionScope);
+    const result = await client.execute({
+      sql: `SELECT 1 FROM tasks
+            WHERE assigned_to = ? AND status IN ('open', 'in_progress', 'blocked')${scope.sql}
+            LIMIT 1`,
+      args: [agentId, ...scope.args]
+    });
+    return result.rows.length > 0;
+  } catch {
+    return CONSERVATIVE_ON_ERROR;
+  }
+}
+async function hasNeedsReview(client, agentId, sessionScope) {
+  try {
+    const scope = sessionScopeFilter(sessionScope);
+    const result = await client.execute({
+      sql: `SELECT 1 FROM tasks
+            WHERE assigned_to = ? AND status = 'needs_review'${scope.sql}
+            LIMIT 1`,
+      args: [agentId, ...scope.args]
+    });
+    return result.rows.length > 0;
+  } catch {
+    return CONSERVATIVE_ON_ERROR;
+  }
+}
+async function hasUnreadInbox(client, agentId, sessionScope) {
+  try {
+    const scope = strictSessionScopeFilter(sessionScope);
+    const result = await client.execute({
+      sql: `SELECT 1 FROM messages
+            WHERE target_agent = ? AND status = 'pending'
+            ${scope.sql}
+            LIMIT 1`,
+      args: [agentId, ...scope.args]
+    });
+    return result.rows.length > 0;
+  } catch {
+    return CONSERVATIVE_ON_ERROR;
+  }
+}
+function hadRecentIntercomAck(sessionName, windowMs, nowMs = Date.now(), intercomLog = path.join(os.homedir(), ".exe-os", "intercom.log")) {
+  if (!existsSync(intercomLog)) return false;
+  try {
+    const raw = readTailUtf8(intercomLog, INTERCOM_ACK_TAIL_BYTES);
+    const lines = raw.split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i];
+      if (!line || !line.includes(sessionName)) continue;
+      const tsMatch = line.match(/^(\d{4}-\d{2}-\d{2}T[\d:.]+Z)/);
+      if (!tsMatch) continue;
+      const ts = Date.parse(tsMatch[1]);
+      if (!Number.isFinite(ts)) continue;
+      if (nowMs - ts <= windowMs) return true;
+      return false;
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function collectAgentSignals(client, agentId, sessionName, intercomAckWindowMs, nowMs = Date.now()) {
+  const coordinatorScope = extractRootExe(sessionName) ?? null;
+  const [open, review, inbox] = await Promise.all([
+    hasOpenTasks(client, agentId, coordinatorScope),
+    hasNeedsReview(client, agentId, coordinatorScope),
+    hasUnreadInbox(client, agentId, coordinatorScope)
+  ]);
+  return {
+    hasOpenTasks: open,
+    hasNeedsReview: review,
+    hasUnreadInbox: inbox,
+    hadRecentIntercomAck: hadRecentIntercomAck(sessionName, intercomAckWindowMs, nowMs)
+  };
+}
+
+// src/lib/daemon-orchestration.ts
+var cpuCount = () => osCpus().length;
+function getAvailableMemoryGB() {
+  if (platform() === "darwin") {
+    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;
+    } catch {
+      return freemem() / 1024 ** 3;
+    }
+  }
+  return freemem() / 1024 ** 3;
+}
+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 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) {
+  if (sessionState !== "idle") return false;
+  if (!hasOpenTasks2) return false;
+  if (nowMs - lastNudgeMs < dedupMs) return false;
+  return true;
+}
+function shouldKillSession(ageHours, contextPct) {
+  return classifyTtlKillReason(ageHours, contextPct) !== null;
+}
+function classifyTtlKillReason(ageHours, contextPct) {
+  if (ageHours > SESSION_TTL_HOURS) return "ttl_age";
+  if (contextPct !== null && contextPct > SESSION_CONTEXT_THRESHOLD_PCT) return "ttl_context";
+  return null;
+}
+function shouldKillIdleSession(input) {
+  if (!input.enabled) return false;
+  if (isExeSession(input.sessionName)) return false;
+  if (input.state !== "idle" && input.state !== "no_claude") return false;
+  if (input.signals.hasOpenTasks) return false;
+  if (input.signals.hasNeedsReview) return false;
+  if (input.signals.hasUnreadInbox) return false;
+  if (input.signals.hadRecentIntercomAck) return false;
+  if (input.idleTicks < input.ticksRequired) return false;
+  return true;
+}
+async function pollIdleEmployees(deps, lastNudge) {
+  const registered = deps.listRegisteredSessions().filter(
+    (s) => !isCoordinatorName(s.agentId)
+  );
+  if (registered.length === 0) return [];
+  let liveSessions;
+  try {
+    liveSessions = new Set(deps.listTmuxSessions());
+  } catch (e) {
+    process.stderr.write("[daemon-orch] list tmux sessions for idle nudge: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    return [];
+  }
+  const nudged = [];
+  const now = Date.now();
+  for (const entry of registered) {
+    if (!liveSessions.has(entry.windowName)) continue;
+    const state = deps.getSessionState(entry.windowName);
+    const lastMs = lastNudge.get(entry.windowName) ?? 0;
+    if (state !== "idle") continue;
+    if (now - lastMs < IDLE_NUDGE_DEDUP_MS) continue;
+    const employeeScope = entry.windowName.includes("-") ? entry.windowName.slice(entry.windowName.indexOf("-") + 1) : null;
+    const task = await deps.queryOpenTask(entry.agentId, employeeScope);
+    if (!task) continue;
+    if (shouldNudgeEmployee(state, true, lastMs, now, IDLE_NUDGE_DEDUP_MS)) {
+      await deps.sendIntercom(entry.windowName);
+      lastNudge.set(entry.windowName, now);
+      nudged.push(entry.windowName);
+    }
+  }
+  return nudged;
+}
+async function checkSessionTTL(deps) {
+  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());
+  } 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 (isCoordinatorName(entry.agentId) || isExeSession(entry.windowName)) continue;
+    const createdEpoch = deps.getSessionCreatedEpoch(entry.windowName);
+    if (createdEpoch === null) continue;
+    const ageHours = (Date.now() / 1e3 - createdEpoch) / 3600;
+    const contextPct = deps.parseContextPercentage(entry.windowName);
+    const killReason = classifyTtlKillReason(ageHours, contextPct);
+    if (killReason !== null) {
+      const isContextFull = contextPct !== null && contextPct > 85;
+      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
+`
+            );
+            continue;
+          }
+        } catch {
+          process.stderr.write(
+            `[exed] Session TTL: SKIPPING ${entry.windowName} \u2014 hasActiveTasks query failed (conservative)
+`
+          );
+          continue;
+        }
+      }
+      if (isContextFull) {
+        process.stderr.write(
+          `[exed] Session TTL: context-full override for ${entry.windowName} (${contextPct}% used) \u2014 killing despite active tasks
+`
+        );
+      }
+      process.stderr.write(
+        `[exed] Session TTL: killing ${entry.windowName} (age=${ageHours.toFixed(1)}h, context=${contextPct}%, reason=${killReason})
+`
+      );
+      deps.recordKill?.({
+        sessionName: entry.windowName,
+        agentId: entry.agentId,
+        reason: killReason
+      });
+      recordOrchestrationEventBestEffort({
+        eventType: killReason === "ttl_age" ? "session.ttl_kill" : "session.context_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 }
+      });
+      deps.killSession(entry.windowName);
+      killed.push(entry.windowName);
+    }
+  }
+  return killed;
+}
+async function pollIdleKill(deps, idleTickCounts, opts) {
+  if (!opts.enabled) return [];
+  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());
+  } catch (e) {
+    process.stderr.write("[daemon-orch] list tmux sessions for idle kill: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    return [];
+  }
+  const killed = [];
+  for (const entry of registered) {
+    if (!liveSessions.has(entry.windowName)) {
+      idleTickCounts.delete(entry.windowName);
+      continue;
+    }
+    const state = deps.getSessionState(entry.windowName);
+    if (state !== "idle" && state !== "no_claude") {
+      idleTickCounts.delete(entry.windowName);
+      continue;
+    }
+    const signals = await deps.collectSignals(entry.agentId, entry.windowName);
+    if (signals.hasOpenTasks) {
+      const instanceName = entry.windowName.split("-")[0] ?? entry.agentId;
+      if (instanceName !== entry.agentId) {
+        try {
+          const markerPath = join(
+            homedir(),
+            ".exe-os",
+            "session-cache",
+            `current-task-${instanceName}.json`
+          );
+          if (!existsSync2(markerPath)) {
+            signals.hasOpenTasks = false;
+          }
+        } catch {
+        }
+      }
+    }
+    if (entry.registeredAt) {
+      const ageMs = Date.now() - new Date(entry.registeredAt).getTime();
+      if (ageMs < 5 * 60 * 1e3) {
+        idleTickCounts.delete(entry.windowName);
+        continue;
+      }
+    }
+    if (signals.hasOpenTasks || signals.hasNeedsReview || signals.hasUnreadInbox || signals.hadRecentIntercomAck) {
+      idleTickCounts.delete(entry.windowName);
+      continue;
+    }
+    const prevTicks = idleTickCounts.get(entry.windowName) ?? 0;
+    const nextTicks = prevTicks + 1;
+    const shouldKill = shouldKillIdleSession({
+      sessionName: entry.windowName,
+      state,
+      signals,
+      idleTicks: nextTicks,
+      ticksRequired: opts.ticksRequired,
+      enabled: opts.enabled
+    });
+    const warningThreshold = Math.max(1, Math.floor(opts.ticksRequired * 0.7));
+    if (nextTicks === warningThreshold && !shouldKill) {
+      try {
+        const { execFileSync: warnExec } = await import("child_process");
+        const shutdownMsg = [
+          "SHUTDOWN WARNING: Your session will be terminated in ~90 seconds due to inactivity.",
+          "All your tasks are complete. Before shutdown:",
+          "1. store_memory() any important decisions, discoveries, or context from this session",
+          "2. If you learned anything non-obvious, commit it to memory for future sessions",
+          "3. If you have in-progress thoughts or plans, checkpoint them now",
+          "This is your last chance to persist state. After shutdown, this context is lost."
+        ].join(" ");
+        warnExec("tmux", ["send-keys", "-t", entry.windowName, "-l", shutdownMsg], { timeout: 2e3 });
+        warnExec("tmux", ["send-keys", "-t", entry.windowName, "Enter"], { timeout: 1e3 });
+        process.stderr.write(`[exed] Idle wind-down warning sent to ${entry.windowName} (tick ${nextTicks}/${opts.ticksRequired})
+`);
+      } catch {
+      }
+    }
+    if (shouldKill) {
+      process.stderr.write(
+        `[exed] Idle kill: ${entry.windowName} (agentId=${entry.agentId}, ticks=${nextTicks})
+`
+      );
+      deps.recordKill?.({
+        sessionName: entry.windowName,
+        agentId: entry.agentId,
+        reason: "idle",
+        ticksIdle: nextTicks
+      });
+      recordOrchestrationEventBestEffort({
+        eventType: "session.idle_kill",
+        source: "daemon-orchestration.pollIdleKill",
+        agentId: entry.agentId,
+        tmuxSession: entry.windowName,
+        sessionScope: entry.windowName.includes("-") ? entry.windowName.slice(entry.windowName.indexOf("-") + 1) : null,
+        payload: { ticksIdle: nextTicks }
+      });
+      deps.killSession(entry.windowName);
+      try {
+        const { execFileSync: verifyExec } = await import("child_process");
+        verifyExec("tmux", ["has-session", "-t", entry.windowName], { timeout: 2e3 });
+        process.stderr.write(
+          `[exed] Idle kill FAILED for ${entry.windowName} \u2014 session still alive, retrying with force
+`
+        );
+        verifyExec("tmux", ["kill-session", "-t", entry.windowName], { timeout: 3e3 });
+      } catch {
+      }
+      killed.push(entry.windowName);
+      idleTickCounts.delete(entry.windowName);
+    } else {
+      idleTickCounts.set(entry.windowName, nextTicks);
+    }
+  }
+  return killed;
+}
+var REVIEW_NUDGE_COOLDOWN_MS = 3e5;
+async function pollReviewNudge(deps, state) {
+  let sessions;
+  try {
+    sessions = deps.listTmuxSessions().filter((s) => isExeSession(s));
+  } catch (e) {
+    process.stderr.write("[daemon-orch] list tmux sessions for review nudge: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    return [];
+  }
+  if (sessions.length === 0) return [];
+  const nudged = [];
+  const now = Date.now();
+  for (const exeSession of sessions) {
+    const prev = state.lastNudge.get(exeSession);
+    if (prev && now - prev.at < REVIEW_NUDGE_COOLDOWN_MS) continue;
+    const sessionState = deps.getSessionState(exeSession);
+    if (sessionState !== "idle") continue;
+    let count;
+    try {
+      count = await deps.countReviewsForScope(exeSession);
+    } catch (e) {
+      process.stderr.write("[daemon-orch] count reviews for scope: " + (e instanceof Error ? e.message : String(e)) + "\n");
+      continue;
+    }
+    if (count === 0) continue;
+    if (prev && prev.count === count) continue;
+    try {
+      deps.sendNudge(exeSession);
+      state.lastNudge.set(exeSession, { at: now, count });
+      nudged.push(exeSession);
+    } catch (e) {
+      process.stderr.write("[daemon-orch] send review nudge: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    }
+  }
+  if (nudged.length > 0 && deps.persistState) {
+    try {
+      deps.persistState(state);
+    } catch {
+    }
+  }
+  return nudged;
+}
+var NUDGE_STATE_PATH = join(homedir(), ".exe-os", "review-nudge-state.json");
+function loadNudgeState() {
+  const state = { lastNudge: /* @__PURE__ */ new Map() };
+  try {
+    if (!existsSync2(NUDGE_STATE_PATH)) return state;
+    const raw = JSON.parse(readFileSync(NUDGE_STATE_PATH, "utf8"));
+    if (Array.isArray(raw)) {
+      for (const [key, val] of raw) {
+        if (key && typeof val?.at === "number" && typeof val?.count === "number") {
+          state.lastNudge.set(key, val);
+        }
+      }
+    }
+  } catch {
+  }
+  return state;
+}
+function saveNudgeState(state) {
+  const entries = Array.from(state.lastNudge.entries());
+  writeFileSync(NUDGE_STATE_PATH, JSON.stringify(entries), "utf8");
+}
+function createReviewNudgeRealDeps(_getClient) {
+  return {
+    listTmuxSessions: () => listTmuxSessions(),
+    getSessionState: (sessionName) => getSessionState(sessionName),
+    countReviewsForScope: async (sessionScope) => {
+      const rows = await queryTaskRows({
+        status: "needs_review",
+        columns: "COUNT(*) as cnt",
+        sessionScope,
+        projectName: null,
+        limit: 1,
+        orderBy: "1"
+      });
+      return Number(rows[0]?.cnt ?? 0);
+    },
+    sendNudge: (sessionName) => {
+      queueIntercom(sessionName, "review nudge: pending reviews", "completion");
+    },
+    persistState: saveNudgeState
+  };
+}
+function createIdleNudgeRealDeps(_getClient) {
+  return {
+    listRegisteredSessions: () => listSessions(),
+    listTmuxSessions: () => listTmuxSessions(),
+    getSessionState: (sessionName) => getSessionState(sessionName),
+    queryOpenTask: async (agentId, sessionScope) => {
+      const rows = await queryTaskRows({
+        assignedTo: agentId,
+        status: ["open", "in_progress"],
+        columns: "id, title, priority",
+        sessionScope: sessionScope ?? null,
+        projectName: null,
+        orderBy: "CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 ELSE 2 END",
+        limit: 1
+      });
+      if (rows.length === 0) return null;
+      return rows[0];
+    },
+    sendIntercom: (sessionName) => sendIntercomAsync(sessionName),
+    killSession: (sessionName) => {
+      getTransport().kill(sessionName);
+    },
+    getAgentRuntime: (agentId) => {
+      try {
+        return getAgentRuntime(agentId).runtime;
+      } catch {
+        return "claude";
+      }
+    }
+  };
+}
+function createSessionTTLRealDeps(getClient) {
+  return {
+    listRegisteredSessions: () => listSessions(),
+    listTmuxSessions: () => listTmuxSessions(),
+    getSessionCreatedEpoch: (sessionName) => {
+      try {
+        const sessions = listSessions();
+        const entry = sessions.find((s) => s.windowName === sessionName);
+        if (entry?.registeredAt) {
+          const epoch = new Date(entry.registeredAt).getTime() / 1e3;
+          if (!isNaN(epoch)) return epoch;
+        }
+      } catch {
+      }
+      try {
+        const out = execFileSync(
+          "tmux",
+          ["display-message", "-t", sessionName, "-p", "#{session_created}"],
+          { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 3e3 }
+        ).trim();
+        const epoch = parseInt(out, 10);
+        return isNaN(epoch) ? null : epoch;
+      } catch {
+        return null;
+      }
+    },
+    parseContextPercentage: (sessionName) => parseContextPercentage(sessionName),
+    killSession: (sessionName) => {
+      getTransport().kill(sessionName);
+    },
+    hasActiveTasks: getClient ? async (agentId) => {
+      const rows = await queryTaskRows({
+        assignedTo: agentId,
+        status: ["open", "in_progress"],
+        columns: "1",
+        sessionScope: null,
+        // null = no session filter (check all)
+        projectName: null,
+        limit: 1
+      });
+      return rows.length > 0;
+    } : void 0,
+    recordKill: (input) => {
+      void recordSessionKill(input);
+    }
+  };
+}
+function createIdleKillRealDeps(getClient, intercomAckWindowMs) {
+  return {
+    listRegisteredSessions: () => listSessions(),
+    listTmuxSessions: () => listTmuxSessions(),
+    getSessionState: (sessionName) => getSessionState(sessionName),
+    collectSignals: async (agentId, sessionName) => {
+      return collectAgentSignals(getClient(), agentId, sessionName, intercomAckWindowMs);
+    },
+    killSession: (sessionName) => {
+      getTransport().kill(sessionName);
+    },
+    recordKill: (input) => {
+      void recordSessionKill(input);
+    }
+  };
+}
+var AUTO_WAKE_COOLDOWN_MS = 5 * 60 * 1e3;
+var AUTO_WAKE_MAX_RETRIES = 3;
+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 CPU_PRESSURE_THRESHOLD = 80;
+var FREE_RAM_MIN_GB = 4;
+function loadAutoWakeState() {
+  try {
+    if (existsSync2(AUTO_WAKE_STATE_PATH)) {
+      const raw = JSON.parse(readFileSync(AUTO_WAKE_STATE_PATH, "utf8"));
+      return {
+        lastSpawn: raw.lastSpawn ?? {},
+        taskRetries: raw.taskRetries ?? {},
+        recentSpawns: raw.recentSpawns ?? {},
+        crashLoopCount: raw.crashLoopCount ?? {},
+        lastSaved: raw.lastSaved ?? 0
+      };
+    }
+  } catch {
+  }
+  return { lastSpawn: {}, taskRetries: {}, recentSpawns: {}, crashLoopCount: {}, lastSaved: 0 };
+}
+function saveAutoWakeState(state) {
+  try {
+    state.lastSaved = Date.now();
+    writeFileSync(AUTO_WAKE_STATE_PATH, JSON.stringify(state), "utf8");
+  } catch {
+  }
+}
+var _autoWakeState = loadAutoWakeState();
+var _autoWakeLastSpawn = {
+  get: (key) => _autoWakeState.lastSpawn[key],
+  set: (key, val) => {
+    _autoWakeState.lastSpawn[key] = val;
+  }
+};
+var _autoWakeTaskRetries = {
+  get: (key) => _autoWakeState.taskRetries[key],
+  set: (key, val) => {
+    _autoWakeState.taskRetries[key] = val;
+  }
+};
+var _autoWakeRecentSpawns = {
+  get: (key) => _autoWakeState.recentSpawns[key],
+  set: (key, val) => {
+    _autoWakeState.recentSpawns[key] = val;
+  }
+};
+function _resetAutoWakeState() {
+  _autoWakeState = { lastSpawn: {}, taskRetries: {}, recentSpawns: {}, crashLoopCount: {}, lastSaved: 0 };
+  try {
+    unlinkSync(AUTO_WAKE_STATE_PATH);
+  } catch {
+  }
+}
+function checkAutoWakeGates(key, nowMs) {
+  try {
+    const lagMarker = join(homedir(), ".exe-os", "session-cache", "event-loop-blocked.marker");
+    if (existsSync2(lagMarker)) {
+      const age = nowMs - statSync2(lagMarker).mtimeMs;
+      if (age < 6e4) return "daemon_event_loop_blocked";
+    }
+  } catch {
+  }
+  const loopCount = _autoWakeState.crashLoopCount[key] ?? 0;
+  if (loopCount > 0) {
+    const backoffMs = Math.min(BACKOFF_BASE_MS * Math.pow(2, loopCount - 1), BACKOFF_CAP_MS);
+    const lastSpawn = _autoWakeState.lastSpawn[key] ?? 0;
+    if (nowMs - lastSpawn < backoffMs) {
+      return `crash_loop_backoff_${Math.round(backoffMs / 6e4)}min`;
+    }
+  }
+  try {
+    const loadAvg = loadavg()[0];
+    const cpus = cpuCount();
+    const loadPct = loadAvg / cpus * 100;
+    if (loadPct > CPU_PRESSURE_THRESHOLD) return `cpu_pressure_${Math.round(loadPct)}pct`;
+    const freeGB = getAvailableMemoryGB();
+    if (freeGB < FREE_RAM_MIN_GB) return `low_ram_${freeGB.toFixed(1)}gb`;
+  } catch {
+  }
+  return null;
+}
+function shouldAutoWake(input) {
+  if (isCoordinatorName(input.agentId)) return false;
+  if (input.nowMs - input.lastSpawnMs < input.cooldownMs) return false;
+  const running = input.runningInstances ?? (input.hasRunningSession ? 1 : 0);
+  const pending = input.pendingTaskGroups ?? 1;
+  if (running >= pending) return false;
+  return true;
+}
+async function pollOrphanedTasks(deps, nowMs = Date.now()) {
+  const checkGate = deps.checkGate ?? checkAutoWakeGates;
+  const globalGate = checkGate("__global__", nowMs);
+  if (globalGate) {
+    process.stderr.write(`[auto-wake] GLOBAL GATE BLOCKED: ${globalGate} \u2014 skipping all spawns
+`);
+    return [];
+  }
+  let liveSessions;
+  try {
+    liveSessions = deps.listTmuxSessions();
+  } catch (e) {
+    process.stderr.write("[daemon-orch] list tmux sessions for orphan poll: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    return [];
+  }
+  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);
+    }
+  }
+  const coordinatorSessions = liveSessions.filter((s) => isExeSession(s));
+  let tasksByAgent;
+  try {
+    tasksByAgent = await deps.queryTasksByAgent();
+  } catch (e) {
+    process.stderr.write("[daemon-orch] query tasks by agent: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    return [];
+  }
+  const coordinatorSet = new Set(coordinatorSessions);
+  const VALID_SESSION_SCOPE = /^[a-zA-Z0-9_]+$/;
+  const agentTasks = /* @__PURE__ */ new Map();
+  for (const t of tasksByAgent) {
+    const rawScope = t.sessionScope;
+    if (rawScope && !VALID_SESSION_SCOPE.test(rawScope)) {
+      process.stderr.write(
+        `[auto-wake] IGNORING corrupted session_scope for ${t.agentId} task ${t.taskId}: "${rawScope.slice(0, 60)}"
+`
+      );
+      t.sessionScope = null;
+    }
+    let scope = t.sessionScope;
+    if (!scope) {
+      if (coordinatorSessions.length !== 1) {
+        process.stderr.write(
+          `[auto-wake] Skipping ${t.agentId} task ${t.taskId} \u2014 missing session_scope and ${coordinatorSessions.length} live coordinators; refusing to guess
+`
+        );
+        continue;
+      }
+      scope = coordinatorSessions[0];
+    }
+    if (!scope) continue;
+    if (t.sessionScope && !coordinatorSet.has(t.sessionScope)) {
+      process.stderr.write(
+        `[auto-wake] Skipping ${t.agentId} task ${t.taskId} \u2014 coordinator session "${t.sessionScope}" is dead
+`
+      );
+      continue;
+    }
+    const key = `${t.agentId}::${scope}`;
+    const existing = agentTasks.get(key) ?? [];
+    existing.push({ taskId: t.taskId, priority: t.priority, sessionScope: scope });
+    agentTasks.set(key, existing);
+  }
+  const woken = [];
+  for (const [key, tasks] of agentTasks) {
+    const agentId = key.split("::")[0];
+    const sessionScope = tasks[0].sessionScope;
+    if (!shouldAutoWake({
+      agentId,
+      hasRunningSession: liveAgentScopedCounts.has(key),
+      lastSpawnMs: _autoWakeLastSpawn.get(key) ?? 0,
+      nowMs,
+      cooldownMs: AUTO_WAKE_COOLDOWN_MS,
+      runningInstances: liveAgentScopedCounts.get(key) ?? 0,
+      pendingTaskGroups: tasks.length
+    })) {
+      continue;
+    }
+    const recentSpawns = _autoWakeRecentSpawns.get(key) ?? [];
+    const recentCount = recentSpawns.filter((ts) => nowMs - ts < CRASH_LOOP_WINDOW_MS).length;
+    if (recentCount >= CRASH_LOOP_THRESHOLD) {
+      const loopCount = (_autoWakeState.crashLoopCount[key] ?? 0) + 1;
+      _autoWakeState.crashLoopCount[key] = loopCount;
+      const backoffMs = Math.min(BACKOFF_BASE_MS * Math.pow(2, loopCount - 1), BACKOFF_CAP_MS);
+      process.stderr.write(
+        `[auto-wake] CRASH LOOP #${loopCount}: ${agentId} spawned ${recentCount}x in ${CRASH_LOOP_WINDOW_MS / 6e4}min \u2014 backoff ${Math.round(backoffMs / 6e4)}min
+`
+      );
+      saveAutoWakeState(_autoWakeState);
+      try {
+        await writeNotification({
+          agentId,
+          agentRole: "employee",
+          event: "error_spike",
+          project: String(tasks[0]?.sessionScope ?? ""),
+          summary: `Crash loop #${loopCount}: ${agentId} died ${recentCount}x. Backoff ${Math.round(backoffMs / 6e4)}min. Check session-deaths.jsonl.`,
+          sessionScope
+        });
+      } catch {
+      }
+      continue;
+    }
+    const agentGate = checkGate(key, nowMs);
+    if (agentGate) {
+      process.stderr.write(`[auto-wake] AGENT GATE BLOCKED: ${agentId} \u2014 ${agentGate}
+`);
+      continue;
+    }
+    const topTask = tasks[0];
+    const retries = _autoWakeTaskRetries.get(topTask.taskId) ?? 0;
+    if (retries >= AUTO_WAKE_MAX_RETRIES) {
+      try {
+        await deps.markTaskNeedsReview(
+          topTask.taskId,
+          `Auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times \u2014 auto-closed: session ended without explicit completion. Needs manual review.`
+        );
+        process.stderr.write(
+          `[auto-wake] ${agentId} task ${topTask.taskId} exceeded ${AUTO_WAKE_MAX_RETRIES} retries \u2014 marked needs_review
+`
+        );
+      } catch (e) {
+        process.stderr.write("[daemon-orch] mark task needs_review after retries: " + (e instanceof Error ? e.message : String(e)) + "\n");
+      }
+      try {
+        await writeNotification({
+          agentId,
+          agentRole: "employee",
+          event: "orphan_task",
+          project: String(topTask.sessionScope ?? ""),
+          summary: `\u26A0\uFE0F Task ${topTask.taskId} for ${agentId} needs review \u2014 auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times. Session could not be recovered.`,
+          sessionScope
+        });
+      } catch {
+      }
+      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})
+`
+    );
+    try {
+      const result = await deps.ensureEmployee(agentId, sessionScope);
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[auto-wake] Failed to spawn ${agentId}: ${result.error ?? "unknown"}
+`
+        );
+        continue;
+      }
+      _autoWakeLastSpawn.set(key, nowMs);
+      _autoWakeTaskRetries.set(topTask.taskId, retries + 1);
+      const spawns = _autoWakeRecentSpawns.get(key) ?? [];
+      spawns.push(nowMs);
+      while (spawns.length > 0 && nowMs - spawns[0] > CRASH_LOOP_WINDOW_MS) spawns.shift();
+      _autoWakeRecentSpawns.set(key, spawns);
+      saveAutoWakeState(_autoWakeState);
+      woken.push(agentId);
+    } catch (err) {
+      process.stderr.write(
+        `[auto-wake] Error spawning ${agentId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return woken;
+}
+var STUCK_TASK_GRACE_MS = 5 * 60 * 1e3;
+async function releaseStuckTasks(deps, nowMs = Date.now()) {
+  let liveSessions;
+  try {
+    liveSessions = deps.listTmuxSessions();
+  } catch (e) {
+    process.stderr.write("[daemon-orch] list tmux sessions for stuck tasks: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    return [];
+  }
+  const liveAgents = /* @__PURE__ */ new Set();
+  for (const session of liveSessions) {
+    const agent = deps.parseAgentFromSession(session);
+    if (agent) liveAgents.add(agent);
+  }
+  for (const session of liveSessions) {
+    if (isExeSession(session)) {
+      liveAgents.add(session);
+      liveAgents.add(getCoordinatorName());
+    }
+  }
+  let tasks;
+  try {
+    tasks = await deps.queryInProgressTasks();
+  } catch (e) {
+    process.stderr.write("[daemon-orch] query in-progress tasks: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    return [];
+  }
+  const released = [];
+  const STALE_TASK_ESCALATION_MS = 60 * 60 * 1e3;
+  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 leaseMs = t.leaseExpiresAt ? new Date(t.leaseExpiresAt).getTime() : NaN;
+      const leaseExpired = !isNaN(leaseMs) && leaseMs < nowMs;
+      if (!leaseExpired && nowMs - updatedMs < STUCK_TASK_GRACE_MS) continue;
+      const reason = leaseExpired ? `Auto-closed: agent "${t.agentId}" task lease expired (${t.leaseExpiresAt}) and no live local session exists. Needs manual review.` : `Auto-closed: agent "${t.agentId}" session ended without explicit completion (in_progress for ${ageMinutes}m, no live session). Needs manual review.`;
+      try {
+        await deps.markTaskNeedsReview(t.taskId, reason);
+        released.push(t.taskId);
+        process.stderr.write(
+          `[stuck-release] Task ${t.taskId} (${t.agentId}) \u2014 in_progress for ${ageMinutes}m, agent dead \u2192 needs_review
+`
+        );
+      } catch (err) {
+        process.stderr.write(`[stuck-release] Failed to mark task ${t.taskId} needs_review: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+      if (deps.notifyOrphan) {
+        try {
+          await deps.notifyOrphan(t.taskId, t.agentId, t.sessionScope);
+        } catch {
+        }
+      }
+      continue;
+    }
+    if (nowMs - updatedMs > STALE_TASK_ESCALATION_MS) {
+      process.stderr.write(
+        `[stuck-release] STALE WARNING: Task ${t.taskId} (${t.agentId}) \u2014 in_progress for ${ageMinutes}m, session alive but no update. Escalating to coordinator.
+`
+      );
+      if (deps.notifyOrphan) {
+        try {
+          await deps.notifyOrphan(t.taskId, t.agentId, t.sessionScope);
+        } catch {
+        }
+      }
+      continue;
+    }
+  }
+  return released;
+}
+function createStuckTaskRealDeps(getClient) {
+  return {
+    listTmuxSessions: () => listTmuxSessions(),
+    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
+              FROM tasks
+              WHERE status = 'in_progress'
+                AND (device_id = ? OR device_id IS NULL OR lease_expires_at < ?)
+              ORDER BY updated_at ASC
+              LIMIT 1000`,
+        args: [deviceId, nowIso]
+      });
+      return rows.rows.map((r) => ({
+        taskId: String(r.id),
+        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
+      }));
+    },
+    markTaskNeedsReview: async (taskId, reason) => {
+      try {
+        await updateTask({ taskId, status: "needs_review", result: reason });
+      } catch {
+        const client = getClient();
+        await client.execute({
+          sql: `UPDATE tasks SET status = 'needs_review', result = ?, updated_at = ? WHERE id = ?`,
+          args: [reason, (/* @__PURE__ */ new Date()).toISOString(), taskId]
+        });
+      }
+    },
+    parseAgentFromSession: (sessionName) => {
+      if (!sessionName.includes("-")) return null;
+      const agentPart = sessionName.split("-")[0];
+      return baseAgentName(agentPart);
+    },
+    notifyOrphan: async (taskId, agentId, sessionScope) => {
+      await writeNotification({
+        agentId,
+        agentRole: "employee",
+        event: "orphan_task",
+        project: "",
+        summary: `Agent "${agentId}" session died \u2014 task ${taskId.slice(0, 8)} needs review (auto-closed: session ended without completion)`,
+        sessionScope: sessionScope ?? void 0
+      });
+    }
+  };
+}
+var DEFAULT_STALE_REVIEW_DAYS = 7;
+async function cleanupStaleReviews(deps) {
+  const thresholdDays = deps.getStaleReviewThreshold();
+  let stale;
+  try {
+    stale = await deps.queryStaleReviews(thresholdDays);
+  } catch (e) {
+    process.stderr.write(`[stale-review] query failed: ${e instanceof Error ? e.message : String(e)}
+`);
+    return [];
+  }
+  const cleaned = [];
+  for (const t of stale) {
+    const reason = `auto-closed: stale review \u2014 no reviewer action for ${thresholdDays} days`;
+    try {
+      await deps.cancelTask(t.taskId, reason);
+      cleaned.push(t.taskId);
+      process.stderr.write(
+        `[stale-review] Cancelled task ${t.taskId.slice(0, 8)} "${t.title}" (${t.assignedTo}) \u2014 needs_review since ${t.updatedAt}
+`
+      );
+    } catch (err) {
+      process.stderr.write(`[stale-review] Failed to cancel ${t.taskId}: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+  }
+  return cleaned;
+}
+function createStaleReviewRealDeps(getClient) {
+  return {
+    queryStaleReviews: async (thresholdDays) => {
+      const client = getClient();
+      const scopeRows = await client.execute({
+        sql: `SELECT DISTINCT session_scope FROM tasks
+              WHERE session_scope IS NOT NULL AND status NOT IN ('closed', 'cancelled')`,
+        args: []
+      });
+      const scopes = scopeRows.rows.map((r) => r.session_scope ? String(r.session_scope) : null);
+      scopes.push(null);
+      const allRows = [];
+      for (const scope of scopes) {
+        const rows = await queryTaskRows({
+          status: "needs_review",
+          columns: "id, title, assigned_to, updated_at",
+          sessionScope: scope,
+          strictSession: scope !== null,
+          projectName: null,
+          orderBy: "updated_at ASC",
+          limit: 1e3,
+          extraConditions: ["updated_at < datetime('now', '-' || ? || ' days')"],
+          extraArgs: [String(thresholdDays)]
+        });
+        allRows.push(...rows);
+      }
+      const seen = /* @__PURE__ */ new Set();
+      return allRows.filter((r) => {
+        const id = String(r.id);
+        if (seen.has(id)) return false;
+        seen.add(id);
+        return true;
+      }).map((r) => ({
+        taskId: String(r.id),
+        title: String(r.title),
+        assignedTo: String(r.assigned_to),
+        updatedAt: String(r.updated_at)
+      }));
+    },
+    cancelTask: async (taskId, reason) => {
+      try {
+        await updateTask({ taskId, status: "cancelled", result: reason });
+      } catch {
+        const client = getClient();
+        await client.execute({
+          sql: `UPDATE tasks SET status = 'cancelled', result = ?, updated_at = ? WHERE id = ?`,
+          args: [reason, (/* @__PURE__ */ new Date()).toISOString(), taskId]
+        });
+      }
+    },
+    getStaleReviewThreshold: () => {
+      try {
+        const cfg = loadConfigSync();
+        return cfg.staleReviewDays ?? DEFAULT_STALE_REVIEW_DAYS;
+      } catch {
+        return DEFAULT_STALE_REVIEW_DAYS;
+      }
+    }
+  };
+}
+function createAutoWakeRealDeps(getClient, projectDir) {
+  return {
+    listTmuxSessions: () => listTmuxSessions(),
+    queryTasksByAgent: async () => {
+      const { loadDeviceId } = await import("./lib/license.js");
+      const deviceId = loadDeviceId();
+      const rows = await queryTaskRows({
+        status: ["open", "in_progress"],
+        columns: "assigned_to, id, priority, session_scope",
+        sessionScope: null,
+        // daemon-level: no session filter
+        projectName: null,
+        deviceId,
+        orderBy: "CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 WHEN 'p2' THEN 2 ELSE 3 END, created_at ASC",
+        limit: 1e3
+      });
+      return rows.map((r) => ({
+        agentId: String(r.assigned_to),
+        taskId: String(r.id),
+        priority: String(r.priority),
+        sessionScope: r.session_scope ? String(r.session_scope) : null
+      }));
+    },
+    ensureEmployee: async (agentName, scope) => {
+      let resolvedProjectDir = projectDir;
+      try {
+        const sessions = listSessions();
+        const coordSession = sessions.find((s) => s.windowName === scope);
+        if (coordSession?.projectDir && existsSync2(coordSession.projectDir)) {
+          resolvedProjectDir = coordSession.projectDir;
+        }
+      } catch {
+        process.stderr.write(
+          `[auto-wake] WARN: could not resolve project dir from session registry for scope="${scope}", falling back to daemon cwd="${projectDir}"
+`
+        );
+      }
+      return ensureEmployeeAsync(agentName, scope, resolvedProjectDir, shouldAutoInstance(agentName));
+    },
+    markTaskNeedsReview: async (taskId, reason) => {
+      try {
+        await updateTask({ taskId, status: "needs_review", result: reason });
+      } catch {
+        const client = getClient();
+        await client.execute({
+          sql: `UPDATE tasks SET status = 'needs_review', result = ?, updated_at = ? WHERE id = ?`,
+          args: [reason, (/* @__PURE__ */ new Date()).toISOString(), taskId]
+        });
+      }
+    },
+    parseAgentFromSession: (sessionName) => {
+      if (!sessionName.includes("-")) return null;
+      const agentPart = sessionName.split("-")[0];
+      return baseAgentName(agentPart);
+    }
+  };
+}
+var COO_CONTEXT_THRESHOLD_PCT = Number(process.env.EXE_COO_CONTEXT_THRESHOLD_PCT) || 85;
+var COO_RESTART_COOLDOWN_MS = Number(process.env.EXE_COO_RESTART_COOLDOWN_MS) || 5 * 60 * 1e3;
+var _cooLastRestart = /* @__PURE__ */ new Map();
+function _resetCooRestartState() {
+  _cooLastRestart.clear();
+}
+async function pollCoordinatorContextRestart(deps, projectDir) {
+  let liveSessions;
+  try {
+    liveSessions = deps.listTmuxSessions();
+  } catch (e) {
+    process.stderr.write(`[daemon-orch] list tmux sessions for coordinator context: ${e instanceof Error ? e.message : String(e)}
+`);
+    return [];
+  }
+  const coordinatorSessions = liveSessions.filter((s) => isExeSession(s));
+  if (coordinatorSessions.length === 0) return [];
+  const restarted = [];
+  const now = Date.now();
+  for (const sessionName of coordinatorSessions) {
+    const lastRestart = _cooLastRestart.get(sessionName) ?? 0;
+    if (now - lastRestart < COO_RESTART_COOLDOWN_MS) continue;
+    const contextPct = deps.parseContextPercentage(sessionName);
+    if (contextPct === null || contextPct < COO_CONTEXT_THRESHOLD_PCT) continue;
+    try {
+      if (await deps.hasUnsavedWork(sessionName)) {
+        process.stderr.write(
+          `[exed] Coordinator context restart: SKIPPING ${sessionName} (context=${contextPct}%) \u2014 has unsaved work
+`
+        );
+        continue;
+      }
+    } catch {
+      process.stderr.write(
+        `[exed] Coordinator context restart: SKIPPING ${sessionName} \u2014 unsaved work check failed (conservative)
+`
+      );
+      continue;
+    }
+    process.stderr.write(
+      `[exed] Coordinator context restart: ${sessionName} at ${contextPct}% (threshold: ${COO_CONTEXT_THRESHOLD_PCT}%). Checkpointing and restarting.
+`
+    );
+    try {
+      await deps.storeCheckpoint(sessionName, contextPct);
+      deps.recordKill?.({
+        sessionName,
+        agentId: sessionName,
+        reason: "ttl_context"
+      });
+      deps.killSession(sessionName);
+      const result = await deps.respawnCoordinator(sessionName, projectDir);
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[exed] Coordinator context restart: respawn FAILED for ${sessionName}: ${result.error ?? "unknown"}
+`
+        );
+      } else {
+        _cooLastRestart.set(sessionName, now);
+        restarted.push(sessionName);
+        process.stderr.write(
+          `[exed] Coordinator context restart: ${sessionName} respawned successfully.
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[exed] Coordinator context restart: error for ${sessionName}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return restarted;
+}
+function createCoordinatorRestartRealDeps(getClient) {
+  return {
+    listTmuxSessions: () => {
+      return listTmuxSessions();
+    },
+    parseContextPercentage: (sessionName) => {
+      return parseContextPercentage(sessionName);
+    },
+    killSession: (sessionName) => {
+      getTransport().kill(sessionName);
+    },
+    respawnCoordinator: async (sessionName, projectDir) => {
+      try {
+        await execFileAsync("tmux", ["new-session", "-d", "-s", sessionName, "-c", projectDir, "claude --resume"], {
+          encoding: "utf8",
+          timeout: 1e4
+        });
+        return { status: "ok" };
+      } catch (err) {
+        return { status: "failed", error: err instanceof Error ? err.message : String(err) };
+      }
+    },
+    storeCheckpoint: async (sessionName, contextPct) => {
+      let paneContent = "";
+      try {
+        const { execFile: execFile2 } = await import("child_process");
+        const { promisify: promisify2 } = await import("util");
+        const execFileAsync2 = promisify2(execFile2);
+        const { stdout } = await execFileAsync2("tmux", [
+          "capture-pane",
+          "-t",
+          sessionName,
+          "-p"
+        ], { encoding: "utf8", timeout: 3e3 });
+        paneContent = stdout.split("\n").slice(-30).join("\n").trim();
+      } catch {
+      }
+      const client = getClient();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const summary = [
+        `CONTEXT CHECKPOINT [auto-restart]: Coordinator ${sessionName} at ${contextPct}% context capacity.`,
+        `Auto-restarted by daemon at ${now}.`,
+        paneContent ? `Last activity:
+${paneContent.slice(0, 500)}` : ""
+      ].filter(Boolean).join("\n");
+      await client.execute({
+        sql: `INSERT INTO memories (id, agent_id, agent_role, text, importance, memory_type, project_name, tool_name, created_at, updated_at, session_scope)
+              VALUES (?, ?, 'coordinator', ?, 9, 'observation', ?, 'daemon', ?, ?, NULL)`,
+        args: [
+          randomUUID(),
+          sessionName,
+          summary,
+          "exe-os",
+          now,
+          now
+        ]
+      });
+    },
+    hasUnsavedWork: async (sessionName) => {
+      try {
+        const { execFile: execFile2 } = await import("child_process");
+        const { promisify: promisify2 } = await import("util");
+        const execFileAsync2 = promisify2(execFile2);
+        const { stdout } = await execFileAsync2("tmux", [
+          "capture-pane",
+          "-t",
+          sessionName,
+          "-p"
+        ], { encoding: "utf8", timeout: 3e3 });
+        const tail = stdout.split("\n").slice(-10).join("\n");
+        if (/(?:git commit|committing|staging)/i.test(tail)) return true;
+      } catch {
+      }
+      return false;
+    },
+    recordKill: (input) => {
+      void recordSessionKill(input);
+    }
+  };
+}
+var ORPHAN_SIGKILL_DELAY_MS = 5e3;
+var ORPHAN_MAX_AGE_SECS = 120;
+var ORPHAN_PATTERNS = [
+  "exe-os/dist/mcp/server.js",
+  "exe-mem/dist/mcp/server.js",
+  "exe-os/dist/hooks/ingest-worker.js",
+  "exe-mem/dist/hooks/ingest-worker.js",
+  // Hook processes that become orphaned and never get reaped.
+  // These accumulate at ~70MB each and caused 1GB+ memory waste.
+  "codex-stop-task-finalizer.js",
+  "scan-tasks.js",
+  "exe-pending-reviews.js",
+  "exe-pending-messages.js",
+  "exe-pending-notifications.js"
+];
+var HOOK_PROCESS_PATTERNS = [
+  "codex-stop-task-finalizer.js",
+  "scan-tasks.js",
+  "exe-pending-reviews.js",
+  "exe-pending-messages.js",
+  "exe-pending-notifications.js",
+  // Hook scripts that can zombie (added 2026-06-01 — orphan bug a4eaf106)
+  "prompt-submit.js",
+  "stop.js",
+  "subagent-stop.js",
+  "pre-tool-use.js",
+  "post-tool-combined.js",
+  "ingest.js",
+  "intercom-check.js",
+  "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 ZOMBIE_AGENT_MAX_AGE_SECS = 300;
+function reapZombieAgentProcesses(deps) {
+  let liveSessions;
+  try {
+    liveSessions = new Set(deps.listTmuxSessions());
+  } catch {
+    return [];
+  }
+  const lines = deps.listProcesses();
+  const reaped = [];
+  const procMap = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(.+)$/);
+    if (!match) continue;
+    procMap.set(parseInt(match[1], 10), {
+      ppid: parseInt(match[2], 10),
+      etime: match[3],
+      tty: match[4],
+      args: match[5]
+    });
+  }
+  const AGENT_PATTERNS = [
+    /\bclaude\b/,
+    // Claude Code CLI
+    /\bcodex\b/,
+    // OpenAI Codex CLI
+    /\bopencode\b/
+    // OpenCode CLI
+  ];
+  const DESKTOP_APP_EXCLUSIONS = [
+    /Claude\s+Helper/i,
+    // "Claude Helper (Renderer)", "Claude Helper (GPU)", etc.
+    /Claude\.app\b/i,
+    // macOS app bundle path
+    /Electron\s+Helper/i,
+    // Generic Electron helper (Claude Desktop is Electron-based)
+    /Claude.*\bRenderer\b/i,
+    // Renderer process variants
+    /Claude.*\bGPU\b/i,
+    // GPU process variants
+    /Contents\/Frameworks\/.*Helper/i,
+    // macOS framework helpers
+    /\/Applications\/Claude/i
+    // Launched from /Applications
+  ];
+  for (const [pid, info] of procMap) {
+    if (pid === deps.selfPid) continue;
+    const isAgent = AGENT_PATTERNS.some((pat) => pat.test(info.args));
+    if (!isAgent) continue;
+    const isDesktopApp = DESKTOP_APP_EXCLUSIONS.some((pat) => pat.test(info.args));
+    if (isDesktopApp) continue;
+    const ageSecs = parseEtime(info.etime);
+    if (ageSecs < ZOMBIE_AGENT_MAX_AGE_SECS) continue;
+    if (info.tty !== "??" && info.tty !== "-") continue;
+    const wrapperInfo = procMap.get(info.ppid);
+    if (wrapperInfo && wrapperInfo.tty !== "??" && wrapperInfo.tty !== "-") continue;
+    let hasLiveSession = false;
+    let cur = info.ppid;
+    for (let depth = 0; depth < 5; depth++) {
+      const parent = procMap.get(cur);
+      if (!parent) break;
+      cur = parent.ppid;
+    }
+    const wrapperPid = info.ppid;
+    for (const session of liveSessions) {
+      try {
+        const panePids = deps.getPanePids ? deps.getPanePids(session) : execSync(
+          `tmux list-panes -t ${JSON.stringify(session)} -F '#{pane_pid}' 2>/dev/null`,
+          { encoding: "utf8", timeout: 3e3 }
+        ).trim().split("\n").map(Number);
+        if (panePids.includes(wrapperPid)) {
+          hasLiveSession = true;
+          break;
+        }
+        let ancestor = wrapperPid;
+        for (let i = 0; i < 3; i++) {
+          const p = procMap.get(ancestor);
+          if (!p) break;
+          if (panePids.includes(p.ppid)) {
+            hasLiveSession = true;
+            break;
+          }
+          ancestor = p.ppid;
+        }
+        if (hasLiveSession) break;
+      } catch {
+      }
+    }
+    if (hasLiveSession) continue;
+    const coordinatorSessions = [...liveSessions].filter(
+      (s) => isCoordinatorName(s.replace(/^\w+-/, "")) || isExeSession(s)
+    );
+    if (coordinatorSessions.length > 0) {
+      let belongsToCoordinator = false;
+      for (const cs of coordinatorSessions) {
+        try {
+          const panePids = (deps.getPanePids ? deps.getPanePids(cs) : execSync(
+            `tmux list-panes -t ${JSON.stringify(cs)} -F '#{pane_pid}' 2>/dev/null`,
+            { encoding: "utf8", timeout: 3e3 }
+          ).trim().split("\n").map(Number)).filter(Boolean);
+          for (const panePid of panePids) {
+            let walk = pid;
+            for (let d = 0; d < 10; d++) {
+              if (walk === panePid) {
+                belongsToCoordinator = true;
+                break;
+              }
+              const p = procMap.get(walk);
+              if (!p || p.ppid <= 1) break;
+              walk = p.ppid;
+            }
+            if (belongsToCoordinator) break;
+          }
+        } catch {
+        }
+        if (belongsToCoordinator) break;
+      }
+      if (belongsToCoordinator) {
+        process.stderr.write(
+          `[zombie-agent-reaper] SKIPPING PID ${pid} \u2014 belongs to coordinator session (${info.args.slice(0, 60)})
+`
+        );
+        continue;
+      }
+    }
+    const rssKb = getRssKb(pid);
+    const rssMb = rssKb ? Math.round(rssKb / 1024) : "?";
+    const desc = `PID ${pid} (age=${ageSecs}s, RSS=${rssMb}MB, ${info.args.slice(0, 80)})`;
+    try {
+      deps.killProcess(pid, "SIGTERM");
+    } catch {
+      continue;
+    }
+    reaped.push(desc);
+    process.stderr.write(`[zombie-agent-reaper] Killed ${desc}
+`);
+    if (wrapperPid > 1 && procMap.has(wrapperPid)) {
+      try {
+        deps.killProcess(wrapperPid, "SIGTERM");
+        process.stderr.write(`[zombie-agent-reaper] Killed wrapper PID ${wrapperPid}
+`);
+      } catch {
+      }
+    }
+    deps.scheduleKill(pid, ORPHAN_SIGKILL_DELAY_MS, () => {
+      try {
+        deps.killProcess(pid, "SIGKILL");
+      } catch {
+      }
+    });
+    if (wrapperPid > 1) {
+      deps.scheduleKill(wrapperPid, ORPHAN_SIGKILL_DELAY_MS, () => {
+        try {
+          deps.killProcess(wrapperPid, "SIGKILL");
+        } catch {
+        }
+      });
+    }
+  }
+  return reaped;
+}
+function getRssKb(pid) {
+  try {
+    const out = execSync(`ps -o rss= -p ${pid} 2>/dev/null`, { encoding: "utf8", timeout: 2e3 });
+    const val = parseInt(out.trim(), 10);
+    return isNaN(val) ? null : val;
+  } catch {
+    return null;
+  }
+}
+function createZombieAgentReaperRealDeps() {
+  const panePidMap = /* @__PURE__ */ new Map();
+  let panePidCacheReady = false;
+  try {
+    const output = execSync("tmux list-panes -a -F '#{session_name} #{pane_pid}' 2>/dev/null", {
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    for (const line of output.split("\n")) {
+      const [sessionName, pidText] = line.trim().split(/\s+/);
+      const pid = Number(pidText);
+      if (!sessionName || !Number.isFinite(pid)) continue;
+      const arr = panePidMap.get(sessionName) ?? [];
+      arr.push(pid);
+      panePidMap.set(sessionName, arr);
+    }
+    panePidCacheReady = true;
+  } catch {
+  }
+  return {
+    listProcesses: () => {
+      const output = execSync("ps -eo pid,ppid,etime,tty,args", {
+        encoding: "utf8",
+        timeout: 5e3
+      });
+      return output.split("\n");
+    },
+    listTmuxSessions: () => {
+      const output = execSync("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
+        encoding: "utf8",
+        timeout: 3e3
+      });
+      return output.trim().split("\n").filter(Boolean);
+    },
+    killProcess: (pid, signal) => {
+      process.kill(pid, signal);
+    },
+    ...panePidCacheReady ? { getPanePids: (sessionName) => panePidMap.get(sessionName) ?? [] } : {},
+    scheduleKill: (_pid, delayMs, cb) => {
+      setTimeout(() => {
+        try {
+          cb();
+        } catch {
+        }
+      }, delayMs).unref();
+    },
+    selfPid: process.pid
+  };
+}
+function parseEtime(etime) {
+  const trimmed = etime.trim();
+  const dayMatch = trimmed.match(/^(\d+)-(\d+):(\d+):(\d+)$/);
+  if (dayMatch) {
+    return parseInt(dayMatch[1], 10) * 86400 + parseInt(dayMatch[2], 10) * 3600 + parseInt(dayMatch[3], 10) * 60 + parseInt(dayMatch[4], 10);
+  }
+  const parts = trimmed.split(":").map((p) => parseInt(p, 10));
+  if (parts.length === 3) return parts[0] * 3600 + parts[1] * 60 + parts[2];
+  if (parts.length === 2) return parts[0] * 60 + parts[1];
+  if (parts.length === 1) return parts[0];
+  return 0;
+}
+function reapOrphanedMcpProcesses(deps) {
+  const lines = deps.listProcesses();
+  const reaped = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+    if (!match) continue;
+    const pid = parseInt(match[1], 10);
+    const ppid = parseInt(match[2], 10);
+    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 ageSecs = parseEtime(etime);
+    const isAgedHookOrphan = ageSecs > ORPHAN_MAX_AGE_SECS && HOOK_PROCESS_PATTERNS.some((pat) => matchScope.includes(pat));
+    if (!isPpid1Orphan && !isAgedHookOrphan) continue;
+    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 {
+      }
+    });
+  }
+  return reaped;
+}
+function createOrphanReaperRealDeps() {
+  return {
+    listProcesses: () => {
+      const output = execSync("ps -eo pid,ppid,etime,args", {
+        encoding: "utf8",
+        timeout: 5e3
+      });
+      return output.split("\n");
+    },
+    killProcess: (pid, signal) => {
+      process.kill(pid, signal);
+    },
+    scheduleKill: (_pid, delayMs, cb) => {
+      setTimeout(() => {
+        try {
+          cb();
+        } catch {
+        }
+      }, delayMs).unref();
+    },
+    selfPid: process.pid
+  };
+}
+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;
+async function reapOrphanedWorktrees(deps, nowMs = Date.now()) {
+  const result = { pruned: [], skipped: [] };
+  let sessions;
+  try {
+    sessions = deps.listTmuxSessions();
+  } catch {
+    return result;
+  }
+  const liveAgents = /* @__PURE__ */ new Set();
+  for (const s of sessions) {
+    if (!s.includes("-")) continue;
+    const agentPart = s.split("-")[0];
+    liveAgents.add(baseAgentName(agentPart));
+  }
+  const repoRoots = /* @__PURE__ */ new Set();
+  for (const s of sessions) {
+    const cwd = deps.getPaneCwd(s);
+    if (!cwd) continue;
+    const root = deps.getGitRoot(cwd);
+    if (root) repoRoots.add(root);
+  }
+  for (const repoRoot of repoRoots) {
+    if (result.pruned.length >= WORKTREE_MAX_PRUNES_PER_TICK) break;
+    let worktrees;
+    try {
+      worktrees = deps.listWorktrees(repoRoot);
+    } catch {
+      continue;
+    }
+    for (const wt of worktrees) {
+      if (result.pruned.length >= WORKTREE_MAX_PRUNES_PER_TICK) break;
+      if (!wt.path.includes("/.worktrees/")) continue;
+      const agentName = deps.parseAgentFromWorktreePath(wt.path);
+      if (!agentName) {
+        result.skipped.push({ path: wt.path, reason: "could not parse agent name" });
+        recordOrchestrationEventBestEffort({
+          eventType: "worktree.skipped",
+          source: "daemon-orchestration.reapOrphanedWorktrees",
+          severity: "warn",
+          payload: { reason: "could not parse agent name" }
+        });
+        continue;
+      }
+      if (liveAgents.has(agentName)) continue;
+      const mtimeMs = deps.getDirMtimeMs(wt.path);
+      if (mtimeMs === null) continue;
+      const ageMs = nowMs - mtimeMs;
+      if (ageMs < WORKTREE_MIN_AGE_MS) {
+        result.skipped.push({ path: wt.path, reason: `too young (${Math.round(ageMs / 6e4)}m < 60m)` });
+        recordOrchestrationEventBestEffort({
+          eventType: "worktree.skipped",
+          source: "daemon-orchestration.reapOrphanedWorktrees",
+          agentId: agentName,
+          payload: { reason: "too young", ageMinutes: Math.round(ageMs / 6e4) }
+        });
+        continue;
+      }
+      if (deps.isWorktreeDirty(wt.path)) {
+        const ageH2 = Math.round(ageMs / 36e5);
+        if (ageMs >= WORKTREE_DIRTY_MAX_AGE_MS && deps.archiveDirtyWorktree) {
+          process.stderr.write(
+            `[worktree-reaper] Dirty orphan worktree aged out (${ageH2}h > ${WORKTREE_DIRTY_MAX_AGE_MS / 36e5}h), archiving: ${wt.path} (agent: ${agentName})
+`
+          );
+          try {
+            const archived = await deps.archiveDirtyWorktree(repoRoot, wt.path, wt.branch, agentName);
+            if (archived) {
+              const removed2 = await deps.removeWorktree(repoRoot, wt.path);
+              if (removed2) {
+                await deps.deleteBranch(repoRoot, wt.branch);
+                await deps.deleteRemoteBranch(repoRoot, wt.branch);
+                process.stderr.write(
+                  `[worktree-reaper] Archived and pruned dirty orphan: ${wt.path} (agent: ${agentName}, age: ${ageH2}h)
+`
+                );
+                recordOrchestrationEventBestEffort({
+                  eventType: "worktree.archived_and_pruned",
+                  source: "daemon-orchestration.reapOrphanedWorktrees",
+                  agentId: agentName,
+                  payload: { branch: wt.branch, ageHours: ageH2, dirty: true }
+                });
+                result.pruned.push(wt.path);
+                continue;
+              }
+            }
+          } catch (err) {
+            process.stderr.write(
+              `[worktree-reaper] Failed to archive dirty orphan ${wt.path}: ${err instanceof Error ? err.message : String(err)}
+`
+            );
+          }
+        }
+        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" });
+        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 }
+        });
+        continue;
+      }
+      const ageH = Math.round(ageMs / 36e5);
+      const removed = await deps.removeWorktree(repoRoot, wt.path);
+      if (removed) {
+        await deps.deleteBranch(repoRoot, wt.branch);
+        await deps.deleteRemoteBranch(repoRoot, wt.branch);
+        process.stderr.write(
+          `[worktree-reaper] Pruned orphan worktree: ${wt.path} (agent: ${agentName}, age: ${ageH}h)
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "worktree.pruned",
+          source: "daemon-orchestration.reapOrphanedWorktrees",
+          agentId: agentName,
+          payload: { branch: wt.branch, ageHours: ageH }
+        });
+        result.pruned.push(wt.path);
+      } else {
+        result.skipped.push({ path: wt.path, reason: "git worktree remove failed" });
+        recordOrchestrationEventBestEffort({
+          eventType: "worktree.failed",
+          source: "daemon-orchestration.reapOrphanedWorktrees",
+          severity: "warn",
+          agentId: agentName,
+          errorCode: "git_worktree_remove_failed",
+          payload: { branch: wt.branch, ageHours: ageH }
+        });
+      }
+    }
+  }
+  return result;
+}
+async function createWorktreeReaperRealDeps() {
+  const { getPaneCwdAsync } = await import("./lib/tmux-status.js");
+  const { getGitRoot, isWorktreeDirty: isDirty } = await import("./worktree-5Q4VB2LR.js");
+  const { statSync: statSync3 } = await import("fs");
+  const { basename } = await import("path");
+  const { promisify: promisify2 } = await import("util");
+  const { execFile: execFileCb } = await import("child_process");
+  const execFileAsync2 = promisify2(execFileCb);
+  const sessions = listTmuxSessions();
+  const cwdMap = /* @__PURE__ */ new Map();
+  const cwdPromises = sessions.map(async (s) => {
+    try {
+      const cwd = await getPaneCwdAsync(s);
+      if (cwd) cwdMap.set(s, cwd);
+    } catch {
+    }
+  });
+  await Promise.all(cwdPromises);
+  const repoRoots = /* @__PURE__ */ new Set();
+  for (const cwd of cwdMap.values()) {
+    const root = getGitRoot(cwd);
+    if (root) repoRoots.add(root);
+  }
+  const worktreeCache = /* @__PURE__ */ new Map();
+  const wtPromises = [...repoRoots].map(async (repoRoot) => {
+    try {
+      const { stdout } = await execFileAsync2("git", ["worktree", "list", "--porcelain"], {
+        cwd: repoRoot,
+        timeout: 1e4
+      });
+      const worktrees = [];
+      let currentPath = "";
+      for (const line of stdout.split("\n")) {
+        if (line.startsWith("worktree ")) {
+          currentPath = line.slice("worktree ".length);
+        } else if (line.startsWith("branch ") && currentPath) {
+          const branch = line.slice("branch refs/heads/".length);
+          worktrees.push({ path: currentPath, branch });
+          currentPath = "";
+        }
+      }
+      worktreeCache.set(repoRoot, worktrees);
+    } catch {
+    }
+  });
+  await Promise.all(wtPromises);
+  return {
+    listTmuxSessions: () => sessions,
+    getPaneCwd: (s) => cwdMap.get(s),
+    listWorktrees: (repoRoot) => worktreeCache.get(repoRoot) ?? [],
+    isWorktreeDirty: (wtPath) => isDirty(wtPath),
+    getDirMtimeMs: (dirPath) => {
+      try {
+        return statSync3(dirPath).mtimeMs;
+      } catch {
+        return null;
+      }
+    },
+    removeWorktree: async (repoRoot, wtPath) => {
+      try {
+        await execFileAsync2("git", ["worktree", "remove", wtPath, "--force"], {
+          cwd: repoRoot,
+          encoding: "utf-8",
+          timeout: 1e4
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    deleteBranch: async (repoRoot, branch) => {
+      try {
+        await execFileAsync2("git", ["branch", "-D", branch], {
+          cwd: repoRoot,
+          encoding: "utf-8",
+          timeout: 1e4
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    deleteRemoteBranch: async (repoRoot, branch) => {
+      try {
+        await execFileAsync2("git", ["push", "origin", "--delete", branch], {
+          cwd: repoRoot,
+          encoding: "utf-8",
+          timeout: 15e3
+        });
+      } catch {
+      }
+    },
+    parseAgentFromWorktreePath: (wtPath) => {
+      const dirName = basename(wtPath);
+      if (!dirName) return null;
+      return baseAgentName(dirName);
+    },
+    getGitRoot: (dir) => getGitRoot(dir),
+    archiveDirtyWorktree: async (_repoRoot, wtPath, _branch, agentName) => {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const quarantineBranch = `quarantine/${agentName}-${timestamp}`;
+      try {
+        await execFileAsync2("git", ["-C", wtPath, "checkout", "-b", quarantineBranch], {
+          encoding: "utf-8",
+          timeout: 1e4
+        });
+        await execFileAsync2("git", ["-C", wtPath, "add", "-A"], {
+          encoding: "utf-8",
+          timeout: 1e4
+        });
+        await execFileAsync2("git", [
+          "-C",
+          wtPath,
+          "commit",
+          "-m",
+          `[quarantine] Auto-archived dirty orphan worktree
+
+Agent: ${agentName}
+Original worktree: ${wtPath}
+Archived by daemon worktree reaper after 7-day dirty orphan threshold.`
+        ], {
+          encoding: "utf-8",
+          timeout: 1e4,
+          env: {
+            ...process.env,
+            GIT_AUTHOR_NAME: "exe-os daemon",
+            GIT_AUTHOR_EMAIL: "daemon@exe-os.local",
+            GIT_COMMITTER_NAME: "exe-os daemon",
+            GIT_COMMITTER_EMAIL: "daemon@exe-os.local"
+          }
+        });
+        process.stderr.write(
+          `[worktree-reaper] Archived dirty changes to branch ${quarantineBranch}
+`
+        );
+        return true;
+      } catch (err) {
+        process.stderr.write(
+          `[worktree-reaper] Archive failed for ${wtPath}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+        return false;
+      }
+    }
+  };
+}
+var _lastStaleCheckpointGcMs = 0;
+var STALE_CHECKPOINT_GC_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+async function gcStaleCheckpoints() {
+  const now = Date.now();
+  if (now - _lastStaleCheckpointGcMs < STALE_CHECKPOINT_GC_INTERVAL_MS) return 0;
+  _lastStaleCheckpointGcMs = now;
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const scope = sessionScopeFilter();
+    const result = await client.execute({
+      sql: `UPDATE tasks SET checkpoint = NULL, checkpoint_count = 0
+            WHERE checkpoint IS NOT NULL
+              AND status IN ('done', 'closed', 'cancelled', 'needs_review')
+              ${scope.sql}`,
+      args: scope.args
+    });
+    const cleared = Number(result.rowsAffected ?? 0);
+    if (cleared > 0) {
+      process.stderr.write(`[daemon-orchestration] GC'd ${cleared} stale checkpoint(s)
+`);
+      recordOrchestrationEventBestEffort({
+        eventType: "checkpoint.gc",
+        source: "daemon-orchestration.gcStaleCheckpoints",
+        payload: { cleared }
+      });
+    }
+    return cleared;
+  } catch (err) {
+    if (process.env.EXE_DEBUG === "1") {
+      process.stderr.write(
+        `[daemon-orchestration] gcStaleCheckpoints error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+    return 0;
+  }
+}
+async function pollTaskGroupBarriers() {
+  try {
+    const { checkAndFireBarriers } = await import("./tasks-crud-LD2WCC5Z.js");
+    const firedGroupIds = await checkAndFireBarriers();
+    if (firedGroupIds.length === 0) return 0;
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    for (const groupId of firedGroupIds) {
+      try {
+        const groupRow = await client.execute({
+          sql: "SELECT title, coordinator, session_scope, aggregated_result FROM task_groups WHERE id = ?",
+          args: [groupId]
+        });
+        if (groupRow.rows.length === 0) continue;
+        const group = groupRow.rows[0];
+        const coordinator = String(group.coordinator);
+        const sessionScope = group.session_scope != null ? String(group.session_scope) : null;
+        const title = String(group.title);
+        let summary = `Task group "${title}" barrier fired.`;
+        try {
+          const agg = JSON.parse(String(group.aggregated_result ?? "{}"));
+          summary = `Task group "${title}" complete: ${agg.succeeded ?? 0}/${agg.total ?? 0} succeeded`;
+          if (agg.cancelled) summary += `, ${agg.cancelled} cancelled`;
+          if (agg.timed_out) summary += " (timed out)";
+        } catch {
+        }
+        if (sessionScope) {
+          try {
+            if (isCoordinatorName(coordinator) && isExeSession(sessionScope)) {
+              await sendIntercomAsync(sessionScope, { force: true, reason: "completion" });
+            } else {
+              const { employeeSessionName } = await import("./lib/tmux-routing.js");
+              await sendIntercomAsync(employeeSessionName(coordinator, sessionScope), { force: true, reason: "completion" });
+            }
+          } catch {
+          }
+        }
+        try {
+          await writeNotification({
+            agentId: coordinator,
+            agentRole: isCoordinatorName(coordinator) ? "COO" : "manager",
+            event: "task_group_barrier",
+            project: "",
+            summary,
+            sessionScope: sessionScope ?? void 0
+          });
+        } catch {
+        }
+        recordOrchestrationEventBestEffort({
+          eventType: "task_group.barrier_notified",
+          source: "daemon-orchestration.pollTaskGroupBarriers",
+          agentId: coordinator,
+          sessionScope,
+          payload: { groupId, title, summary }
+        });
+      } catch {
+      }
+    }
+    return firedGroupIds.length;
+  } catch (err) {
+    if (process.env.EXE_DEBUG === "1") {
+      process.stderr.write(
+        `[daemon-orchestration] pollTaskGroupBarriers error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+    return 0;
+  }
+}
+
+export {
+  getAvailableMemoryGB,
+  IDLE_NUDGE_DEDUP_MS,
+  SESSION_TTL_HOURS,
+  SESSION_CONTEXT_THRESHOLD_PCT,
+  IDLE_KILL_INTERCOM_ACK_WINDOW_MS,
+  shouldNudgeEmployee,
+  shouldKillSession,
+  classifyTtlKillReason,
+  shouldKillIdleSession,
+  pollIdleEmployees,
+  checkSessionTTL,
+  pollIdleKill,
+  REVIEW_NUDGE_COOLDOWN_MS,
+  pollReviewNudge,
+  loadNudgeState,
+  saveNudgeState,
+  createReviewNudgeRealDeps,
+  createIdleNudgeRealDeps,
+  createSessionTTLRealDeps,
+  createIdleKillRealDeps,
+  AUTO_WAKE_COOLDOWN_MS,
+  AUTO_WAKE_MAX_RETRIES,
+  CRASH_LOOP_WINDOW_MS,
+  CRASH_LOOP_THRESHOLD,
+  _resetAutoWakeState,
+  checkAutoWakeGates,
+  shouldAutoWake,
+  pollOrphanedTasks,
+  STUCK_TASK_GRACE_MS,
+  releaseStuckTasks,
+  createStuckTaskRealDeps,
+  cleanupStaleReviews,
+  createStaleReviewRealDeps,
+  createAutoWakeRealDeps,
+  COO_CONTEXT_THRESHOLD_PCT,
+  COO_RESTART_COOLDOWN_MS,
+  _resetCooRestartState,
+  pollCoordinatorContextRestart,
+  createCoordinatorRestartRealDeps,
+  ORPHAN_SIGKILL_DELAY_MS,
+  ORPHAN_MAX_AGE_SECS,
+  ORPHAN_PATTERNS,
+  HOOK_PROCESS_PATTERNS,
+  reapZombieAgentProcesses,
+  createZombieAgentReaperRealDeps,
+  reapOrphanedMcpProcesses,
+  createOrphanReaperRealDeps,
+  WORKTREE_REAPER_INTERVAL_MS,
+  reapOrphanedWorktrees,
+  createWorktreeReaperRealDeps,
+  gcStaleCheckpoints,
+  pollTaskGroupBarriers
+};