@askexenow/exe-os 0.9.312 → 0.9.313

package/dist/lib/exe-daemon.js

@@ -1,15 +1,15 @@
 import {
   clearDaemonReady,
   writeDaemonReady
-} from "../chunk-XXJRZ75E.js";
+} from "../chunk-RV634O2W.js";
 import {
   pushNotifyAsync
-} from "../chunk-IBDPPBFK.js";
+} from "../chunk-R5IPZ5ZC.js";
 import {
   getMcpToolFamily,
   inferMcpRuntime,
   recordMcpHttpEvent
-} from "../chunk-5A6KTWQL.js";
+} from "../chunk-WOTKNUKK.js";
 import {
   deserializeArgs,
   serializeResultSet
@@ -18,17 +18,19 @@ import {
   ensureDaemonToken,
   reconcileSessionAgentIdentity,
   shouldEnforceSessionIdentity
-} from "../chunk-RQ7OVXUZ.js";
+} from "../chunk-V2CZVZUO.js";
 import {
   findScopedDuplicate,
   governMemoryRecord,
   schedulePostWriteMemoryHygiene
-} from "../chunk-MQCTK6EF.js";
+} from "../chunk-RRYJTPVW.js";
 import "../chunk-Y25OJWOQ.js";
 import {
-  consumeRestartIntent,
-  logRestartEvent
-} from "../chunk-RVXWGPD3.js";
+  attributeSignalSource,
+  consumeRestartIntentDetail,
+  logRestartEvent,
+  requestRestart
+} from "../chunk-75TM3APG.js";
 import {
   DAEMON_RSS_RESTART_DEBOUNCE,
   DAEMON_RSS_STARTUP_GRACE_MS,
@@ -47,14 +49,14 @@ import {
 } from "../chunk-7XGDTKHX.js";
 import {
   resolveEmbeddingsEnabled
-} from "../chunk-PHFPIUWU.js";
+} from "../chunk-KWOAM7TA.js";
 import {
   logBoot,
   logCrash,
   logDaemonHealth,
   logHeartbeat,
   logShutdown
-} from "../chunk-VQRTO7IS.js";
+} from "../chunk-H73TUI4Y.js";
 import {
   getEventLoopLagMs,
   isEventLoopDegraded,
@@ -68,8 +70,8 @@ import {
   EXE_AI_DIR,
   MODELS_DIR,
   resolveEmbedModelFile
-} from "../chunk-DFIOOK5R.js";
-import "../chunk-65DBIEM2.js";
+} from "../chunk-WCES22KG.js";
+import "../chunk-SHIICYJW.js";
 import "../chunk-MLKGABMK.js";
 
 // src/lib/exe-daemon.ts
@@ -95,7 +97,11 @@ var DAEMON_ALLOWED_SCHEMA_SQL_RE = [
   // Internal telemetry tables are created lazily from hooks and daemon helpers.
   // Keep this allowlist narrow: idempotent CREATEs for known tables/indexes only.
   /^\s*CREATE\s+TABLE\s+IF\s+NOT\s+EXISTS\s+session_events\s*\(/i,
-  /^\s*CREATE\s+INDEX\s+IF\s+NOT\s+EXISTS\s+idx_session_events_(?:agent_time|session_index|scope_agent_time)\s+ON\s+session_events\s*\(/i,
+  // Bug 2417b0b1: idx_session_events_created_at (the retention-sweep index added
+  // in db9c95c8) was missing from this allowlist, so its idempotent CREATE INDEX
+  // was rejected on every session-event write — flooding daemon-health.log with
+  // "Blocked unsafe daemon SQL" db_errors. Added created_at to the alternation.
+  /^\s*CREATE\s+INDEX\s+IF\s+NOT\s+EXISTS\s+idx_session_events_(?:agent_time|session_index|scope_agent_time|created_at)\s+ON\s+session_events\s*\(/i,
   /^\s*CREATE\s+TABLE\s+IF\s+NOT\s+EXISTS\s+orchestration_events\s*\(/i,
   /^\s*CREATE\s+INDEX\s+IF\s+NOT\s+EXISTS\s+idx_orch_events_(?:ts|task|agent|type)\s+ON\s+orchestration_events\s*\(/i,
   // Cloud sync metadata table — created lazily by getCloudReuploadRequired().
@@ -479,6 +485,7 @@ var _mcpSessionDetailsRef = null;
 var _activeWrites = 0;
 var _mcpHttpReady = Promise.resolve();
 var _daemonToken = "";
+var _boundMcpPort;
 var _injectedRegisterAllTools = null;
 function injectRegisterAllTools(fn) {
   _injectedRegisterAllTools = fn;
@@ -585,6 +592,15 @@ async function capturePaneAsync(session, lines = 20) {
     return "";
   }
 }
+function classifyPaneState(pane) {
+  const busyPattern = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
+  if (!pane.includes("\u276F") && !pane.includes("Claude Code") && !busyPattern.test(pane) && !/Running…/.test(pane)) {
+    if (/\$\s*$/.test(pane) || /% $/.test(pane.trimEnd())) return "no_claude";
+  }
+  if (/Running…/.test(pane)) return "tool";
+  if (busyPattern.test(pane)) return "thinking";
+  return "idle";
+}
 async function killTmuxSessionAsync(session, timeout = 3e3) {
   try {
     await execFileAsync("tmux", ["kill-session", "-t", session], { timeout });
@@ -692,20 +708,43 @@ var _startedAt2 = Date.now();
 process.env.EXE_DAEMON_STARTED_AT_ISO ??= new Date(_startedAt2).toISOString();
 var TIMER_TRACE_BOOT_WINDOW_MS = Number(process.env.EXE_TIMER_TRACE_BOOT_WINDOW_MS) || 10 * 60 * 1e3;
 var TIMER_TRACE_SLOW_MS = Number(process.env.EXE_TIMER_TRACE_SLOW_MS) || 500;
+var TIMER_TIMEOUT_MS = Number(process.env.EXE_TIMER_TIMEOUT_MS) || 1e4;
+var _timerInFlight = /* @__PURE__ */ new Set();
 function shouldTraceDaemonTimer(durationMs = 0) {
   return Date.now() - _startedAt2 < TIMER_TRACE_BOOT_WINDOW_MS || durationMs >= TIMER_TRACE_SLOW_MS;
 }
 var yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
 async function traceDaemonTimer(name, fn) {
+  if (_timerInFlight.has(name)) {
+    process.stderr.write(`[exed] Timer SKIPPED (overlap): ${name} \u2014 previous tick still running
+`);
+    return void 0;
+  }
+  _timerInFlight.add(name);
   const probe = captureClockProbe();
   const traceStart = shouldTraceDaemonTimer();
   if (traceStart) {
     process.stderr.write(`[exed] Timer start: ${name}
 `);
   }
+  const timeoutHandle = setTimeout(() => {
+    process.stderr.write(
+      `[exed] Timer TIMEOUT WARNING: ${name} has been running for >${TIMER_TIMEOUT_MS / 1e3}s \u2014 likely blocking the event loop
+`
+    );
+    logDaemonHealth({
+      event: "timer_timeout",
+      pid: process.pid,
+      message: `Timer ${name} exceeded ${TIMER_TIMEOUT_MS / 1e3}s budget`,
+      data: { timer: name, timeoutMs: TIMER_TIMEOUT_MS }
+    });
+  }, TIMER_TIMEOUT_MS);
+  timeoutHandle.unref();
   try {
     return await fn();
   } finally {
+    clearTimeout(timeoutHandle);
+    _timerInFlight.delete(name);
     const span = measureSpan(probe);
     const durationMs = Math.round(span.monoMs);
     const slept = span.sleptMs > 1e3;
@@ -722,7 +761,6 @@ async function traceDaemonTimer(name, fn) {
           type: "timer_duration",
           timer: name,
           durationMs,
-          // monotonic — the value dashboards/alerts should trust
           wallMs: Math.round(span.wallMs),
           sleptMs: Math.round(span.sleptMs),
           clockJump: slept,
@@ -868,6 +906,17 @@ function isEventLoopBlockedNow(freshMs = EVENT_LOOP_BLOCKED_FRESH_MS) {
     return false;
   }
 }
+function eventLoopHeartbeatPath() {
+  return path3.join(os2.homedir(), ".exe-os", "session-cache", "event-loop-heartbeat");
+}
+function touchEventLoopHeartbeat() {
+  try {
+    const p = eventLoopHeartbeatPath();
+    mkdirSync2(path3.dirname(p), { recursive: true });
+    writeFileSync3(p, String(Date.now()));
+  } catch {
+  }
+}
 function checkLaunchdPlistHealth() {
   try {
     if (process.platform !== "darwin") return;
@@ -1101,7 +1150,7 @@ async function loadModel() {
         void (async () => {
           try {
             if (_storeInitialized) {
-              const { writeNotification } = await import("../notifications-UP7WQGG4.js");
+              const { writeNotification } = await import("../notifications-Q5NEAP6K.js");
               await writeNotification({
                 agentId: "exe",
                 agentRole: "system",
@@ -1217,7 +1266,7 @@ function disableEmbeddingsForInferenceTimeouts() {
   void (async () => {
     try {
       if (_storeInitialized) {
-        const { writeNotification } = await import("../notifications-UP7WQGG4.js");
+        const { writeNotification } = await import("../notifications-Q5NEAP6K.js");
         await writeNotification({
           agentId: "exe",
           agentRole: "system",
@@ -1428,7 +1477,7 @@ async function shutdown(exitCode = 0) {
     }
   }
   try {
-    const { createBackupAsync, enforceRetention, hasRecentBackup } = await import("../db-backup-EORG4LBO.js");
+    const { createBackupAsync, enforceRetention, hasRecentBackup } = await import("../db-backup-BTL2FBBL.js");
     const PRE_RESTART_DEDUP_MS = 2 * 60 * 1e3;
     if (hasRecentBackup("pre-restart", PRE_RESTART_DEDUP_MS)) {
       const deleted = enforceRetention("pre-restart");
@@ -1459,12 +1508,12 @@ async function shutdown(exitCode = 0) {
 `);
   }
   try {
-    const { stopProjectionWorker } = await import("../projection-worker-HWY37MNC.js");
+    const { stopProjectionWorker } = await import("../projection-worker-HELRBNDR.js");
     stopProjectionWorker();
   } catch {
   }
   try {
-    const { disposeShards } = await import("../shard-manager-KUCJPLC6.js");
+    const { disposeShards } = await import("../shard-manager-RASGFMGS.js");
     disposeShards();
   } catch {
   }
@@ -1525,7 +1574,7 @@ async function handleHealthCheck(socket, requestId) {
   let pipelineStatus = "unknown";
   if (dbConnected) {
     try {
-      await import("../pipeline-router-5CRWKESM.js");
+      await import("../pipeline-router-5IBJBH7P.js");
       pipelineStatus = "ok";
     } catch {
       pipelineStatus = "unavailable";
@@ -1921,7 +1970,7 @@ async function _writeMemoryRecordInner(entry) {
   const vRow = await client.execute({ sql: "SELECT version FROM memories WHERE id = ?", args: [id] });
   const version = Number(vRow.rows[0]?.version) || 0;
   try {
-    const { insertOntologyForMemory } = await import("../agentic-ontology-6KBAXLSJ.js");
+    const { insertOntologyForMemory } = await import("../agentic-ontology-AAUATKUS.js");
     await insertOntologyForMemory({
       id,
       agent_id: record.agent_id,
@@ -1944,18 +1993,20 @@ async function _writeMemoryRecordInner(entry) {
   return id;
 }
 var MEMORY_DRAIN_INTERVAL_MS = 30 * 1e3;
+var MEMORY_DRAIN_BATCH = Math.max(1, Number(process.env.EXE_MEMORY_DRAIN_BATCH) || 25);
 function startMemoryQueueDrain() {
   const drain = async () => traceDaemonTimer("memory_queue_drain", async () => {
     fired("memory_queue_drain");
     if (!await ensureStoreForPolling()) return;
     try {
-      const { ackQueue, claimQueue, retryQueueEntries } = await import("../memory-queue-VAE6WMSS.js");
+      const { ackQueue, claimQueue, retryQueueEntries } = await import("../memory-queue-3Q5P43AM.js");
       const lease = claimQueue();
       if (!lease || lease.entries.length === 0) return;
       acted("memory_queue_drain");
       const entries = lease.entries;
       let processed = 0;
       const retryEntries = [];
+      let sinceYield = 0;
       for (const entry of entries) {
         if (!entry.raw_text || entry.raw_text.length < 10) continue;
         try {
@@ -1968,6 +2019,10 @@ function startMemoryQueueDrain() {
 `
           );
         }
+        if (++sinceYield >= MEMORY_DRAIN_BATCH) {
+          sinceYield = 0;
+          await yieldToEventLoop();
+        }
       }
       if (retryEntries.length === 0) {
         ackQueue(lease.leasePath);
@@ -2005,7 +2060,7 @@ function startMessageQueueDrain() {
     fired("message_queue_drain");
     if (!await ensureStoreForPolling()) return;
     try {
-      const { claimMessageQueue, ackMessageQueue } = await import("../message-queue-client-4VDU6BZY.js");
+      const { claimMessageQueue, ackMessageQueue } = await import("../message-queue-client-IXYLJJVJ.js");
       const lease = claimMessageQueue();
       if (!lease || lease.entries.length === 0) return;
       acted("message_queue_drain");
@@ -2021,14 +2076,20 @@ function startMessageQueueDrain() {
           const id = randomUUID2();
           await client.execute({
             sql: `INSERT INTO messages (id, source_agent, target_agent, content, priority, status, created_at)
-                  VALUES (?, ?, ?, ?, ?, 'delivered', ?)`,
+                  VALUES (?, ?, ?, ?, ?, 'pending_delivery', ?)`,
             args: [id, entry.source_agent, entry.target_agent, entry.content, entry.priority, now]
           });
+          let delivered = false;
           const exeSession = resolveExeSession();
           if (exeSession) {
             const sessionName = employeeSessionName(entry.target_agent, exeSession);
-            await sendIntercomAsync(sessionName, { force: true });
+            const result = await sendIntercomAsync(sessionName, { force: true });
+            delivered = result !== "failed";
           }
+          await client.execute({
+            sql: `UPDATE messages SET status = ? WHERE id = ?`,
+            args: [delivered ? "delivered" : "pending_delivery", id]
+          });
           processed++;
         } catch (err) {
           retryEntries.push(entry);
@@ -2037,6 +2098,7 @@ function startMessageQueueDrain() {
 `
           );
         }
+        await yieldToEventLoop();
       }
       if (retryEntries.length === 0) {
         ackMessageQueue(lease.leasePath);
@@ -2058,6 +2120,49 @@ function startMessageQueueDrain() {
   process.stderr.write(`[exed] Message queue drain started (every ${MESSAGE_DRAIN_INTERVAL_MS / 1e3}s)
 `);
 }
+async function retryPendingMessages() {
+  try {
+    if (!await ensureStoreForPolling()) return;
+    const { getClient: getDbClient } = await import("./database.js");
+    const client = getDbClient();
+    const { sendIntercomAsync, employeeSessionName, resolveExeSession } = await import("./tmux-routing.js");
+    const rows = await client.execute({
+      sql: `SELECT id, target_agent FROM messages WHERE status = 'pending_delivery' ORDER BY created_at ASC LIMIT 100`,
+      args: []
+    });
+    if (!rows.rows || rows.rows.length === 0) return;
+    process.stderr.write(`[exed] Retrying ${rows.rows.length} pending_delivery message(s) from previous daemon lifecycle...
+`);
+    const exeSession = resolveExeSession();
+    let retried = 0;
+    for (const row of rows.rows) {
+      const id = row.id;
+      const targetAgent = row.target_agent;
+      try {
+        let delivered = false;
+        if (exeSession) {
+          const sessionName = employeeSessionName(targetAgent, exeSession);
+          const result = await sendIntercomAsync(sessionName, { force: true });
+          delivered = result !== "failed";
+        }
+        await client.execute({
+          sql: `UPDATE messages SET status = ? WHERE id = ?`,
+          args: [delivered ? "delivered" : "delivery_failed", id]
+        });
+        if (delivered) retried++;
+        await yieldToEventLoop();
+      } catch (err) {
+        process.stderr.write(`[exed] Pending message retry error for ${id}: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+    }
+    if (retried > 0) process.stderr.write(`[exed] Pending message retry: ${retried}/${rows.rows.length} delivered successfully.
+`);
+  } catch (err) {
+    process.stderr.write(`[exed] Pending message retry sweep error: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
 function startServer() {
   mkdirSync2(path3.dirname(SOCKET_PATH), { recursive: true });
   try {
@@ -2476,13 +2581,18 @@ async function startMcpHttpServer() {
       }
       return "unknown";
     }, sendJsonRpcError2 = function(res, status, message, id, extra) {
-      res.writeHead(status, { "Content-Type": "application/json" });
+      const correlationId = randomUUID();
+      const headers = {
+        "Content-Type": "application/json",
+        "X-Exe-Correlation-Id": correlationId
+      };
+      res.writeHead(status, headers);
       res.end(JSON.stringify({
         jsonrpc: "2.0",
-        error: { code: -32e3, message },
+        error: { code: -32e3, message, data: { correlationId } },
         id
       }));
-      recordMcpHttpEvent({ level: "warn", message, status, ...extra });
+      recordMcpHttpEvent({ level: "warn", message, status, correlationId, ...extra });
     };
     var parseDurationMs = parseDurationMs2, formatHostAuthority = formatHostAuthority2, formatOriginBase = formatOriginBase2, isAllowedHostAndOrigin = isAllowedHostAndOrigin2, closeMcpSession = closeMcpSession2, mcpSessionOwnerKey = mcpSessionOwnerKey2, resolveMcpSessionDetails = resolveMcpSessionDetails2, evictDuplicateMcpSessions = evictDuplicateMcpSessions2, pruneStaleRecoveryAliases = pruneStaleRecoveryAliases2, getRecoveredMcpSession = getRecoveredMcpSession2, awaitPendingMcpInit2 = awaitPendingMcpInit3, sweepStaleMcpSessions = sweepStaleMcpSessions2, getJsonRpcId = getJsonRpcId2, sendJsonRpcError = sendJsonRpcError2;
     process.stderr.write("[exed] MCP HTTP: importing SDK modules...\n");
@@ -2549,7 +2659,7 @@ async function startMcpHttpServer() {
     }
     process.stderr.write("[exed] MCP HTTP: DB ready\n");
     _storeInitialized = true;
-    const { initLicenseGate, getCachedLicenseGate } = await import("../license-gate-7SDHCJUO.js");
+    const { initLicenseGate, getCachedLicenseGate } = await import("../license-gate-PZOP7S2S.js");
     const gateResult = await initLicenseGate();
     if (!gateResult.hasKey) {
       process.stderr.write(
@@ -2564,13 +2674,13 @@ async function startMcpHttpServer() {
     let _cachedWrapTelemetry = null;
     async function getWrapTelemetry() {
       if (!_cachedWrapTelemetry) {
-        const { wrapServerWithTelemetry } = await import("../tool-telemetry-BS5JXM5M.js");
+        const { wrapServerWithTelemetry } = await import("../tool-telemetry-CDNPES5B.js");
         _cachedWrapTelemetry = wrapServerWithTelemetry;
       }
       return _cachedWrapTelemetry;
     }
     Promise.all([
-      import("../tool-capability-index-ZEXBWKUZ.js"),
+      import("../tool-capability-index-SHYCBE2Z.js"),
       import("../tool-gates-3IC7DK4R.js")
     ]).then(async ([{ getToolCapabilityIndex }, { TOOL_CATEGORIES }]) => {
       const gateState = getCachedLicenseGate();
@@ -2634,7 +2744,7 @@ async function startMcpHttpServer() {
       if (!token || token === header) return false;
       if (token === _daemonToken) return true;
       try {
-        const { verifyAccessToken } = await import("../oauth-server-EWUL7DMD.js");
+        const { verifyAccessToken } = await import("../oauth-server-F4QWESK2.js");
         const result = verifyAccessToken(token);
         return result.valid;
       } catch {
@@ -2837,8 +2947,8 @@ async function startMcpHttpServer() {
       }
       res.setHeader("Access-Control-Allow-Origin", "http://127.0.0.1");
       res.setHeader("Access-Control-Allow-Methods", "POST, GET, DELETE, OPTIONS");
-      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Agent-Id, X-Agent-Role, X-Exe-Session, X-Project-Name, Mcp-Session-Id");
-      res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Agent-Id, X-Agent-Role, X-Exe-Session, X-Exe-Session-Name, X-Project-Name, Mcp-Session-Id");
+      res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id, X-Exe-Correlation-Id");
       const url = new URL(req.url || "/", `http://${MCP_HTTP_HOST}:${MCP_HTTP_PORT}`);
       if (req.method === "GET" && url.pathname === "/health") {
         const elLag = getEventLoopLagMs();
@@ -2869,12 +2979,14 @@ async function startMcpHttpServer() {
         return;
       }
       if (_drainingWrites) {
-        res.writeHead(503, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Server shutting down" }));
+        const correlationId = randomUUID();
+        res.writeHead(503, { "Content-Type": "application/json", "X-Exe-Correlation-Id": correlationId });
+        res.end(JSON.stringify({ error: "Server shutting down", correlationId }));
+        recordMcpHttpEvent({ level: "warn", message: "Server shutting down", status: 503, method: req.method, correlationId });
         return;
       }
       try {
-        const { handleOAuthRoute } = await import("../oauth-server-EWUL7DMD.js");
+        const { handleOAuthRoute } = await import("../oauth-server-F4QWESK2.js");
         const handled = await handleOAuthRoute(req, res, url, MCP_HTTP_PORT);
         if (handled) return;
       } catch (err) {
@@ -2906,7 +3018,7 @@ async function startMcpHttpServer() {
         for await (const chunk of req) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
         const rawBody = Buffer.concat(chunks);
         try {
-          const { loadWebhookConfig, verifyHmac, processWebhook } = await import("../webhook-pipe-DHIGZHPW.js");
+          const { loadWebhookConfig, verifyHmac, processWebhook } = await import("../webhook-pipe-S4CWK6H5.js");
           const webhookConfig = await loadWebhookConfig();
           const serviceConfig = webhookConfig[serviceName];
           if (!serviceConfig) {
@@ -3002,7 +3114,7 @@ async function startMcpHttpServer() {
             contextPct: body.context_pct
           });
           if (body.context_pct !== void 0 && body.context_pct > 70) {
-            void import("../orchestration-events-PZLLPCKY.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+            void import("../orchestration-events-7SNWRJYE.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
               recordOE({
                 eventType: "context.pressure",
                 source: "exe-daemon.heartbeat",
@@ -3084,7 +3196,7 @@ async function startMcpHttpServer() {
         agentRole = "employee";
       }
       const projectNameHeader = req.headers["x-project-name"] || "";
-      let sessionHint = req.headers["x-exe-session"] || "";
+      let sessionHint = req.headers["x-exe-session-name"] || req.headers["x-exe-session"] || "";
       if (sessionHint.includes("$(") || sessionHint.includes("#{") || sessionHint.includes("tmux")) {
         sessionHint = "";
       }
@@ -3148,6 +3260,13 @@ async function startMcpHttpServer() {
         });
         return;
       }
+      const pingMethod = parsedBody?.method;
+      if (req.method === "POST" && pingMethod === "ping") {
+        const payload = JSON.stringify({ jsonrpc: "2.0", id: getJsonRpcId2(parsedBody), result: {} });
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(payload);
+        return;
+      }
       const sessionId = req.headers["mcp-session-id"];
       let transport;
       let _thisRequestPendingInit;
@@ -3318,6 +3437,7 @@ async function startMcpHttpServer() {
         sessionHint = details.sessionHint ?? "";
         transport = recovered.transport;
         req.headers["mcp-session-id"] = recovered.sessionId;
+        if (!res.headersSent) res.setHeader("Mcp-Session-Id", recovered.sessionId);
       } else if (sessionId && !transports.has(sessionId) && req.method === "DELETE") {
         recordMcpHttpEvent({
           level: "info",
@@ -3344,6 +3464,7 @@ async function startMcpHttpServer() {
           transport = transports.get(adoptedSid);
           sessionLastSeen.set(adoptedSid, Date.now());
           req.headers["mcp-session-id"] = adoptedSid;
+          if (!res.headersSent) res.setHeader("Mcp-Session-Id", adoptedSid);
           recordMcpHttpEvent({
             level: "info",
             message: "missing_session_grace_recovered",
@@ -3481,8 +3602,9 @@ async function startMcpHttpServer() {
       httpServer.listen(MCP_HTTP_PORT, MCP_HTTP_HOST, () => {
         process.stderr.write(`[exed] MCP HTTP listening on ${MCP_HTTP_HOST}:${MCP_HTTP_PORT}
 `);
+        _boundMcpPort = MCP_HTTP_PORT;
         writeDaemonReady({ pid: process.pid, port: MCP_HTTP_PORT });
-        void import("../mcp-port-config-AWWRZA22.js").then(({ persistMcpPortToConfig }) => persistMcpPortToConfig(String(MCP_HTTP_PORT))).catch(() => {
+        void import("../mcp-port-config-FFAMMLLE.js").then(({ persistMcpPortToConfig }) => persistMcpPortToConfig(String(MCP_HTTP_PORT))).catch(() => {
         });
         recordMcpHttpEvent({
           level: "info",
@@ -3586,13 +3708,13 @@ async function ensureStoreForPolling() {
   }
 }
 async function startReviewPolling() {
-  const polling = await import("../review-polling-65JZUE3T.js");
+  const polling = await import("../review-polling-SRYZU2PI.js");
   const state = {
     lastIntercomSent: /* @__PURE__ */ new Map(),
     lastNudgeSent: /* @__PURE__ */ new Map(),
     intervalMs: REVIEW_POLL_INTERVAL_MS
   };
-  const { pollReviewNudge, createReviewNudgeRealDeps, loadNudgeState } = await import("../daemon-orchestration-G4RRTPP7.js");
+  const { pollReviewNudge, createReviewNudgeRealDeps, loadNudgeState } = await import("../daemon-orchestration-NBU5RZ2O.js");
   const nudgeState = loadNudgeState();
   const tick = async () => traceDaemonTimer("review_polling", async () => {
     fired("review_polling");
@@ -3636,7 +3758,7 @@ function startSessionTTL() {
     if (!await ensureStoreForPolling()) return;
     try {
       const { getClient } = await import("./database.js");
-      const { checkSessionTTL, createSessionTTLRealDeps } = await import("../daemon-orchestration-G4RRTPP7.js");
+      const { checkSessionTTL, createSessionTTLRealDeps } = await import("../daemon-orchestration-NBU5RZ2O.js");
       const deps = createSessionTTLRealDeps(getClient);
       const killed = await checkSessionTTL(deps);
       if (killed.length > 0) acted("session_ttl");
@@ -3684,7 +3806,7 @@ function startIdleKill() {
       const cfg = await getCachedConfig();
       if (!cfg) return;
       const { getClient } = await import("./database.js");
-      const { pollIdleKill, createIdleKillRealDeps } = await import("../daemon-orchestration-G4RRTPP7.js");
+      const { pollIdleKill, createIdleKillRealDeps } = await import("../daemon-orchestration-NBU5RZ2O.js");
       const { sessions: liveSessions, paneCache, aliveSessions } = await getSharedOrchestrationCaches();
       const realDeps = createIdleKillRealDeps(
         getClient,
@@ -3753,7 +3875,7 @@ function startConsolidation() {
 `);
       }
       try {
-        const { createBackupAsync, enforceRetention } = await import("../db-backup-EORG4LBO.js");
+        const { createBackupAsync, enforceRetention } = await import("../db-backup-BTL2FBBL.js");
         const p = await createBackupAsync("pre-consolidation");
         if (p) enforceRetention("pre-consolidation");
       } catch (e) {
@@ -3937,7 +4059,7 @@ function startSkillRefinement() {
     if (!shouldRunHeavyJob("skill_refinement")) return;
     try {
       if (!await ensureStoreForPolling()) return;
-      const { runSkillRefinement } = await import("../skill-refinement-DUOO6B7V.js");
+      const { runSkillRefinement } = await import("../skill-refinement-VTYL4OMJ.js");
       const result = await runSkillRefinement();
       if (result.reviewed > 0) {
         acted("skill_refinement");
@@ -3963,7 +4085,7 @@ function startStaleBranchSweep() {
   const tick = async () => {
     fired("stale_branch_sweep");
     try {
-      const { discoverRepoPaths } = await import("../worktree-sweep-K3CJFSUL.js");
+      const { discoverRepoPaths } = await import("../worktree-sweep-LWSCAZW6.js");
       const { scanUnmergedBranches } = await import("../branch-hygiene-55TKIWAZ.js");
       const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       for (const k of _staleBranchAlertedToday) {
@@ -3990,7 +4112,7 @@ function startStaleBranchSweep() {
         if (!_storeInitialized) continue;
         const stale = scan.branches.filter((b) => b.ageHours >= STALE_BRANCH_HOURS).slice(0, 5).map((b) => `${b.name} (+${b.ahead} commits, ${(b.ageHours / 24).toFixed(1)}d)`).join("; ");
         try {
-          const { writeNotification } = await import("../notifications-UP7WQGG4.js");
+          const { writeNotification } = await import("../notifications-Q5NEAP6K.js");
           await writeNotification({
             agentId: "exe",
             agentRole: "system",
@@ -4443,7 +4565,7 @@ function startReflectionSweep() {
       );
       let runReflection;
       try {
-        ({ runReflection } = await import("../memory-reflection-PXF6YFDU.js"));
+        ({ runReflection } = await import("../memory-reflection-VHQRUZWK.js"));
       } catch (importErr) {
         _reflectionImportFailed = true;
         process.stderr.write(`[exed] Reflection module unavailable (stale chunk hash?) \u2014 disabled until daemon restart: ${importErr instanceof Error ? importErr.message : String(importErr)}
@@ -4482,7 +4604,7 @@ function startReflectionSweep() {
       if (memories > 100 && cards < memories * 0.1) {
         process.stderr.write(`[exed] Memory cards sparse (${cards} cards / ${memories} memories) \u2014 running backfill...
 `);
-        const { insertMemoryCardsForBatch } = await import("../memory-cards-II67WFL2.js");
+        const { insertMemoryCardsForBatch } = await import("../memory-cards-CNLMHSZC.js");
         const batchSize = 500;
         let offset = 0;
         let totalCards = 0;
@@ -4527,7 +4649,7 @@ function startDatabaseBackup() {
     fired("db_backup");
     if (!shouldRunHeavyJob("db_backup")) return;
     try {
-      const { createBackupAsync, enforceRetention, hasBackupToday } = await import("../db-backup-EORG4LBO.js");
+      const { createBackupAsync, enforceRetention, hasBackupToday } = await import("../db-backup-BTL2FBBL.js");
       if (hasBackupToday("daily")) return;
       const backupPath = await createBackupAsync("daily");
       if (backupPath) {
@@ -4596,7 +4718,7 @@ function startSessionEventsRetention() {
     if (!await ensureStoreForPolling()) return;
     try {
       const { getClient } = await import("./database.js");
-      const { sweepExpiredSessionEvents, DEFAULT_SESSION_EVENTS_RETENTION_DAYS } = await import("../session-events-EJ3OSAA6.js");
+      const { sweepExpiredSessionEvents, DEFAULT_SESSION_EVENTS_RETENTION_DAYS } = await import("../session-events-L4DK5J6J.js");
       const days = SESSION_EVENTS_RETENTION_DAYS ?? DEFAULT_SESSION_EVENTS_RETENTION_DAYS;
       const count = await sweepExpiredSessionEvents(getClient(), days);
       if (count > 0) {
@@ -4626,13 +4748,41 @@ function startIntercomQueueDrain() {
   const tick = async () => traceDaemonTimer("intercom_queue_drain", async () => {
     fired("intercom_queue_drain");
     try {
-      const { drainQueue } = await import("../intercom-queue-6M5IRX3Y.js");
+      const { drainQueue, readQueue } = await import("../intercom-queue-6M5IRX3Y.js");
       const { isSessionBusy } = await import("./tmux-routing.js");
+      const { baseAgentName } = await import("./employees.js");
+      const agentsWithEmptyInbox = /* @__PURE__ */ new Set();
+      try {
+        const queue = readQueue();
+        const messageTargets = new Set(
+          queue.filter((q) => q.intercomReason === "message").map((q) => baseAgentName(q.targetSession.split("-")[0] ?? q.targetSession))
+        );
+        if (messageTargets.size > 0) {
+          const { countUnreadMessages } = await import("./messaging.js");
+          for (const agentId of messageTargets) {
+            try {
+              const count = await countUnreadMessages(agentId);
+              if (count === 0) agentsWithEmptyInbox.add(agentId);
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
       const { sendIntercom: centralSendIntercom } = await import("./tmux-routing.js");
       const result = drainQueue(
         (session) => isSessionBusy(session),
         (session, item) => {
           try {
+            if (item.intercomReason === "message") {
+              const agentRaw = session.split("-")[0] ?? session;
+              const agent = baseAgentName(agentRaw);
+              if (agentsWithEmptyInbox.has(agent)) {
+                process.stderr.write(`[exe-daemon] skipping stale message intercom for ${session} (inbox empty)
+`);
+                return true;
+              }
+            }
             const outcome = centralSendIntercom(session, {
               reason: item.intercomReason ?? "nudge"
             });
@@ -4664,7 +4814,7 @@ function startOrphanReaper() {
   const tick = async () => traceDaemonTimer("orphan_reaper", async () => {
     fired("orphan_reaper");
     try {
-      const { reapOrphanedMcpProcesses, createOrphanReaperRealDepsAsync } = await import("../daemon-orchestration-G4RRTPP7.js");
+      const { reapOrphanedMcpProcesses, createOrphanReaperRealDepsAsync } = await import("../daemon-orchestration-NBU5RZ2O.js");
       const deps = await createOrphanReaperRealDepsAsync();
       const reaped = await reapOrphanedMcpProcesses(deps);
       if (reaped.length > 0) acted("orphan_reaper");
@@ -4689,7 +4839,7 @@ function startZombieAgentReaper() {
   const tick = async () => traceDaemonTimer("zombie_agent_reaper", async () => {
     fired("zombie_agent_reaper");
     try {
-      const { reapZombieAgentProcesses, createZombieAgentReaperRealDepsAsync } = await import("../daemon-orchestration-G4RRTPP7.js");
+      const { reapZombieAgentProcesses, createZombieAgentReaperRealDepsAsync } = await import("../daemon-orchestration-NBU5RZ2O.js");
       const deps = await createZombieAgentReaperRealDepsAsync();
       const reaped = reapZombieAgentProcesses(deps);
       if (reaped.length > 0) acted("zombie_agent_reaper");
@@ -4713,7 +4863,7 @@ function startWorktreeReaper() {
   const tick = async () => traceDaemonTimer("worktree_reaper", async () => {
     fired("worktree_reaper");
     try {
-      const { reapOrphanedWorktrees, createWorktreeReaperRealDeps } = await import("../daemon-orchestration-G4RRTPP7.js");
+      const { reapOrphanedWorktrees, createWorktreeReaperRealDeps } = await import("../daemon-orchestration-NBU5RZ2O.js");
       const deps = await createWorktreeReaperRealDeps();
       const result = await reapOrphanedWorktrees(deps);
       if (result.pruned.length > 0) {
@@ -4753,8 +4903,8 @@ function startWorktreeReaper() {
               }
               continue;
             }
-            const { cleanupAgentWorktree } = await import("../worktree-sweep-K3CJFSUL.js");
-            const { getMainRepoRoot } = await import("../worktree-2CXY6NEB.js");
+            const { cleanupAgentWorktree } = await import("../worktree-sweep-LWSCAZW6.js");
+            const { getMainRepoRoot } = await import("../worktree-Z2G4CP4Z.js");
             const repoRoot = getMainRepoRoot(signal.worktreePath);
             if (repoRoot && signal.agentId) {
               const notes = cleanupAgentWorktree(repoRoot, signal.agentId);
@@ -4780,6 +4930,116 @@ function startWorktreeReaper() {
 `);
 }
 var AUTO_WAKE_INTERVAL_MS = 60 * 1e3;
+function startAutoWake() {
+  const tick = async () => traceDaemonTimer("auto_wake", async () => {
+    fired("auto_wake");
+    if (process.env.EXE_AUTO_WAKE === "0") return;
+    if (!await ensureStoreForPolling()) return;
+    try {
+      const { getClient } = await import("./database.js");
+      const { pollOrphanedTasks, createAutoWakeRealDeps } = await import("../daemon-orchestration-NBU5RZ2O.js");
+      const deps = createAutoWakeRealDeps(getClient, process.cwd());
+      const woken = await pollOrphanedTasks(deps);
+      if (woken.length > 0) acted("auto_wake");
+      for (const agent of woken) {
+        process.stderr.write(`[exed] Auto-wake: spawned ${agent}
+`);
+      }
+      try {
+        const signalBase = path3.join(os2.homedir(), ".exe-os", "task-signals");
+        if (existsSync3(signalBase)) {
+          const { readdirSync: readdirSync2, statSync: statSyncFs } = await import("fs");
+          const { sendIntercomAsync } = await import("./tmux-routing.js");
+          const sessionCache = path3.join(os2.homedir(), ".exe-os", "session-cache");
+          const sessions = await getTmuxSessionsAsync();
+          const signalDirs = [];
+          for (const entry of readdirSync2(signalBase, { withFileTypes: true })) {
+            if (entry.isDirectory()) signalDirs.push({ dir: path3.join(signalBase, entry.name), scope: entry.name });
+          }
+          signalDirs.push({ dir: signalBase, scope: null });
+          const _runtimeCache = /* @__PURE__ */ new Map();
+          const runtimeFor = (sessionName) => {
+            const cached = _runtimeCache.get(sessionName);
+            if (cached && Date.now() - cached.ts < 3e4) return cached.runtime;
+            try {
+              const dispatchInfoPath = path3.join(sessionCache, `dispatch-info-${sessionName}.json`);
+              if (!existsSync3(dispatchInfoPath)) {
+                _runtimeCache.set(sessionName, { runtime: "claude", ts: Date.now() });
+                return "claude";
+              }
+              const raw = JSON.parse(readFileSync3(dispatchInfoPath, "utf8"));
+              const rt = raw.runtime ?? "claude";
+              _runtimeCache.set(sessionName, { runtime: rt, ts: Date.now() });
+              return rt;
+            } catch {
+              return "claude";
+            }
+          };
+          for (const { dir, scope } of signalDirs) {
+            let files = [];
+            try {
+              files = readdirSync2(dir).filter((f) => f.endsWith(".pending") && !f.includes("review-"));
+            } catch {
+              continue;
+            }
+            for (const file of files) {
+              const signalPath = path3.join(dir, file);
+              const age = Date.now() - statSyncFs(signalPath).mtimeMs;
+              if (age > 60 * 60 * 1e3) {
+                try {
+                  unlinkSync2(signalPath);
+                  void import("../orchestration-events-7SNWRJYE.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+                    recordOE({ eventType: "signal.stale", source: "exe-daemon.autoWake", severity: "warn", payload: { file, ageMinutes: Math.round(age / 6e4) } });
+                  }).catch(() => {
+                  });
+                } catch {
+                }
+                continue;
+              }
+              if (age > 5 * 60 * 1e3) continue;
+              const agentId = file.includes(".") ? file.split(".")[0] : file.replace(".pending", "");
+              const match = sessions.find((s) => {
+                const agentPart = s.split("-")[0] ?? s;
+                const base = agentPart.replace(/\d+$/, "");
+                if (base !== agentId && s !== agentId) return false;
+                if (!scope) return true;
+                return s.endsWith(`-${scope}`);
+              });
+              if (!match) continue;
+              const state = classifyPaneState(await capturePaneAsync(match, 5));
+              if (state !== "idle") continue;
+              const runtime = runtimeFor(match);
+              if (runtime === "codex" || runtime === "opencode" || runtime === "exe-agent") {
+                await killTmuxSessionAsync(match);
+                acted("auto_wake");
+                process.stderr.write(
+                  `[exed] Signal-wake: killed idle ${runtime} session ${match} for fresh task signal ${file}; auto-wake will respawn (signal age ${Math.round(age / 1e3)}s)
+`
+                );
+              } else {
+                await sendIntercomAsync(match, { force: true, reason: "signal" });
+                process.stderr.write(`[exed] Signal-nudge: sent intercom to ${match} (signal age ${Math.round(age / 1e3)}s)
+`);
+              }
+            }
+          }
+        }
+      } catch (err) {
+        process.stderr.write(`[exed] Signal-wake error: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`[exed] Auto-wake error: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+  });
+  setTimeout(() => {
+    const timer = setInterval(() => void tick(), AUTO_WAKE_INTERVAL_MS);
+    timer.unref();
+  }, 15e3);
+  process.stderr.write(`[exed] Auto-wake started (every ${AUTO_WAKE_INTERVAL_MS / 1e3}s, offset 15s)
+`);
+}
 var WAL_CHECKPOINT_INTERVAL_MS = 5 * 60 * 1e3;
 function startWalCheckpoint() {
   const tick = async () => {
@@ -4788,7 +5048,7 @@ function startWalCheckpoint() {
     try {
       const { getClient, runWalCheckpoint } = await import("./database.js");
       const client = getClient();
-      const { findActiveDb } = await import("../db-backup-EORG4LBO.js");
+      const { findActiveDb } = await import("../db-backup-BTL2FBBL.js");
       const dbPath = findActiveDb();
       const started = Date.now();
       const result = await runWalCheckpoint(client, dbPath, true);
@@ -4860,7 +5120,7 @@ function startStuckTaskRelease() {
     if (!await ensureStoreForPolling()) return;
     try {
       const { getClient } = await import("./database.js");
-      const { releaseStuckTasks, createStuckTaskRealDeps } = await import("../daemon-orchestration-G4RRTPP7.js");
+      const { releaseStuckTasks, createStuckTaskRealDeps } = await import("../daemon-orchestration-NBU5RZ2O.js");
       const deps = createStuckTaskRealDeps(getClient);
       const released = await releaseStuckTasks(deps);
       if (released.length > 0) {
@@ -4914,8 +5174,9 @@ function startExternalRssWatchdog() {
     const workerSource = `
       import { workerData } from "node:worker_threads";
       import { execFile } from "node:child_process";
-      import { mkdirSync, writeFileSync } from "node:fs";
+      import { mkdirSync, writeFileSync, statSync } from "node:fs";
       import { dirname } from "node:path";
+      import { loadavg, cpus } from "node:os";
 
       const pid = Number(workerData.pid);
       const restartBytes = Number(workerData.restartBytes);
@@ -4929,6 +5190,16 @@ function startExternalRssWatchdog() {
       const debounceN = Number(workerData.debounceN) || 3;
       const startupGraceMs = Number(workerData.startupGraceMs) || 0;
       const startedAtMs = Number(workerData.startedAtMs) || Date.now();
+      // Bugs 0b5ece29/459b9c5a/9a2e91a5: event-loop stall detection. The main loop
+      // touches heartbeatPath every ~2s while alive. If its mtime goes stale beyond
+      // stallMs, the loop is wedged on a synchronous op (SQLCipher scan) \u2014 RSS stays
+      // healthy so the RSS path never fires. This worker thread has its OWN event
+      // loop, so it keeps running and can terminate the daemon for a launchd respawn.
+      const heartbeatPath = String(workerData.heartbeatPath || "");
+      const stallMs = Number(workerData.stallMs) || 0;
+      const stallMarkerPath = String(workerData.stallMarkerPath || markerPath);
+      const starvationRatio = Number(workerData.starvationRatio);
+      const cpuCount = cpus().length || 1;
       let overCount = 0;
       let terminating = false;
 
@@ -4940,6 +5211,44 @@ function startExternalRssWatchdog() {
         });
       }
 
+      function terminateDaemon(reason) {
+        if (terminating) return;
+        terminating = true;
+        try { process.stderr.write("[exed-watchdog] " + reason + " \u2014 terminating daemon PID " + pid + "\\n"); } catch {}
+        // A wedged loop cannot run its SIGTERM handler, so escalate to SIGKILL after
+        // a short grace (the in-process self-heal already WAL-checkpoints when it can;
+        // this external path is the last resort precisely because the loop is stuck).
+        try { process.kill(pid, "SIGTERM"); } catch {}
+        setTimeout(() => { try { process.kill(pid, "SIGKILL"); } catch {} }, 5000).unref();
+      }
+
+      // --- Event-loop stall watchdog (independent of RSS) ---
+      if (heartbeatPath && stallMs > 0) {
+        setInterval(() => {
+          if (terminating) return;
+          if (Date.now() - startedAtMs < startupGraceMs) return;
+          let ageMs;
+          try { ageMs = Date.now() - statSync(heartbeatPath).mtimeMs; }
+          catch { return; } // heartbeat not yet written \u2014 main loop not up; do not act
+          if (ageMs < stallMs) return;
+          // Starvation-aware (bugs 459b9c5a/9a2e91a5): if the OS is CPU-starved the
+          // lag is the scheduler, not an internal hang \u2014 restarting would not help and
+          // risks WAL damage. Skip while load/core exceeds the ratio. starvationRatio<=0
+          // disables this check (always treat a stale heartbeat as a real wedge).
+          if (starvationRatio > 0) {
+            const load1m = loadavg()[0] || 0;
+            if (load1m > cpuCount * starvationRatio) {
+              try { process.stderr.write("[exed-watchdog] event-loop heartbeat stale " + Math.round(ageMs/1000) + "s but load=" + load1m.toFixed(2) + "/" + cpuCount + " cpus (starved) \u2014 NOT restarting\\n"); } catch {}
+              return;
+            }
+          }
+          try { mkdirSync(dirname(stallMarkerPath), { recursive: true }); } catch {}
+          try { writeFileSync(stallMarkerPath, "event-loop wedged (heartbeat stale " + Math.round(ageMs/1000) + "s) at " + new Date().toISOString() + " (external watchdog)\\n"); } catch {}
+          terminateDaemon("EVENT LOOP WEDGED: heartbeat stale " + Math.round(ageMs/1000) + "s > " + Math.round(stallMs/1000) + "s threshold");
+        }, checkMs).unref();
+      }
+
+      // --- RSS watchdog (native leak outside V8 heap) ---
       setInterval(() => {
         if (terminating) return;
         readRssBytes((rss) => {
@@ -4948,16 +5257,15 @@ function startExternalRssWatchdog() {
           if (Date.now() - startedAtMs < startupGraceMs) return;
           overCount += 1;
           if (overCount < debounceN) return;
-          terminating = true;
           const rssMb = Math.round(rss / 1024 / 1024);
           try { mkdirSync(dirname(markerPath), { recursive: true }); } catch {}
           try { writeFileSync(markerPath, "RSS=" + rssMb + "MB at " + new Date().toISOString() + " (external watchdog, " + overCount + " consecutive)\\n"); } catch {}
-          try { process.stderr.write("[exed-rss-watchdog] RSS CRITICAL: " + rssMb + "MB for " + overCount + " consecutive samples \u2014 terminating daemon PID " + pid + "\\n"); } catch {}
-          try { process.kill(pid, "SIGTERM"); } catch {}
-          setTimeout(() => { try { process.kill(pid, "SIGKILL"); } catch {} }, 5000).unref();
+          terminateDaemon("RSS CRITICAL: " + rssMb + "MB for " + overCount + " consecutive samples");
         });
       }, checkMs).unref();
     `;
+    const stallMs = parseFloat(process.env.EXE_EVENT_LOOP_STALL_MS ?? "") || 15e4;
+    const starvationRatio = parseFloat(process.env.EXE_STARVATION_LOAD_RATIO ?? "1.5");
     const worker = new Worker(new URL(`data:text/javascript,${encodeURIComponent(workerSource)}`), {
       workerData: {
         pid: process.pid,
@@ -4969,12 +5277,16 @@ function startExternalRssWatchdog() {
         // beyond the in-process debounce before terminating.
         debounceN: DAEMON_RSS_RESTART_DEBOUNCE + 1,
         startupGraceMs: DAEMON_RSS_STARTUP_GRACE_MS,
-        startedAtMs: _daemonStartedAtMs
+        startedAtMs: _daemonStartedAtMs,
+        heartbeatPath: process.env.EXE_EVENT_LOOP_STALL_MS === "0" ? "" : eventLoopHeartbeatPath(),
+        stallMs: process.env.EXE_EVENT_LOOP_STALL_MS === "0" ? 0 : stallMs,
+        stallMarkerPath: eventLoopBlockedMarkerPath(),
+        starvationRatio: Number.isFinite(starvationRatio) ? starvationRatio : 1.5
       }
     });
     worker.unref();
     worker.on("error", (err) => {
-      process.stderr.write(`[exed] External RSS watchdog error: ${err.message}
+      process.stderr.write(`[exed] External watchdog error: ${err.message}
 `);
       _externalRssWatchdog = null;
     });
@@ -4982,7 +5294,10 @@ function startExternalRssWatchdog() {
       _externalRssWatchdog = null;
     });
     _externalRssWatchdog = worker;
-    process.stderr.write("[exed] External RSS watchdog started (worker thread; survives main event-loop stalls).\n");
+    process.stderr.write(
+      `[exed] External watchdog started (worker thread; survives main event-loop stalls; RSS restart + event-loop stall detection${process.env.EXE_EVENT_LOOP_STALL_MS === "0" ? " [stall OFF]" : ` @ ${Math.round(stallMs / 1e3)}s`}).
+`
+    );
   } catch (err) {
     process.stderr.write(`[exed] External RSS watchdog failed to start: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -4992,12 +5307,12 @@ function startTaskEnforcementScanner() {
   const tick = async () => traceDaemonTimer("task_enforcement", async () => {
     fired("task_enforcement");
     try {
-      const { runTaskEnforcementTick } = await import("../task-enforcement-UOULTGFB.js");
+      const { runTaskEnforcementTick } = await import("../task-enforcement-VFSAAZUN.js");
       const { getTransport } = await import("./transport.js");
       const { loadAgentConfig } = await import("./agent-config.js");
       const { getClient } = await import("./database.js");
       const { loadEmployeesSync } = await import("./employees.js");
-      const { sessionScopeFilter } = await import("../task-scope-P5STKYAC.js");
+      const { sessionScopeFilter } = await import("../task-scope-P4VLIQNP.js");
       const transport = getTransport();
       const { sessions: allSessions, paneCache, aliveSessions } = await getSharedOrchestrationCaches();
       await yieldToEventLoop();
@@ -5008,10 +5323,10 @@ function startTaskEnforcementScanner() {
         sendKeysLiteral: transport.sendKeysLiteral?.bind(transport),
         isAlive: (session) => aliveSessions.has(session)
       };
-      const { checkAutoWakeGates } = await import("../daemon-orchestration-G4RRTPP7.js");
+      const { checkAutoWakeGates } = await import("../daemon-orchestration-NBU5RZ2O.js");
       const { ensureEmployeeAsync, employeeSessionName } = await import("./tmux-routing.js");
       const { shouldAutoInstance } = await import("./employees.js");
-      const { recordOrchestrationEventBestEffort } = await import("../orchestration-events-PZLLPCKY.js");
+      const { recordOrchestrationEventBestEffort } = await import("../orchestration-events-7SNWRJYE.js");
       const projectDir = process.cwd();
       await runTaskEnforcementTick({
         transport: enforcementTransport,
@@ -5293,8 +5608,8 @@ function startBackgroundJobGuardrails() {
   const tick = async () => traceDaemonTimer("background_job_guardrails", async () => {
     fired("background_job_guardrails");
     try {
-      const { enforceBackgroundJobGuardrails } = await import("../background-jobs-A2LV36UX.js");
-      const actions = enforceBackgroundJobGuardrails();
+      const { enforceBackgroundJobGuardrailsAsync } = await import("../background-jobs-2QZ5IQKE.js");
+      const actions = await enforceBackgroundJobGuardrailsAsync();
       if (actions.length > 0) {
         acted("background_job_guardrails");
         for (const action of actions) {
@@ -5316,18 +5631,56 @@ function startBackgroundJobGuardrails() {
 }
 function handleSignalShutdown() {
   if (_shuttingDown) return;
-  const restartIntent = consumeRestartIntent();
-  logRestartEvent("daemon_signal_received", { platform: process.platform, fast_exit: false, restart_intent: restartIntent, uptime_s: Math.floor((Date.now() - _startedAt2) / 1e3) });
-  logShutdown(restartIntent ? "restart shutdown" : "graceful shutdown", "SIGTERM/SIGINT");
+  const { intent: restartIntent, reason } = consumeRestartIntentDetail();
+  const signalAttribution = attributeSignalSource(reason);
+  logRestartEvent("daemon_signal_received", {
+    platform: process.platform,
+    fast_exit: false,
+    restart_intent: restartIntent,
+    uptime_s: Math.floor((Date.now() - _startedAt2) / 1e3),
+    ...signalAttribution
+  });
+  logShutdown(restartIntent ? "restart shutdown" : "graceful shutdown", "SIGTERM/SIGINT", signalAttribution);
   void shutdown(restartIntent ? 75 : 0);
 }
 process.on("SIGINT", handleSignalShutdown);
 process.on("SIGTERM", handleSignalShutdown);
+var _staleDistRe = /(?:ERR_MODULE_NOT_FOUND|Cannot find module)[^\n]*dist[\\/]/i;
+var _staleDistRestartRequested = false;
+function isStaleDistChunkError(reason) {
+  try {
+    if (reason && typeof reason === "object" && reason.code === "ERR_MODULE_NOT_FOUND") return true;
+    const msg = reason instanceof Error ? reason.stack ?? reason.message : String(reason);
+    return _staleDistRe.test(msg);
+  } catch {
+    return false;
+  }
+}
+function maybeSelfHealStaleDist(reason, source) {
+  if (!isStaleDistChunkError(reason)) return;
+  const msg = reason instanceof Error ? reason.stack ?? reason.message : String(reason);
+  if (_staleDistRestartRequested) {
+    process.stderr.write(`[exed] Stale-dist chunk error again (${source}) \u2014 restart already requested: ${msg}
+`);
+    return;
+  }
+  _staleDistRestartRequested = true;
+  process.stderr.write(`[exed] Stale dist chunk detected (${source}) \u2014 daemon is running against a swapped build; requesting restart: ${msg}
+`);
+  logRestartEvent("daemon_self_exit", { trigger: "stale_dist_chunk", source, uptime_s: Math.floor((Date.now() - _startedAt2) / 1e3) });
+  try {
+    requestRestart("stale-dist-chunk-self-heal");
+  } catch (err) {
+    process.stderr.write(`[exed] requestRestart for stale-dist self-heal failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
 process.on("unhandledRejection", (reason) => {
   const msg = reason instanceof Error ? reason.stack ?? reason.message : String(reason);
   process.stderr.write(`[exed] Unhandled rejection (caught): ${msg}
 `);
   logCrash(reason instanceof Error ? reason : String(reason), "unhandled_rejection");
+  maybeSelfHealStaleDist(reason, "unhandledRejection");
 });
 var BUG_AUTOFIX_INTERVAL_MS = 5 * 6e4;
 var AUTOFIX_DEDUP_TTL_MS = 6 * 60 * 60 * 1e3;
@@ -5425,6 +5778,7 @@ process.on("uncaughtException", (err) => {
 `
   );
   logCrash(err, "uncaught_exception");
+  maybeSelfHealStaleDist(err, "uncaughtException");
   try {
     pushNotifyAsync({ event: "daemon_crash", title: "Daemon crashed", body: err.message, priority: "urgent" });
   } catch {
@@ -5650,7 +6004,7 @@ if (process.platform === "darwin") {
 logBoot({ socketPath: SOCKET_PATH, pidPath: PID_PATH });
 void (async () => {
   try {
-    const { cleanupCrashDebris } = await import("../db-backup-EORG4LBO.js");
+    const { cleanupCrashDebris } = await import("../db-backup-BTL2FBBL.js");
     const removed = cleanupCrashDebris();
     if (removed > 0) {
       process.stderr.write(`[exed] Startup cleanup: pruned ${removed} crash-debris file(s) (backups/quarantine).
@@ -5796,7 +6150,9 @@ function startEventLoopLagDetector() {
   const SELF_HEAL_CONSECUTIVE = parseInt(process.env.EXE_SELF_HEAL_CONSECUTIVE ?? "") || 3;
   const SELF_HEAL_THRESHOLD_MS = parseFloat(process.env.EXE_SELF_HEAL_THRESHOLD_MS ?? "") || 3e4;
   let consecutiveSevereBlocks = 0;
+  touchEventLoopHeartbeat();
   const lagTimer = setInterval(() => {
+    touchEventLoopHeartbeat();
     const lag = monotonicElapsedMs(lastTick) - 2e3;
     const clockJump = looksLikeClockJump(clockProbe);
     lastTick = monotonicNowMs();
@@ -5815,7 +6171,7 @@ function startEventLoopLagDetector() {
       const msg = `[exed] EVENT LOOP BLOCKED ${(lag / 1e3).toFixed(1)}s \u2014 MCP UNRESPONSIVE. Sessions will die.`;
       process.stderr.write(msg + "\n");
       logDaemonHealth({ event: "event_loop_blocked", pid: process.pid, message: msg, data: { lagMs: lag } });
-      void import("../orchestration-events-PZLLPCKY.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+      void import("../orchestration-events-7SNWRJYE.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
         recordOE({ eventType: "daemon.event_loop_blocked", source: "exe-daemon.lagDetector", severity: "error", durationMs: lag });
       }).catch(() => {
       });
@@ -5877,7 +6233,7 @@ function startEventLoopLagDetector() {
       consecutiveSevereBlocks = 0;
     } else {
       consecutiveSevereBlocks = 0;
-      writeDaemonReady({ pid: process.pid });
+      writeDaemonReady({ pid: process.pid, port: _boundMcpPort });
     }
   }, 2e3);
   lagTimer.unref();
@@ -5901,6 +6257,7 @@ function startTaskFileResync() {
       const client = getClient();
       const tasksRoot = path3.join(os2.homedir(), ".exe-os", "tasks");
       let synced = 0;
+      let fileCount = 0;
       const walkAsync = async (dir) => {
         let entries;
         try {
@@ -5934,7 +6291,7 @@ function startTaskFileResync() {
                 });
                 if (Number(res.rowsAffected ?? 0) > 0) {
                   synced++;
-                  void import("../orchestration-events-PZLLPCKY.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+                  void import("../orchestration-events-7SNWRJYE.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
                     recordOE({
                       eventType: "task_file.resynced",
                       source: "exe-daemon.taskFileResync",
@@ -5952,6 +6309,7 @@ function startTaskFileResync() {
             }
           } catch {
           }
+          if (++fileCount % 10 === 0) await yieldToEventLoop();
         }
       };
       await walkAsync(tasksRoot);
@@ -5970,7 +6328,7 @@ function startTaskGroupBarriers() {
       fired("task_group_barriers");
       if (!await ensureStoreForPolling()) return;
       try {
-        const { pollTaskGroupBarriers } = await import("../daemon-orchestration-G4RRTPP7.js");
+        const { pollTaskGroupBarriers } = await import("../daemon-orchestration-NBU5RZ2O.js");
         const firedCount = await pollTaskGroupBarriers();
         if (firedCount > 0) {
           acted("task_group_barriers");
@@ -5992,7 +6350,7 @@ function startCheckpointGc() {
       fired("checkpoint_gc");
       if (!await ensureStoreForPolling()) return;
       try {
-        const { gcStaleCheckpoints } = await import("../daemon-orchestration-G4RRTPP7.js");
+        const { gcStaleCheckpoints } = await import("../daemon-orchestration-NBU5RZ2O.js");
         const cleared = await gcStaleCheckpoints();
         if (cleared > 0) {
           acted("checkpoint_gc");
@@ -6032,14 +6390,14 @@ function startDispatchAckCleanup() {
 function startProjectionWorkerDeferred() {
   setTimeout(async () => {
     try {
-      const { startProjectionWorker } = await import("../projection-worker-HWY37MNC.js");
+      const { startProjectionWorker } = await import("../projection-worker-HELRBNDR.js");
       startProjectionWorker();
     } catch {
     }
   }, 2e4);
 }
 async function startToolTelemetry() {
-  const { startToolTelemetryFlush } = await import("../tool-telemetry-BS5JXM5M.js");
+  const { startToolTelemetryFlush } = await import("../tool-telemetry-CDNPES5B.js");
   startToolTelemetryFlush();
   process.stderr.write("[exed] Tool telemetry started (flush every 5m)\n");
 }
@@ -6067,11 +6425,13 @@ function startServerModeTimers() {
 function startLocalFirstTimers() {
   startMemoryQueueDrain();
   startMessageQueueDrain();
+  setTimeout(() => void retryPendingMessages(), 15e3);
   void drainIngestOutbox();
   startIntercomQueueDrain();
   startReviewPolling();
   startSessionTTL();
   startTaskEnforcementScanner();
+  startAutoWake();
   startApiWatchdog();
   startIdleKill();
   startRssWatchdog();
@@ -6182,7 +6542,7 @@ function startLocalFirstTimers() {
     fired("orphan_task_cleanup");
     try {
       if (!await ensureStoreForPolling()) return;
-      const { cleanOrphanedTaskFiles } = await import("../tasks-crud-24HMTULR.js");
+      const { cleanOrphanedTaskFiles } = await import("../tasks-crud-SC3ERIUR.js");
       const count = await cleanOrphanedTaskFiles();
       if (count > 0) {
         acted("orphan_task_cleanup");
@@ -6198,7 +6558,7 @@ function startLocalFirstTimers() {
     fired("task_file_consistency");
     try {
       if (!await ensureStoreForPolling()) return;
-      const { checkTaskFileConsistency } = await import("../tasks-crud-24HMTULR.js");
+      const { checkTaskFileConsistency } = await import("../tasks-crud-SC3ERIUR.js");
       const mismatches = await checkTaskFileConsistency();
       if (mismatches > 0) {
         acted("task_file_consistency");
@@ -6217,7 +6577,7 @@ function startLocalFirstTimers() {
   const TELEMETRY_DAILY_MS = 24 * 60 * 60 * 1e3;
   const telemetryDaily = async () => {
     try {
-      const { sendTelemetry, isTelemetryEnabled } = await import("../telemetry-upload-DWFGC2XJ.js");
+      const { sendTelemetry, isTelemetryEnabled } = await import("../telemetry-upload-4QEYQROW.js");
       if (!isTelemetryEnabled()) return;
       const { upstream } = await sendTelemetry(24);
       if (upstream.startsWith("sent")) {