@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-CFIM43JH.js

@@ -0,0 +1,862 @@
+import {
+  init_session_kill_telemetry,
+  session_kill_telemetry_exports
+} from "./chunk-IHDHL5ML.js";
+import {
+  init_tmux_status,
+  tmux_status_exports
+} from "./chunk-DC4ZD76Y.js";
+import {
+  init_notifications,
+  init_task_scope,
+  init_tmux_routing,
+  isExeSession,
+  notifications_exports,
+  sessionScopeFilter,
+  tmux_routing_exports
+} from "./chunk-N7L33TED.js";
+import {
+  init_intercom_queue,
+  intercom_queue_exports
+} from "./chunk-NEAHEC5G.js";
+import {
+  init_session_registry,
+  session_registry_exports
+} from "./chunk-KRLOFIPI.js";
+import {
+  init_transport,
+  transport_exports
+} from "./chunk-R4M6XCMU.js";
+import {
+  employees_exports,
+  init_employees,
+  isCoordinatorName
+} from "./chunk-RUG3N6P4.js";
+import {
+  __esm,
+  __export,
+  __require,
+  __toCommonJS
+} from "./chunk-KFQGP6VL.js";
+
+// src/lib/agent-signals.ts
+var agent_signals_exports = {};
+__export(agent_signals_exports, {
+  collectAgentSignals: () => collectAgentSignals,
+  hadRecentIntercomAck: () => hadRecentIntercomAck,
+  hasNeedsReview: () => hasNeedsReview,
+  hasOpenTasks: () => hasOpenTasks,
+  hasUnreadInbox: () => hasUnreadInbox
+});
+import { readFileSync, existsSync } from "fs";
+import os from "os";
+import path from "path";
+async function hasOpenTasks(client, agentId) {
+  try {
+    const scope = sessionScopeFilter(null);
+    const result = await client.execute({
+      sql: `SELECT 1 FROM tasks
+            WHERE assigned_to = ? AND status IN ('open', 'in_progress')${scope.sql}
+            LIMIT 1`,
+      args: [agentId, ...scope.args]
+    });
+    return result.rows.length > 0;
+  } catch {
+    return CONSERVATIVE_ON_ERROR;
+  }
+}
+async function hasNeedsReview(client, agentId) {
+  try {
+    const scope = sessionScopeFilter(null);
+    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) {
+  try {
+    const result = await client.execute({
+      sql: `SELECT 1 FROM messages
+            WHERE target_agent = ? AND status = 'pending'
+            LIMIT 1`,
+      args: [agentId]
+    });
+    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 = readFileSync(intercomLog, "utf8");
+    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 [open, review, inbox] = await Promise.all([
+    hasOpenTasks(client, agentId),
+    hasNeedsReview(client, agentId),
+    hasUnreadInbox(client, agentId)
+  ]);
+  return {
+    hasOpenTasks: open,
+    hasNeedsReview: review,
+    hasUnreadInbox: inbox,
+    hadRecentIntercomAck: hadRecentIntercomAck(sessionName, intercomAckWindowMs, nowMs)
+  };
+}
+var CONSERVATIVE_ON_ERROR;
+var init_agent_signals = __esm({
+  "src/lib/agent-signals.ts"() {
+    "use strict";
+    init_task_scope();
+    CONSERVATIVE_ON_ERROR = true;
+  }
+});
+
+// src/lib/daemon-orchestration.ts
+init_tmux_routing();
+init_task_scope();
+init_employees();
+import { execSync } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var IDLE_NUDGE_DEDUP_MS = Number(process.env.EXE_NUDGE_INTERVAL_MS) || 6e4;
+var SESSION_TTL_HOURS = Number(process.env.EXE_SESSION_TTL_HOURS) || 4;
+var SESSION_CONTEXT_THRESHOLD_PCT = Number(process.env.EXE_CONTEXT_KILL_PCT) || 50;
+var IDLE_KILL_INTERCOM_ACK_WINDOW_MS = Number(process.env.EXE_INTERCOM_ACK_WINDOW_MS) || 1e4;
+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") 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 {
+    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 task = await deps.queryOpenTask(entry.agentId);
+    if (!task) continue;
+    if (shouldNudgeEmployee(state, true, lastMs, now, IDLE_NUDGE_DEDUP_MS)) {
+      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 {
+    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) {
+      if (deps.hasActiveTasks) {
+        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;
+        }
+      }
+      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
+      });
+      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 {
+    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") {
+      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 = __require("path").join(
+            __require("os").homedir(),
+            ".exe-os",
+            "session-cache",
+            `current-task-${instanceName}.json`
+          );
+          if (!__require("fs").existsSync(markerPath)) {
+            signals.hasOpenTasks = false;
+          }
+        } catch {
+        }
+      }
+    }
+    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
+    });
+    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
+      });
+      deps.killSession(entry.windowName);
+      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 {
+    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 {
+      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 {
+    }
+  }
+  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(readFileSync2(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: () => {
+      const { listTmuxSessions } = (init_tmux_status(), __toCommonJS(tmux_status_exports));
+      return listTmuxSessions();
+    },
+    getSessionState: (sessionName) => {
+      const { getSessionState } = (init_tmux_routing(), __toCommonJS(tmux_routing_exports));
+      return getSessionState(sessionName);
+    },
+    countReviewsForScope: async (sessionScope) => {
+      const client = getClient();
+      const result = await client.execute({
+        sql: `SELECT COUNT(*) as cnt FROM tasks
+              WHERE status = 'needs_review'
+                AND (session_scope = ? OR session_scope IS NULL)`,
+        args: [sessionScope]
+      });
+      return Number(result.rows[0]?.cnt ?? 0);
+    },
+    sendNudge: (sessionName) => {
+      const { queueIntercom: qi } = (init_intercom_queue(), __toCommonJS(intercom_queue_exports));
+      qi(sessionName, "review nudge: pending reviews");
+    },
+    persistState: saveNudgeState
+  };
+}
+function createIdleNudgeRealDeps(getClient) {
+  return {
+    listRegisteredSessions: () => {
+      const { listSessions } = (init_session_registry(), __toCommonJS(session_registry_exports));
+      return listSessions();
+    },
+    listTmuxSessions: () => {
+      const { listTmuxSessions } = (init_tmux_status(), __toCommonJS(tmux_status_exports));
+      return listTmuxSessions();
+    },
+    getSessionState: (sessionName) => {
+      const { getSessionState } = (init_tmux_routing(), __toCommonJS(tmux_routing_exports));
+      return getSessionState(sessionName);
+    },
+    queryOpenTask: async (agentId) => {
+      const client = getClient();
+      const doScope = sessionScopeFilter(null);
+      const result = await client.execute({
+        sql: `SELECT id, title, priority FROM tasks
+              WHERE assigned_to = ? AND status IN ('open', 'in_progress')${doScope.sql}
+              ORDER BY CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 ELSE 2 END
+              LIMIT 1`,
+        args: [agentId, ...doScope.args]
+      });
+      if (result.rows.length === 0) return null;
+      const row = result.rows[0];
+      return row;
+    },
+    sendIntercom: (sessionName) => {
+      const { sendIntercom } = (init_tmux_routing(), __toCommonJS(tmux_routing_exports));
+      return sendIntercom(sessionName);
+    }
+  };
+}
+function createSessionTTLRealDeps(getClient) {
+  return {
+    listRegisteredSessions: () => {
+      const { listSessions } = (init_session_registry(), __toCommonJS(session_registry_exports));
+      return listSessions();
+    },
+    listTmuxSessions: () => {
+      const { listTmuxSessions } = (init_tmux_status(), __toCommonJS(tmux_status_exports));
+      return listTmuxSessions();
+    },
+    getSessionCreatedEpoch: (sessionName) => {
+      try {
+        const out = execSync(
+          `tmux display-message -t ${JSON.stringify(sessionName)} -p '#{session_created}' 2>/dev/null`,
+          { encoding: "utf8", timeout: 3e3 }
+        ).trim();
+        const epoch = parseInt(out, 10);
+        return isNaN(epoch) ? null : epoch;
+      } catch {
+        return null;
+      }
+    },
+    parseContextPercentage: (sessionName) => {
+      const { parseContextPercentage } = (init_tmux_status(), __toCommonJS(tmux_status_exports));
+      return parseContextPercentage(sessionName);
+    },
+    killSession: (sessionName) => {
+      const { getTransport } = (init_transport(), __toCommonJS(transport_exports));
+      getTransport().kill(sessionName);
+    },
+    hasActiveTasks: getClient ? async (agentId) => {
+      const client = getClient();
+      const scope = sessionScopeFilter(null);
+      const result = await client.execute({
+        sql: `SELECT 1 FROM tasks
+                  WHERE assigned_to = ? AND status IN ('open', 'in_progress')${scope.sql}
+                  LIMIT 1`,
+        args: [agentId, ...scope.args]
+      });
+      return result.rows.length > 0;
+    } : void 0,
+    recordKill: (input) => {
+      const { recordSessionKill } = (init_session_kill_telemetry(), __toCommonJS(session_kill_telemetry_exports));
+      void recordSessionKill(input);
+    }
+  };
+}
+function createIdleKillRealDeps(getClient, intercomAckWindowMs) {
+  return {
+    listRegisteredSessions: () => {
+      const { listSessions } = (init_session_registry(), __toCommonJS(session_registry_exports));
+      return listSessions();
+    },
+    listTmuxSessions: () => {
+      const { listTmuxSessions } = (init_tmux_status(), __toCommonJS(tmux_status_exports));
+      return listTmuxSessions();
+    },
+    getSessionState: (sessionName) => {
+      const { getSessionState } = (init_tmux_routing(), __toCommonJS(tmux_routing_exports));
+      return getSessionState(sessionName);
+    },
+    collectSignals: async (agentId, sessionName) => {
+      const { collectAgentSignals: collectAgentSignals2 } = (init_agent_signals(), __toCommonJS(agent_signals_exports));
+      return collectAgentSignals2(getClient(), agentId, sessionName, intercomAckWindowMs);
+    },
+    killSession: (sessionName) => {
+      const { getTransport } = (init_transport(), __toCommonJS(transport_exports));
+      getTransport().kill(sessionName);
+    },
+    recordKill: (input) => {
+      const { recordSessionKill } = (init_session_kill_telemetry(), __toCommonJS(session_kill_telemetry_exports));
+      void recordSessionKill(input);
+    }
+  };
+}
+var AUTO_WAKE_COOLDOWN_MS = 5 * 60 * 1e3;
+var AUTO_WAKE_MAX_RETRIES = 3;
+var _autoWakeLastSpawn = /* @__PURE__ */ new Map();
+var _autoWakeTaskRetries = /* @__PURE__ */ new Map();
+function _resetAutoWakeState() {
+  _autoWakeLastSpawn.clear();
+  _autoWakeTaskRetries.clear();
+}
+function shouldAutoWake(input) {
+  if (isCoordinatorName(input.agentId)) return false;
+  if (input.hasRunningSession) return false;
+  if (input.nowMs - input.lastSpawnMs < input.cooldownMs) return false;
+  return true;
+}
+async function pollOrphanedTasks(deps, nowMs = Date.now()) {
+  let liveSessions;
+  try {
+    liveSessions = deps.listTmuxSessions();
+  } catch {
+    return [];
+  }
+  const liveAgents = /* @__PURE__ */ new Set();
+  for (const session of liveSessions) {
+    const agent = deps.parseAgentFromSession(session);
+    if (agent) liveAgents.add(agent);
+  }
+  const coordinatorSessions = liveSessions.filter((s) => isExeSession(s));
+  let tasksByAgent;
+  try {
+    tasksByAgent = await deps.queryTasksByAgent();
+  } catch {
+    return [];
+  }
+  const coordinatorSet = new Set(coordinatorSessions);
+  const agentTasks = /* @__PURE__ */ new Map();
+  for (const t of tasksByAgent) {
+    const scope = t.sessionScope || coordinatorSessions[0] || null;
+    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: liveAgents.has(agentId),
+      lastSpawnMs: _autoWakeLastSpawn.get(agentId) ?? 0,
+      nowMs,
+      cooldownMs: AUTO_WAKE_COOLDOWN_MS
+    })) {
+      continue;
+    }
+    const topTask = tasks[0];
+    const retries = _autoWakeTaskRetries.get(topTask.taskId) ?? 0;
+    if (retries >= AUTO_WAKE_MAX_RETRIES) {
+      try {
+        await deps.markTaskBlocked(
+          topTask.taskId,
+          `Auto-wake failed ${AUTO_WAKE_MAX_RETRIES} times \u2014 marking blocked for manual intervention`
+        );
+        process.stderr.write(
+          `[auto-wake] ${agentId} task ${topTask.taskId} exceeded ${AUTO_WAKE_MAX_RETRIES} retries \u2014 marked blocked
+`
+        );
+      } 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 = deps.ensureEmployee(agentId, sessionScope);
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[auto-wake] Failed to spawn ${agentId}: ${result.error ?? "unknown"}
+`
+        );
+        continue;
+      }
+      _autoWakeLastSpawn.set(agentId, nowMs);
+      _autoWakeTaskRetries.set(topTask.taskId, retries + 1);
+      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 {
+    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);
+  }
+  let tasks;
+  try {
+    tasks = await deps.queryInProgressTasks();
+  } catch {
+    return [];
+  }
+  const released = [];
+  for (const t of tasks) {
+    if (liveAgents.has(t.agentId)) continue;
+    const updatedMs = new Date(t.updatedAt).getTime();
+    if (isNaN(updatedMs) || nowMs - updatedMs < STUCK_TASK_GRACE_MS) continue;
+    const ageMinutes = Math.round((nowMs - updatedMs) / 6e4);
+    const reason = `[auto-release] Agent "${t.agentId}" session is dead and task has been in_progress for ${ageMinutes}m with no update. Marked blocked for triage.`;
+    try {
+      await deps.markTaskBlocked(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 blocked
+`
+      );
+      if (deps.notifyOrphan) {
+        try {
+          await deps.notifyOrphan(t.taskId, t.agentId);
+        } catch {
+        }
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[stuck-release] Failed to release ${t.taskId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return released;
+}
+function createStuckTaskRealDeps(getClient) {
+  return {
+    listTmuxSessions: () => {
+      const { listTmuxSessions } = (init_tmux_status(), __toCommonJS(tmux_status_exports));
+      return listTmuxSessions();
+    },
+    queryInProgressTasks: async () => {
+      const client = getClient();
+      const result = await client.execute({
+        sql: `SELECT id, assigned_to, session_scope, updated_at FROM tasks
+              WHERE status = 'in_progress'
+              ORDER BY updated_at ASC`,
+        args: []
+      });
+      return result.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)
+      }));
+    },
+    markTaskBlocked: async (taskId, reason) => {
+      const client = getClient();
+      await client.execute({
+        sql: `UPDATE tasks SET status = 'blocked', result = ?, updated_at = ? WHERE id = ?`,
+        args: [reason, (/* @__PURE__ */ new Date()).toISOString(), taskId]
+      });
+    },
+    parseAgentFromSession: (sessionName) => {
+      const { baseAgentName } = (init_employees(), __toCommonJS(employees_exports));
+      if (!sessionName.includes("-")) return null;
+      const agentPart = sessionName.split("-")[0];
+      return baseAgentName(agentPart);
+    },
+    notifyOrphan: async (taskId, agentId) => {
+      const { writeNotification } = (init_notifications(), __toCommonJS(notifications_exports));
+      await writeNotification({
+        agentId,
+        agentRole: "employee",
+        event: "orphan_task",
+        project: "",
+        summary: `Agent "${agentId}" session died \u2014 task ${taskId.slice(0, 8)} auto-released to blocked for triage`
+      });
+    }
+  };
+}
+function createAutoWakeRealDeps(getClient, projectDir) {
+  return {
+    listTmuxSessions: () => {
+      const { listTmuxSessions } = (init_tmux_status(), __toCommonJS(tmux_status_exports));
+      return listTmuxSessions();
+    },
+    queryTasksByAgent: async () => {
+      const client = getClient();
+      const result = await client.execute({
+        sql: `SELECT assigned_to, id, priority, session_scope FROM tasks
+              WHERE status IN ('open', 'in_progress')
+              ORDER BY
+                CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 WHEN 'p2' THEN 2 ELSE 3 END,
+                created_at ASC`,
+        args: []
+      });
+      return result.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: (agentName, scope) => {
+      const { ensureEmployee } = (init_tmux_routing(), __toCommonJS(tmux_routing_exports));
+      return ensureEmployee(agentName, scope, projectDir);
+    },
+    markTaskBlocked: async (taskId, reason) => {
+      const client = getClient();
+      await client.execute({
+        sql: `UPDATE tasks SET status = 'blocked', result = ?, updated_at = ? WHERE id = ?`,
+        args: [reason, (/* @__PURE__ */ new Date()).toISOString(), taskId]
+      });
+    },
+    parseAgentFromSession: (sessionName) => {
+      const { baseAgentName } = (init_employees(), __toCommonJS(employees_exports));
+      if (!sessionName.includes("-")) return null;
+      const agentPart = sessionName.split("-")[0];
+      return baseAgentName(agentPart);
+    }
+  };
+}
+var ORPHAN_SIGKILL_DELAY_MS = 5e3;
+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"
+];
+function reapOrphanedMcpProcesses(deps) {
+  const lines = deps.listProcesses();
+  const reaped = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^(\d+)\s+1\s+(.+)$/);
+    if (!match) continue;
+    const pid = parseInt(match[1], 10);
+    const args = match[2];
+    if (pid === deps.selfPid) continue;
+    if (!ORPHAN_PATTERNS.some((pat) => args.includes(pat))) continue;
+    try {
+      deps.killProcess(pid, "SIGTERM");
+    } catch {
+      continue;
+    }
+    const desc = `PID ${pid} (${args.slice(0, 100)})`;
+    reaped.push(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,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
+  };
+}
+
+export {
+  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,
+  _resetAutoWakeState,
+  shouldAutoWake,
+  pollOrphanedTasks,
+  STUCK_TASK_GRACE_MS,
+  releaseStuckTasks,
+  createStuckTaskRealDeps,
+  createAutoWakeRealDeps,
+  ORPHAN_SIGKILL_DELAY_MS,
+  ORPHAN_PATTERNS,
+  reapOrphanedMcpProcesses,
+  createOrphanReaperRealDeps
+};