@askexenow/exe-os 0.9.340 → 0.9.342

package/dist/lib/exe-daemon.js

@@ -1,15 +1,23 @@
 import {
-  clearDaemonReady,
-  writeDaemonReady
-} from "../chunk-I5RLNOFK.js";
+  readBreakerAlert,
+  recordDaemonRestart,
+  restartBootsInWindow,
+  restartBreakerAlertPath,
+  writeDaemonExitBreadcrumb
+} from "../chunk-HJ447YER.js";
 import {
   pushNotifyAsync
-} from "../chunk-BVV6NHKQ.js";
+} from "../chunk-3SW4OEHB.js";
+import {
+  clearDaemonReady,
+  eventLoopHeartbeatPath,
+  writeDaemonReady
+} from "../chunk-MOPUCPXK.js";
 import {
   getMcpToolFamily,
   inferMcpRuntime,
   recordMcpHttpEvent
-} from "../chunk-5RACW3LX.js";
+} from "../chunk-RAXVPNMR.js";
 import {
   deserializeArgs,
   serializeResultSet
@@ -21,8 +29,11 @@ import {
   findScopedDuplicate,
   governMemoryRecord,
   schedulePostWriteMemoryHygiene
-} from "../chunk-HHIBOU3P.js";
-import "../chunk-Y25OJWOQ.js";
+} from "../chunk-6XWTQUO4.js";
+import "../chunk-4QCFFW2H.js";
+import {
+  BUSY_PATTERN
+} from "../chunk-GWDSB25T.js";
 import {
   attributeSignalSource,
   consumeRestartIntentDetail,
@@ -30,10 +41,11 @@ import {
   requestRestart
 } from "../chunk-AFNRE2RV.js";
 import {
+  assessInitialBindIdentity,
   ensureDaemonToken,
   reconcileSessionAgentIdentity,
   shouldEnforceSessionIdentity
-} from "../chunk-3NGZ4PL7.js";
+} from "../chunk-X2Q5NLUL.js";
 import {
   DAEMON_RSS_RESTART_DEBOUNCE,
   DAEMON_RSS_STARTUP_GRACE_MS,
@@ -70,8 +82,8 @@ import {
   EXE_AI_DIR,
   MODELS_DIR,
   resolveEmbedModelFile
-} from "../chunk-7Y5UDEVM.js";
-import "../chunk-SHIICYJW.js";
+} from "../chunk-WZHZCDDO.js";
+import "../chunk-BYTDMAGB.js";
 import "../chunk-MLKGABMK.js";
 
 // src/lib/exe-daemon.ts
@@ -79,11 +91,41 @@ import os2 from "os";
 import net from "net";
 import v8 from "v8";
 import { createServer as createHttpServer, request as httpRequest } from "http";
-import { randomUUID } from "crypto";
+import { randomUUID, timingSafeEqual } from "crypto";
 import { writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2, existsSync as existsSync4, readFileSync as readFileSync4, chmodSync, readdirSync, renameSync, statSync } from "fs";
 import { writeFile } from "fs/promises";
 import { execSync as execSyncNode, execFile as execFileNode } from "child_process";
 import { promisify } from "util";
+
+// src/lib/coo-respawn.ts
+var NPM_ROOT_RETRY_MS = (() => {
+  const raw = process.env.EXE_NPM_ROOT_RETRY_MS;
+  const n = raw !== void 0 ? Number(raw) : NaN;
+  return Number.isFinite(n) && n >= 0 ? n : 5 * 6e4;
+})();
+function createMemoizedNpmGlobalRootResolver(execFile, log = (m) => void process.stderr.write(m), opts = {}) {
+  const retryMs = opts.retryMs ?? NPM_ROOT_RETRY_MS;
+  const now = opts.now ?? (() => Date.now());
+  let memo = null;
+  let failedAt = null;
+  return async () => {
+    if (memo !== null) return memo;
+    if (failedAt !== null && now() - failedAt < retryMs) return null;
+    try {
+      const { stdout } = await execFile("npm", ["root", "-g"], { timeout: 5e3, encoding: "utf8" });
+      memo = stdout.trim();
+      failedAt = null;
+      return memo;
+    } catch (err) {
+      failedAt = now();
+      log(`[exed] npm root -g resolution failed (memoized, retry after ${Math.round(retryMs / 1e3)}s): ${err instanceof Error ? err.message : String(err)}
+`);
+      return null;
+    }
+  };
+}
+
+// src/lib/exe-daemon.ts
 import path3 from "path";
 import { fileURLToPath } from "url";
 import { fork, spawn } from "child_process";
@@ -192,6 +234,10 @@ function validateWriteShape(maskedSql) {
   }
   return null;
 }
+function isOffloadableDaemonReadSql(sql) {
+  const masked = maskSqlLiteralsAndComments(sql.trim());
+  return DAEMON_READ_SQL_RE.test(masked);
+}
 function validateDaemonDbSql(sql) {
   const original = sql.trim();
   if (!original) return "empty SQL is not allowed";
@@ -330,6 +376,20 @@ async function awaitPendingMcpInit(ownerKey, requestSessionId, deps, transientMa
   return null;
 }
 
+// src/lib/daemon-self-heal-dispatch.ts
+function dispatchSelfHealRestart(lagMs, trigger, deps) {
+  deps.writeBreadcrumb(lagMs, trigger);
+  deps.shutdown(75);
+}
+function resolveSelfHealThresholds(env = process.env) {
+  return {
+    singleMs: parseFloat(env.EXE_SELF_HEAL_SINGLE_MS ?? "") || 12e4,
+    thresholdMs: parseFloat(env.EXE_SELF_HEAL_THRESHOLD_MS ?? "") || 3e4,
+    consecutive: parseInt(env.EXE_SELF_HEAL_CONSECUTIVE ?? "") || 3,
+    starvationRatio: parseFloat(env.EXE_STARVATION_LOAD_RATIO ?? "1.5")
+  };
+}
+
 // src/lib/daemon-restart-backoff.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, mkdirSync } from "fs";
 import { createHash } from "crypto";
@@ -815,7 +875,7 @@ async function capturePaneAsync(session, lines = 20) {
   }
 }
 function classifyPaneState(pane) {
-  const busyPattern = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
+  const busyPattern = BUSY_PATTERN;
   if (!pane.includes("\u276F") && !pane.includes("Claude Code") && !busyPattern.test(pane) && !/Running…/.test(pane)) {
     if (/\$\s*$/.test(pane) || /% $/.test(pane.trimEnd())) return "no_claude";
   }
@@ -884,7 +944,7 @@ async function batchPaneAlive(sessions) {
   }
   return alive;
 }
-var CACHED_SESSION_BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
+var CACHED_SESSION_BUSY_PATTERN = BUSY_PATTERN;
 function getCachedSessionState(sessionName, paneCache, aliveSessions) {
   if (!aliveSessions.has(sessionName)) return "offline";
   const pane = paneCache.get(sessionName);
@@ -974,6 +1034,46 @@ 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));
+var _lastBlockingTimer = null;
+function getLastBlockingTimer() {
+  return _lastBlockingTimer;
+}
+var _exitBreadcrumbWritten = false;
+function recordExitBreadcrumb(kind, exitCode, reason, extra) {
+  if (_exitBreadcrumbWritten) return;
+  _exitBreadcrumbWritten = true;
+  let rssBytes;
+  try {
+    rssBytes = process.memoryUsage().rss;
+  } catch {
+  }
+  const info = {
+    exitCode,
+    reason,
+    kind,
+    ts: Date.now(),
+    uptimeMs: Date.now() - _startedAt2,
+    ...rssBytes !== void 0 ? { rssBytes } : {},
+    ...extra
+  };
+  writeDaemonExitBreadcrumb(info);
+}
+function recordSelfHealBreadcrumb(lagMs, trigger) {
+  const blk = _lastBlockingTimer && Date.now() - _lastBlockingTimer.ts < 6e4 ? _lastBlockingTimer : null;
+  recordExitBreadcrumb("self_heal", 75, `self_heal_event_loop_lag:${trigger}`, {
+    lagMs: Math.round(lagMs),
+    ...blk ? { timerName: blk.name, timerDurationMs: blk.durationMs } : {}
+  });
+}
+var SELF_HEAL_ACTION_DEPS = {
+  writeBreadcrumb: recordSelfHealBreadcrumb,
+  shutdown: (code) => {
+    void shutdown(code);
+  },
+  exit: (code) => {
+    process.exit(code);
+  }
+};
 async function traceDaemonTimer(name, fn) {
   if (_timerInFlight.has(name)) {
     process.stderr.write(`[exed] Timer SKIPPED (overlap): ${name} \u2014 previous tick still running
@@ -988,6 +1088,7 @@ async function traceDaemonTimer(name, fn) {
 `);
   }
   const timeoutHandle = setTimeout(() => {
+    _lastBlockingTimer = { name, durationMs: TIMER_TIMEOUT_MS, ts: Date.now() };
     process.stderr.write(
       `[exed] Timer TIMEOUT WARNING: ${name} has been running for >${TIMER_TIMEOUT_MS / 1e3}s \u2014 likely blocking the event loop
 `
@@ -1008,6 +1109,9 @@ async function traceDaemonTimer(name, fn) {
     const span = measureSpan(probe);
     const durationMs = Math.round(span.monoMs);
     const slept = span.sleptMs > 1e3;
+    if (!slept && durationMs >= TIMER_TIMEOUT_MS) {
+      _lastBlockingTimer = { name, durationMs, ts: Date.now() };
+    }
     if (shouldTraceDaemonTimer(durationMs)) {
       const sleepNote = slept ? ` (wall ${Math.round(span.wallMs)}ms \u2014 host slept/clock-stepped ${Math.round(span.sleptMs)}ms; not an event-loop block)` : "";
       const msg = `[exed] Timer duration: ${name} ${durationMs}ms${sleepNote}`;
@@ -1166,9 +1270,6 @@ 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();
@@ -1438,7 +1539,7 @@ async function loadModel() {
         void (async () => {
           try {
             if (_storeInitialized) {
-              const { writeNotification } = await import("../notifications-KONB3C62.js");
+              const { writeNotification } = await import("../notifications-4UT53CDG.js");
               await writeNotification({
                 agentId: "exe",
                 agentRole: "system",
@@ -1554,7 +1655,7 @@ function disableEmbeddingsForInferenceTimeouts() {
   void (async () => {
     try {
       if (_storeInitialized) {
-        const { writeNotification } = await import("../notifications-KONB3C62.js");
+        const { writeNotification } = await import("../notifications-4UT53CDG.js");
         await writeNotification({
           agentId: "exe",
           agentRole: "system",
@@ -1723,10 +1824,12 @@ function checkIdle() {
     _idleTimer.unref();
   }
 }
-async function shutdown(exitCode = 0) {
+async function shutdown(exitCode = 0, reason = null) {
   if (_shuttingDown) return;
   _shuttingDown = true;
   _drainingWrites = true;
+  const _exitKind = exitCode === 0 && !reason ? "clean" : reason ? "self_exit" : "restart-intent";
+  recordExitBreadcrumb(_exitKind, exitCode, reason);
   clearDaemonReady();
   if (exitCode !== 0) {
     recordDaemonCrash();
@@ -1765,12 +1868,58 @@ async function shutdown(exitCode = 0) {
     }
   }
   try {
-    const { createBackupAsync, enforceRetention, hasRecentBackup } = await import("../db-backup-DLD4QZBO.js");
-    const PRE_RESTART_DEDUP_MS = 2 * 60 * 1e3;
-    if (hasRecentBackup("pre-restart", PRE_RESTART_DEDUP_MS)) {
+    const {
+      createBackupAsync,
+      enforceRetention,
+      hasRecentBackup,
+      preRestartDedupWindowMs,
+      findActiveDb,
+      shouldSkipBackupUnderMemoryPressure
+    } = await import("../db-backup-W2QFSYQC.js");
+    const PRE_RESTART_DEDUP_MS = preRestartDedupWindowMs();
+    const PRE_RESTART_STORM_CAP = (() => {
+      const v = Number(process.env.EXE_PRE_RESTART_STORM_CAP);
+      return Number.isFinite(v) && v > 0 ? Math.floor(v) : 3;
+    })();
+    let stormSkip = false;
+    try {
+      const recentRestarts = restartBootsInWindow();
+      if (recentRestarts >= PRE_RESTART_STORM_CAP) {
+        stormSkip = true;
+        process.stderr.write(
+          `[exed] Pre-restart backup SKIPPED \u2014 restart storm (${recentRestarts} restarts in breaker window \u2265 cap ${PRE_RESTART_STORM_CAP}). Bounding total 1.7GB backup bytes; last snapshot + daily backups remain (data-safe).
+`
+        );
+      }
+    } catch {
+    }
+    let memoryGateSkip = false;
+    try {
+      const dbPath = findActiveDb();
+      let dbBytes = 0;
+      try {
+        dbBytes = dbPath ? statSync(dbPath).size : 0;
+      } catch {
+      }
+      const { getAvailableMemoryBytesSync } = await import("../memory-pressure-watchdog-HN5X7AVN.js");
+      const freeBytes = getAvailableMemoryBytesSync();
+      if (shouldSkipBackupUnderMemoryPressure(freeBytes, dbBytes)) {
+        memoryGateSkip = true;
+        process.stderr.write(
+          `[exed] Pre-restart backup SKIPPED under memory pressure \u2014 ${Math.round(freeBytes / 1024 / 1024)}MB free vs ${Math.round(dbBytes / 1024 / 1024)}MB DB. Skipping the copy is data-safe; OOM-killing the machine mid-copy is not.
+`
+        );
+      }
+    } catch {
+    }
+    if (stormSkip) {
+      enforceRetention("pre-restart");
+    } else if (hasRecentBackup("pre-restart", PRE_RESTART_DEDUP_MS)) {
       const deleted = enforceRetention("pre-restart");
       process.stderr.write(`[exed] Pre-restart backup skipped \u2014 recent snapshot exists (crash-loop dedup)${deleted > 0 ? `; rotated ${deleted} old` : ""}.
 `);
+    } else if (memoryGateSkip) {
+      enforceRetention("pre-restart");
     } else {
       const backupPath = await createBackupAsync("pre-restart");
       if (backupPath) {
@@ -1796,12 +1945,12 @@ async function shutdown(exitCode = 0) {
 `);
   }
   try {
-    const { stopProjectionWorker } = await import("../projection-worker-ZVOFHTXT.js");
+    const { stopProjectionWorker } = await import("../projection-worker-FZ7YSN3G.js");
     stopProjectionWorker();
   } catch {
   }
   try {
-    const { disposeShards } = await import("../shard-manager-MBWQEYNG.js");
+    const { disposeShards } = await import("../shard-manager-35PWFR3B.js");
     disposeShards();
   } catch {
   }
@@ -1862,7 +2011,7 @@ async function handleHealthCheck(socket, requestId) {
   let pipelineStatus = "unknown";
   if (dbConnected) {
     try {
-      await import("../pipeline-router-O6HU7DKH.js");
+      await import("../pipeline-router-LM53NMWJ.js");
       pipelineStatus = "ok";
     } catch {
       pipelineStatus = "unavailable";
@@ -1967,6 +2116,18 @@ async function handleDbExecute(socket, requestId, sql, args) {
       sendResponse(socket, { id: requestId, error: "DB not initialized" });
       return;
     }
+    if (isOffloadableDaemonReadSql(sql)) {
+      try {
+        const { isDbReadWorkerReady, runReadQueryInWorkerSerialized } = await import("./db-read-worker-client.js");
+        if (isDbReadWorkerReady()) {
+          const serialized = await runReadQueryInWorkerSerialized(sql, args);
+          _dbRequestsServed++;
+          sendResponse(socket, { id: requestId, db: serialized });
+          return;
+        }
+      } catch {
+      }
+    }
     const { getClient } = await import("./database.js");
     const client = getClient();
     const deserializedArgs = deserializeArgs(args);
@@ -2258,7 +2419,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-RNSXGXW4.js");
+    const { insertOntologyForMemory } = await import("../agentic-ontology-3FXYMHKW.js");
     await insertOntologyForMemory({
       id,
       agent_id: record.agent_id,
@@ -2287,37 +2448,34 @@ function startMemoryQueueDrain() {
     fired("memory_queue_drain");
     if (!await ensureStoreForPolling()) return;
     try {
-      const { ackQueue, claimQueue, retryQueueEntries } = await import("../memory-queue-X2CSEAKE.js");
+      const { ackQueue, claimQueue, retryQueueEntries, processQueueEntries } = await import("../memory-queue-2UOOF27L.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 {
-          await writeMemoryRecord(entry);
-          processed++;
-        } catch (err) {
-          retryEntries.push(entry);
+      const result = await processQueueEntries(entries, (entry) => writeMemoryRecord(entry), {
+        isDraining: () => _drainingWrites,
+        batchSize: MEMORY_DRAIN_BATCH,
+        yieldFn: yieldToEventLoop,
+        onWriteError: (_entry, err) => {
           process.stderr.write(
             `[exed] Queue drain write error: ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        },
+        onShutdownPreserve: (count) => {
+          process.stderr.write(
+            `[exed] Queue drain interrupted by shutdown \u2014 ${count} entr${count === 1 ? "y" : "ies"} preserved in lease for replay after restart
 `
           );
         }
-        if (++sinceYield >= MEMORY_DRAIN_BATCH) {
-          sinceYield = 0;
-          await yieldToEventLoop();
-        }
-      }
-      if (retryEntries.length === 0) {
+      });
+      if (result.retryEntries.length === 0) {
         ackQueue(lease.leasePath);
       } else {
-        retryQueueEntries(lease.leasePath, retryEntries);
+        retryQueueEntries(lease.leasePath, result.retryEntries);
       }
-      process.stderr.write(`[exed] Queue drain: processed ${processed}/${entries.length} memories
+      process.stderr.write(`[exed] Queue drain: processed ${result.processed}/${entries.length} memories${result.preserved > 0 ? ` (${result.preserved} preserved for replay)` : ""}
 `);
     } catch (err) {
       process.stderr.write(
@@ -2348,7 +2506,7 @@ function startMessageQueueDrain() {
     fired("message_queue_drain");
     if (!await ensureStoreForPolling()) return;
     try {
-      const { claimMessageQueue, ackMessageQueue } = await import("../message-queue-client-Q5BW3O5W.js");
+      const { claimMessageQueue, ackMessageQueue } = await import("../message-queue-client-4EOQRUXW.js");
       const lease = claimMessageQueue();
       if (!lease || lease.entries.length === 0) return;
       acted("message_queue_drain");
@@ -2994,7 +3152,7 @@ async function startMcpHttpServer() {
     process.stderr.write("[exed] MCP HTTP: DB ready\n");
     setBootPhase("db_ready");
     _storeInitialized = true;
-    const { initLicenseGate, getCachedLicenseGate } = await import("../license-gate-BYDMFMFT.js");
+    const { initLicenseGate, getCachedLicenseGate } = await import("../license-gate-QTRQHV4F.js");
     const gateResult = await initLicenseGate();
     if (!gateResult.hasKey) {
       process.stderr.write(
@@ -3009,13 +3167,13 @@ async function startMcpHttpServer() {
     let _cachedWrapTelemetry = null;
     async function getWrapTelemetry() {
       if (!_cachedWrapTelemetry) {
-        const { wrapServerWithTelemetry } = await import("../tool-telemetry-ULIDUK3P.js");
+        const { wrapServerWithTelemetry } = await import("../tool-telemetry-KBXSBDTK.js");
         _cachedWrapTelemetry = wrapServerWithTelemetry;
       }
       return _cachedWrapTelemetry;
     }
     Promise.all([
-      import("../tool-capability-index-Q6YQDL7I.js"),
+      import("../tool-capability-index-VYF5GNJ2.js"),
       import("../tool-gates-3IC7DK4R.js")
     ]).then(async ([{ getToolCapabilityIndex }, { TOOL_CATEGORIES }]) => {
       const gateState = getCachedLicenseGate();
@@ -3077,9 +3235,11 @@ async function startMcpHttpServer() {
       if (!header) return false;
       const token = header.replace(/^Bearer\s+/i, "");
       if (!token || token === header) return false;
-      if (token === _daemonToken) return true;
+      const tokenBuf = Buffer.from(token);
+      const expectedBuf = Buffer.from(_daemonToken);
+      if (tokenBuf.length === expectedBuf.length && timingSafeEqual(tokenBuf, expectedBuf)) return true;
       try {
-        const { verifyAccessToken } = await import("../oauth-server-ROQFOEMM.js");
+        const { verifyAccessToken } = await import("../oauth-server-67YBDP32.js");
         const result = verifyAccessToken(token);
         return result.valid;
       } catch {
@@ -3295,6 +3455,14 @@ async function startMcpHttpServer() {
           version: PACKAGE_VERSION,
           eventLoopLagMs: Math.round(elLag),
           eventLoopBlockedNow: blockedNow,
+          // Feature 9ddc55b2 (timer health dashboard): expose the names of the
+          // timers executing RIGHT NOW. This is a plain read of the existing
+          // in-memory overlap-guard Set (≤ ~96 short strings) on an existing
+          // request handler — it adds ZERO work to the timer hot path. Without
+          // it "is this timer in-flight?" is unanswerable from outside the
+          // process: traceDaemonTimer writes tick *starts* to stderr only, never
+          // durably. When a tick blocks the loop this is the field that names it.
+          timersInFlight: [..._timerInFlight],
           ...blockedNow && { warning: "Event loop blocked marker is fresh \u2014 /mcp returning 503 Retry-After until marker clears (~10s)" },
           ...!blockedNow && degraded && { warning: `Event loop lag ${Math.round(elLag)}ms exceeds 5000ms threshold \u2014 daemon may be unresponsive` }
         }));
@@ -3324,7 +3492,7 @@ async function startMcpHttpServer() {
         return;
       }
       try {
-        const { handleOAuthRoute } = await import("../oauth-server-ROQFOEMM.js");
+        const { handleOAuthRoute } = await import("../oauth-server-67YBDP32.js");
         const handled = await handleOAuthRoute(req, res, url, MCP_HTTP_PORT);
         if (handled) return;
       } catch (err) {
@@ -3356,7 +3524,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-FZYLO6RR.js");
+          const { loadWebhookConfig, verifyHmac, processWebhook } = await import("../webhook-pipe-LEXMUQ5B.js");
           const webhookConfig = await loadWebhookConfig();
           const serviceConfig = webhookConfig[serviceName];
           if (!serviceConfig) {
@@ -3452,7 +3620,7 @@ async function startMcpHttpServer() {
             contextPct: body.context_pct
           });
           if (body.context_pct !== void 0 && body.context_pct > 70) {
-            void import("../orchestration-events-5SIJOE4H.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+            void import("../orchestration-events-WV4NWKZH.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
               recordOE({
                 eventType: "context.pressure",
                 source: "exe-daemon.heartbeat",
@@ -3535,36 +3703,70 @@ async function startMcpHttpServer() {
       }
       const projectNameHeader = req.headers["x-project-name"] || "";
       let sessionHint = req.headers["x-exe-session-name"] || req.headers["x-exe-session"] || "";
-      if (sessionHint.includes("$(") || sessionHint.includes("#{") || sessionHint.includes("tmux")) {
-        sessionHint = "";
+      if (sessionHint) {
+        try {
+          const { sanitizeSessionHintHeader, rejectForgedSessionHint } = await import("../mcp-session-identity-T7H2EKFQ.js");
+          const rawHint = sessionHint;
+          sessionHint = sanitizeSessionHintHeader(sessionHint);
+          if (!sessionHint) {
+            process.stderr.write(
+              `[daemon] WARN: discarded malformed session identity header ${JSON.stringify(rawHint)} from agent "${agentId}"
+`
+            );
+          } else {
+            try {
+              const { listSessions: listRegistrySessions } = await import("./session-registry.js");
+              const verdict = rejectForgedSessionHint({
+                agentId,
+                hint: sessionHint,
+                registrySessions: listRegistrySessions()
+              });
+              if (verdict.rejected) {
+                process.stderr.write(`[daemon] WARN: ${verdict.reason}
+`);
+                sessionHint = "";
+              }
+            } catch {
+            }
+          }
+        } catch {
+          if (sessionHint.includes("$(") || sessionHint.includes("#{") || sessionHint.includes("tmux")) {
+            sessionHint = "";
+          }
+        }
       }
       const clientProvidedSessionHint = Boolean(sessionHint);
       if (!sessionHint && agentId) {
         try {
           const liveSessions = await getTmuxSessionsAsync();
-          const agentSessions = liveSessions.filter((s) => s.startsWith(agentId + "-"));
-          if (agentSessions.length === 1) {
-            sessionHint = agentSessions[0];
+          const paneCommands = await getPaneCommandsAsync();
+          const { resolveMcpSessionHint } = await import("../mcp-session-identity-T7H2EKFQ.js");
+          let registrySessions = [];
+          try {
+            const { listSessions: listRegistrySessions } = await import("./session-registry.js");
+            registrySessions = listRegistrySessions();
+          } catch {
           }
-          if (!sessionHint) {
-            const paneCommands = await getPaneCommandsAsync();
-            const roots = liveSessions.filter(
-              (s) => !s.includes("-") && /^[a-z]+\d*$/.test(s) && coordinatorPaneHasLiveAgent(s, paneCommands)
-            );
-            if (roots.length === 1) {
-              sessionHint = roots[0];
-            } else if (roots.length > 1 && agentId) {
-              const agentRoots = roots.filter((r) => r.startsWith(agentId));
-              if (agentRoots.length === 1) {
-                sessionHint = agentRoots[0];
-              }
-              if (!sessionHint) {
-                process.stderr.write(
-                  `[daemon] WARN: ${roots.length} coordinator sessions (${roots.join(", ")}), cannot auto-resolve for agent "${agentId}". Use per-session MCP config.
-`
-                );
-              }
-            }
+          let isCoordinator = false;
+          try {
+            const { isCoordinatorName } = await import("./employees.js");
+            isCoordinator = isCoordinatorName(agentId);
+          } catch {
+          }
+          const resolution = resolveMcpSessionHint({
+            agentId,
+            isCoordinator,
+            liveTmuxSessions: liveSessions,
+            registrySessions,
+            // Only count coordinators that still host a LIVE agent. Orphaned
+            // coordinator shells (agent exited, tmux shell lingers) would otherwise
+            // inflate the count forever and spam "cannot auto-resolve" (bug 6c46d301).
+            coordinatorHasLiveAgent: (s) => coordinatorPaneHasLiveAgent(s, paneCommands)
+          });
+          sessionHint = resolution.sessionHint;
+          if (resolution.warning) {
+            process.stderr.write(`[daemon] WARN: ${resolution.warning}
+`);
           }
         } catch {
         }
@@ -3662,6 +3864,54 @@ async function startMcpHttpServer() {
         } catch (dbInitErr) {
           process.stderr.write(`[exed] DB init on new session FAILED: ${dbInitErr instanceof Error ? dbInitErr.message : String(dbInitErr)}
 `);
+        }
+        try {
+          const { isManagementIdentity } = await import("./employees.js");
+          if (isManagementIdentity(agentId)) {
+            let bindRegistry = [];
+            let bindLive = [];
+            try {
+              const { listSessions: listRegistrySessions } = await import("./session-registry.js");
+              bindRegistry = listRegistrySessions();
+              bindLive = await getTmuxSessionsAsync();
+            } catch {
+            }
+            const { isLauncherCorroboratedIdentity } = await import("../mcp-session-identity-T7H2EKFQ.js");
+            const corroborated = isLauncherCorroboratedIdentity({
+              agentId,
+              registrySessions: bindRegistry,
+              liveTmuxSessions: bindLive
+            });
+            const assessment = assessInitialBindIdentity({
+              agentId,
+              privileged: true,
+              corroborated,
+              enforce: shouldEnforceSessionIdentity()
+            });
+            if (assessment.flagged) {
+              process.stderr.write(`[exed] SECURITY: ${assessment.reason}
+`);
+              recordMcpHttpEvent({
+                level: "warn",
+                message: assessment.reject ? "initial_bind_identity_rejected" : "initial_bind_identity_uncorroborated",
+                method: req.method,
+                agentId,
+                agentRole,
+                runtime
+              });
+            }
+            if (assessment.reject) {
+              sendJsonRpcError2(
+                res,
+                403,
+                `Refusing to bind privileged identity "${agentId}" to a new MCP session: the X-Agent-Id header claims a management role but no launcher-written session-registry entry corroborates it (bug 2138232d). Launch the agent through exe-os, or set EXE_ENFORCE_SESSION_IDENTITY=0 for warn-only.`,
+                getJsonRpcId2(parsedBody),
+                { agentId, agentRole }
+              );
+              return;
+            }
+          }
+        } catch {
         }
         const initIsTransient = !clientProvidedSessionHint;
         const initOwnerKey = mcpSessionOwnerKey2({ agentId, runtime, sessionHint, transient: initIsTransient });
@@ -3868,6 +4118,25 @@ async function startMcpHttpServer() {
           effectiveSessionHint = stored.sessionHint;
         }
       }
+      try {
+        const { reconcileHintWithRegistryIdentity } = await import("../mcp-session-identity-T7H2EKFQ.js");
+        const { listSessions: listRegistrySessions } = await import("./session-registry.js");
+        const recon = reconcileHintWithRegistryIdentity({
+          agentId,
+          hint: effectiveSessionHint,
+          clientProvided: clientProvidedSessionHint,
+          registrySessions: listRegistrySessions(),
+          liveTmuxSessions: await getTmuxSessionsAsync()
+        });
+        if (recon.message) process.stderr.write(`[daemon] ${recon.message}
+`);
+        if (recon.corrected) {
+          effectiveSessionHint = recon.sessionHint;
+          const stored = activeRequestSessionId ? sessionDetails.get(activeRequestSessionId) : void 0;
+          if (stored && recon.sessionHint) stored.sessionHint = recon.sessionHint;
+        }
+      } catch {
+      }
       try {
         await runWithAgent({ agentId, agentRole, sessionHint: effectiveSessionHint, projectName: projectNameHeader || void 0 }, async () => {
           if (wantsJsonOnly) {
@@ -3988,7 +4257,7 @@ async function startMcpHttpServer() {
 `);
         _boundMcpPort = MCP_HTTP_PORT;
         writeDaemonReady({ pid: process.pid, port: MCP_HTTP_PORT });
-        void import("../mcp-port-config-FFAMMLLE.js").then(({ persistMcpPortToConfig }) => persistMcpPortToConfig(String(MCP_HTTP_PORT))).catch(() => {
+        void import("../mcp-port-config-6HYY6J7K.js").then(({ persistMcpPortToConfig }) => persistMcpPortToConfig(String(MCP_HTTP_PORT))).catch(() => {
         });
         recordMcpHttpEvent({
           level: "info",
@@ -4046,6 +4315,20 @@ async function ensureStoreForPolling() {
       }
       await initDatabase({ dbPath: config.dbPath, encryptionKey: masterKey.toString("hex") });
       await ensureSchema();
+      try {
+        const { isLedgerEnabled } = await import("../notification-ledger-SZEPGJQ7.js");
+        if (isLedgerEnabled()) {
+          const { bumpBootGeneration } = await import("../boot-generation-BL2ISK4U.js");
+          const { setDaemonReadyGeneration } = await import("../daemon-ready-signal-LPAZWQOV.js");
+          const generation = await bumpBootGeneration();
+          setDaemonReadyGeneration(generation);
+          process.stderr.write(`[exed] notification ledger enabled \u2014 boot generation ${generation}
+`);
+        }
+      } catch (e) {
+        process.stderr.write(`[exed] boot-generation bump failed (non-fatal): ${e instanceof Error ? e.message : String(e)}
+`);
+      }
       try {
         const { spawnDbReadWorker } = await import("./db-read-worker-client.js");
         spawnDbReadWorker(config.dbPath, masterKey.toString("hex"));
@@ -4065,13 +4348,13 @@ async function ensureStoreForPolling() {
   }
 }
 async function startReviewPolling() {
-  const polling = await import("../review-polling-PCMD5BFN.js");
+  const polling = await import("../review-polling-HXAFJZDA.js");
   const state = {
     lastIntercomSent: /* @__PURE__ */ new Map(),
     lastNudgeSent: /* @__PURE__ */ new Map(),
     intervalMs: REVIEW_POLL_INTERVAL_MS
   };
-  const { pollReviewNudge, createReviewNudgeRealDeps, loadNudgeState } = await import("../daemon-orchestration-7QB6QOXT.js");
+  const { pollReviewNudge, createReviewNudgeRealDeps, loadNudgeState } = await import("../daemon-orchestration-FX4XZDR5.js");
   const nudgeState = loadNudgeState();
   const tick = async () => traceDaemonTimer("review_polling", async () => {
     fired("review_polling");
@@ -4109,16 +4392,17 @@ async function startReviewPolling() {
 }
 var SESSION_TTL_INTERVAL_MS = 5 * 60 * 1e3;
 var SESSION_REGISTRY_MAINTENANCE_INTERVAL_MS = 5 * 60 * 1e3;
+var _wedgeObservations = /* @__PURE__ */ new Map();
 function startSessionTTL() {
   const tick = async () => traceDaemonTimer("session_ttl", async () => {
     fired("session_ttl");
-    if (!await ensureStoreForPolling()) return;
-    if (inPostRestartDestructiveGrace("session_ttl")) return;
     try {
+      if (!await ensureStoreForPolling()) return;
+      if (inPostRestartDestructiveGrace("session_ttl")) return;
       const { getClient } = await import("./database.js");
-      const { checkSessionTTL, createSessionTTLRealDeps } = await import("../daemon-orchestration-7QB6QOXT.js");
+      const { checkSessionTTL, createSessionTTLRealDeps } = await import("../daemon-orchestration-FX4XZDR5.js");
       const deps = createSessionTTLRealDeps(getClient);
-      const killed = await checkSessionTTL(deps);
+      const killed = await checkSessionTTL(deps, _wedgeObservations);
       if (killed.length > 0) acted("session_ttl");
     } catch (err) {
       process.stderr.write(`[exed] Session TTL error: ${err instanceof Error ? err.message : String(err)}
@@ -4131,6 +4415,9 @@ function startSessionTTL() {
 `);
 }
 var COO_RESTART_COOLDOWN_MS = 5 * 6e4;
+var _resolveNpmGlobalRoot = createMemoizedNpmGlobalRootResolver(
+  (file, args, opts) => execFileAsync(file, args, opts)
+);
 var _idleTickCounts = /* @__PURE__ */ new Map();
 function startIdleKill() {
   const tick = async () => traceDaemonTimer("idle_kill", async () => {
@@ -4165,7 +4452,7 @@ function startIdleKill() {
       const cfg = await getCachedConfig();
       if (!cfg) return;
       const { getClient } = await import("./database.js");
-      const { pollIdleKill, createIdleKillRealDeps } = await import("../daemon-orchestration-7QB6QOXT.js");
+      const { pollIdleKill, createIdleKillRealDeps } = await import("../daemon-orchestration-FX4XZDR5.js");
       const { sessions: liveSessions, paneCache, aliveSessions } = await getSharedOrchestrationCaches();
       const realDeps = createIdleKillRealDeps(
         getClient,
@@ -4238,7 +4525,7 @@ function startConsolidation() {
 `);
       }
       try {
-        const { createBackupAsync, enforceRetention } = await import("../db-backup-DLD4QZBO.js");
+        const { createBackupAsync, enforceRetention } = await import("../db-backup-W2QFSYQC.js");
         const p = await createBackupAsync("pre-consolidation");
         if (p) enforceRetention("pre-consolidation");
       } catch (e) {
@@ -4471,7 +4758,7 @@ function startSkillRefinement() {
     if (!shouldRunHeavyJob("skill_refinement")) return;
     try {
       if (!await ensureStoreForPolling()) return;
-      const { runSkillRefinement } = await import("../skill-refinement-74T6VDFM.js");
+      const { runSkillRefinement } = await import("../skill-refinement-DVSYXBBP.js");
       const result = await runSkillRefinement();
       if (result.reviewed > 0) {
         acted("skill_refinement");
@@ -4497,8 +4784,8 @@ function startStaleBranchSweep() {
   const tick = async () => {
     fired("stale_branch_sweep");
     try {
-      const { discoverRepoPaths } = await import("../worktree-sweep-ZAG3V24E.js");
-      const { scanUnmergedBranches } = await import("../branch-hygiene-R5NVTRAY.js");
+      const { discoverRepoPaths } = await import("../worktree-sweep-WTK3MTKH.js");
+      const { scanUnmergedBranchesCached } = await import("../branch-hygiene-TZWK6QCF.js");
       const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       for (const k of _staleBranchAlertedToday) {
         if (!k.endsWith(today)) _staleBranchAlertedToday.delete(k);
@@ -4513,7 +4800,11 @@ function startStaleBranchSweep() {
         await yieldToEventLoop();
         let scan;
         try {
-          scan = await scanUnmergedBranches(repo, { staleHours: STALE_BRANCH_HOURS });
+          scan = await scanUnmergedBranchesCached(
+            repo,
+            { staleHours: STALE_BRANCH_HOURS },
+            { forceRefresh: true }
+          );
         } catch {
           continue;
         }
@@ -4525,13 +4816,13 @@ 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-KONB3C62.js");
+          const { writeNotification } = await import("../notifications-4UT53CDG.js");
           await writeNotification({
             agentId: "exe",
             agentRole: "system",
             event: "error_spike",
             project: repoName,
-            summary: `${scan.staleCount} unmerged remote branch(es) in ${repoName} are >${STALE_BRANCH_HOURS}h old with unique work \u2014 check before starting new work to avoid redoing it. Oldest: ${stale}. Review with: exe-os git-sweep --dry-run`,
+            summary: `${scan.staleCount} unmerged remote branch(es) in ${repoName} are >${STALE_BRANCH_HOURS}h old with unique work \u2014 check before starting new work to avoid redoing it. Oldest: ${stale}. List them with: git branch -r --no-merged origin/main`,
             sessionScope: null
           });
           acted("stale_branch_sweep");
@@ -4982,7 +5273,7 @@ function startReflectionSweep() {
       );
       let runReflection;
       try {
-        ({ runReflection } = await import("../memory-reflection-6N4J2FL7.js"));
+        ({ runReflection } = await import("../memory-reflection-WVNFBJAA.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)}
@@ -5023,7 +5314,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-TQRLZI4D.js");
+        const { insertMemoryCardsForBatch } = await import("../memory-cards-ZRDW7QBX.js");
         const batchSize = 500;
         let offset = 0;
         let totalCards = 0;
@@ -5062,13 +5353,25 @@ function startReflectionSweep() {
   process.stderr.write(`[exed] Reflection sweep started (every 6h)
 `);
 }
-var DB_BACKUP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var DB_BACKUP_TARGET_WINDOW_MS = Number(process.env.EXE_DB_BACKUP_TARGET_WINDOW_MS) || 6 * 60 * 60 * 1e3;
+var DB_BACKUP_INTERVAL_MS = Math.min(60 * 60 * 1e3, DB_BACKUP_TARGET_WINDOW_MS);
 function startDatabaseBackup() {
   const tick = async () => {
     fired("db_backup");
-    if (!shouldRunHeavyJob("db_backup")) return;
     try {
-      const { createBackupAsync, enforceRetention, hasBackupToday } = await import("../db-backup-DLD4QZBO.js");
+      const { createBackupAsync, enforceRetention, hasBackupToday, hasRecentBackup } = await import("../db-backup-W2QFSYQC.js");
+      if (!hasRecentBackup("guaranteed", DB_BACKUP_TARGET_WINDOW_MS)) {
+        const guaranteedPath = await createBackupAsync("guaranteed");
+        if (guaranteedPath) {
+          acted("db_backup");
+          const deleted = enforceRetention("guaranteed");
+          process.stderr.write(
+            `[exed] DB backup guaranteed: ${guaranteedPath.split("/").pop()} (target window ${Math.round(DB_BACKUP_TARGET_WINDOW_MS / 36e5)}h)${deleted > 0 ? ` (rotated ${deleted} old)` : ""}
+`
+          );
+        }
+      }
+      if (!shouldRunHeavyJob("db_backup_daily")) return;
       if (hasBackupToday("daily")) return;
       const backupPath = await createBackupAsync("daily");
       if (backupPath) {
@@ -5078,6 +5381,22 @@ function startDatabaseBackup() {
           `[exed] DB backup: ${backupPath.split("/").pop()}${deleted > 0 ? ` (rotated ${deleted} old)` : ""}
 `
         );
+        try {
+          const { maybeVerifyDailyBackup } = await import("../backup-verify-3Y2FHGZU.js");
+          const verdict = await maybeVerifyDailyBackup(backupPath);
+          if (verdict && !verdict.ok) {
+            process.stderr.write(
+              `[exed] DB backup VERIFY FAIL: ${verdict.backup} \u2014 ${verdict.reason}${verdict.detail ? `: ${verdict.detail}` : ""}
+`
+            );
+          } else if (verdict) {
+            process.stderr.write(`[exed] DB backup verified OK (${verdict.source})
+`);
+          }
+        } catch (verr) {
+          process.stderr.write(`[exed] DB backup verify skipped: ${verr instanceof Error ? verr.message : String(verr)}
+`);
+        }
       }
     } catch (err) {
       process.stderr.write(`[exed] DB backup error: ${err instanceof Error ? err.message : String(err)}
@@ -5087,8 +5406,10 @@ function startDatabaseBackup() {
   tick();
   const timer = setInterval(() => void traceDaemonTimer("db_backup", tick), DB_BACKUP_INTERVAL_MS);
   timer.unref();
-  process.stderr.write(`[exed] Database backup started (daily, keep 3 days)
-`);
+  process.stderr.write(
+    `[exed] Database backup started (guaranteed every \u2264${Math.round(DB_BACKUP_TARGET_WINDOW_MS / 36e5)}h; daily verify window retained)
+`
+  );
 }
 var PURGE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
 function startSoftDeletePurge() {
@@ -5138,7 +5459,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-3LCVQEL7.js");
+      const { sweepExpiredSessionEvents, DEFAULT_SESSION_EVENTS_RETENTION_DAYS } = await import("../session-events-O3BV56ZX.js");
       const days = SESSION_EVENTS_RETENTION_DAYS ?? DEFAULT_SESSION_EVENTS_RETENTION_DAYS;
       const count = await sweepExpiredSessionEvents(getClient(), days);
       if (count > 0) {
@@ -5169,11 +5490,15 @@ function startIntercomQueueDrain() {
   const tick = async () => traceDaemonTimer("intercom_queue_drain", async () => {
     fired("intercom_queue_drain");
     try {
-      const { drainQueueAsync, readQueue } = await import("../intercom-queue-VU2G6F5R.js");
+      const { drainQueueAsync, readQueue } = await import("../intercom-queue-ZFEQALR3.js");
       const {
         sendIntercomAsync: centralSendIntercomAsync,
-        decideQueuedNudgeDrain,
-        countScopedPendingReviews
+        countScopedPendingReviews,
+        countScopedOpenTasks,
+        dispositionWedgedSessionTask,
+        decideDrainSend,
+        offlineIfEmpty,
+        paneHasPendingInput
       } = await import("./tmux-routing.js");
       const { baseAgentName, getCoordinatorName } = await import("./employees.js");
       const agentsWithEmptyInbox = /* @__PURE__ */ new Set();
@@ -5206,6 +5531,18 @@ function startIntercomQueueDrain() {
           if (count !== null) pendingReviewCounts.set(target, count);
         }
       }
+      const openTaskCounts = /* @__PURE__ */ new Map();
+      {
+        const queue = readQueue();
+        const taskTargets = new Set(
+          queue.filter((q) => q.intercomReason === "nudge" || q.intercomReason === "signal" || !q.intercomReason).map((q) => q.targetSession)
+        );
+        for (const target of taskTargets) {
+          const agent = baseAgentName(target.split("-")[0] ?? target);
+          const count = await countScopedOpenTasks(target, agent);
+          if (count !== null) openTaskCounts.set(target, count);
+        }
+      }
       const result = await drainQueueAsync(
         // Bug ddbfc3f6: async busy check via the shared async pane cache —
         // no sync execFileSync("tmux") per queue item on the event loop.
@@ -5217,24 +5554,52 @@ function startIntercomQueueDrain() {
           try {
             const agentRaw = session.split("-")[0] ?? session;
             const agent = baseAgentName(agentRaw);
-            const decision = decideQueuedNudgeDrain(item.intercomReason, {
-              hasUnreadMessages: !agentsWithEmptyInbox.has(agent),
-              pendingReviewCount: pendingReviewCounts.get(session) ?? null,
-              hasInProgressTask: false
+            const pane = await capturePaneAsync(session, 8);
+            return await decideDrainSend(item, {
+              pane,
+              paneState: classifyPaneState(pane),
+              hasPendingInput: paneHasPendingInput(pane),
+              nudgeState: {
+                hasUnreadMessages: !agentsWithEmptyInbox.has(agent),
+                pendingReviewCount: pendingReviewCounts.get(session) ?? null,
+                openTaskCount: openTaskCounts.get(session) ?? null,
+                hasInProgressTask: false
+              },
+              deliver: (s, reason) => centralSendIntercomAsync(s, { reason }),
+              disposition: dispositionWedgedSessionTask
             });
-            if (decision.action === "drop") {
-              process.stderr.write(`[exe-daemon] dropping stale ${item.intercomReason ?? "nudge"} intercom for ${session} (${decision.reason})
-`);
-              return true;
-            }
-            const outcome = await centralSendIntercomAsync(session, {
-              reason: item.intercomReason ?? "nudge"
-            });
-            return outcome === "delivered" || outcome === "debounced" || outcome === "skipped_exe";
           } catch (e) {
             process.stderr.write("[exe-daemon] intercom send to " + session + ": " + (e instanceof Error ? e.message : String(e)) + "\n");
             return false;
           }
+        },
+        void 0,
+        // notifyExpiry — use the module default (notifyExpiredIntercom)
+        10,
+        // Terminal disposition (bug e9c19ffe + e7880e0e): a nudge that has
+        // exhausted its retry budget (or TTL-expired) against a wedged EMPLOYEE
+        // session routes that session's in_progress task to blocked. Pure DB
+        // write — never a keystroke, never a buffer clear — so a human
+        // mid-typing can never be clobbered. Round 4: an empty/uncapturable pane
+        // is OFFLINE (⇒ wedged), and only a CONFIRMED "dispositioned" removes the
+        // item; "error" returns false so drainQueueAsync keeps it for retry.
+        async (item) => {
+          try {
+            const pane = await capturePaneAsync(item.targetSession, 8);
+            const state = offlineIfEmpty(pane, classifyPaneState(pane));
+            const hasPendingInput = paneHasPendingInput(pane);
+            const outcome = await dispositionWedgedSessionTask(
+              item.targetSession,
+              `Auto-blocked: intercom (${item.intercomReason ?? "nudge"}) undeliverable after retry budget exhausted \u2014 session wedged (state=${state}, pendingInput=${hasPendingInput}; ${item.reason}). Re-dispatch after clearing the pane.`,
+              { state, hasPendingInput }
+            );
+            if (outcome === "dispositioned") return "dispositioned";
+            if (outcome === "error") return "error";
+            return "declined";
+          } catch (e) {
+            process.stderr.write("[exe-daemon] intercom disposition for " + item.targetSession + ": " + (e instanceof Error ? e.message : String(e)) + "\n");
+            return "error";
+          }
         }
       );
       if (result.drained > 0 || result.failed > 0) {
@@ -5253,12 +5618,50 @@ function startIntercomQueueDrain() {
   process.stderr.write(`[exed] Intercom queue drain started (every ${QUEUE_DRAIN_INTERVAL_MS / 1e3}s)
 `);
 }
+function startLedgerDrain() {
+  const tick = async () => traceDaemonTimer("ledger_drain", async () => {
+    fired("ledger_drain");
+    try {
+      const { isLedgerEnabled, drainLedger } = await import("../notification-ledger-SZEPGJQ7.js");
+      if (!isLedgerEnabled()) return;
+      const result = await drainLedger({
+        // Shadow "would-deliver": idle target = would-deliver, busy = retry.
+        // No real send here — the legacy intercom path owns actual delivery.
+        attemptDelivery: async (row) => {
+          const session = row.targetSession;
+          if (!session) return false;
+          const state = classifyPaneState(await capturePaneAsync(session, 5));
+          const busy = state === "thinking" || state === "tool";
+          if (busy) return false;
+          process.stderr.write(
+            `[exed] ledger(shadow) WOULD deliver ${row.kind} \u2192 ${session} (id ${row.id}, retries ${row.retryCount})
+`
+          );
+          return true;
+        }
+      });
+      if (result.delivered || result.retried || result.expired || result.escalated) {
+        acted("ledger_drain");
+        process.stderr.write(
+          `[exed] Ledger(shadow): ${result.delivered} would-deliver, ${result.retried} retry, ${result.expired} expired, ${result.escalated} escalated
+`
+        );
+      }
+    } catch (e) {
+      process.stderr.write("[exe-daemon] ledger drain: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    }
+  });
+  const timer = setInterval(tick, QUEUE_DRAIN_INTERVAL_MS);
+  timer.unref();
+  process.stderr.write(`[exed] Notification ledger drain started (shadow, every ${QUEUE_DRAIN_INTERVAL_MS / 1e3}s)
+`);
+}
 var ORPHAN_REAP_INTERVAL_MS = 5 * 60 * 1e3;
 function startOrphanReaper() {
   const tick = async () => traceDaemonTimer("orphan_reaper", async () => {
     fired("orphan_reaper");
     try {
-      const { reapOrphanedMcpProcesses, createOrphanReaperRealDepsAsync } = await import("../daemon-orchestration-7QB6QOXT.js");
+      const { reapOrphanedMcpProcesses, createOrphanReaperRealDepsAsync } = await import("../daemon-orchestration-FX4XZDR5.js");
       const deps = await createOrphanReaperRealDepsAsync();
       const reaped = await reapOrphanedMcpProcesses(deps);
       if (reaped.length > 0) acted("orphan_reaper");
@@ -5283,7 +5686,7 @@ function startZombieAgentReaper() {
   const tick = async () => traceDaemonTimer("zombie_agent_reaper", async () => {
     fired("zombie_agent_reaper");
     try {
-      const { reapZombieAgentProcesses, createZombieAgentReaperRealDepsAsync } = await import("../daemon-orchestration-7QB6QOXT.js");
+      const { reapZombieAgentProcesses, createZombieAgentReaperRealDepsAsync } = await import("../daemon-orchestration-FX4XZDR5.js");
       const deps = await createZombieAgentReaperRealDepsAsync();
       const reaped = reapZombieAgentProcesses(deps);
       if (reaped.length > 0) acted("zombie_agent_reaper");
@@ -5307,7 +5710,7 @@ async function startDaemonMemoryPressureWatchdog() {
   try {
     const cfg = await getCachedConfig();
     if (!cfg) return;
-    const { startMemoryPressureWatchdog: startWatchdog, MEMORY_PRESSURE_WATCHDOG_DEFAULTS } = await import("../memory-pressure-watchdog-RRIAXPXQ.js");
+    const { startMemoryPressureWatchdog: startWatchdog, MEMORY_PRESSURE_WATCHDOG_DEFAULTS } = await import("../memory-pressure-watchdog-HN5X7AVN.js");
     const watchdogCfg = {
       ...MEMORY_PRESSURE_WATCHDOG_DEFAULTS,
       ...cfg.memoryPressureWatchdog ?? {}
@@ -5338,7 +5741,7 @@ function startWorktreeReaper() {
   const tick = async () => traceDaemonTimer("worktree_reaper", async () => {
     fired("worktree_reaper");
     try {
-      const { reapOrphanedWorktrees, createWorktreeReaperRealDeps } = await import("../daemon-orchestration-7QB6QOXT.js");
+      const { reapOrphanedWorktrees, createWorktreeReaperRealDeps } = await import("../daemon-orchestration-FX4XZDR5.js");
       const deps = await createWorktreeReaperRealDeps();
       const result = await reapOrphanedWorktrees(deps);
       if (result.pruned.length > 0) {
@@ -5378,9 +5781,9 @@ function startWorktreeReaper() {
               }
               continue;
             }
-            const { cleanupAgentWorktree } = await import("../worktree-sweep-ZAG3V24E.js");
-            const { getMainRepoRoot } = await import("../worktree-GVF2I5FP.js");
-            const repoRoot = getMainRepoRoot(signal.worktreePath);
+            const { cleanupAgentWorktree } = await import("../worktree-sweep-WTK3MTKH.js");
+            const { getMainRepoRootAsync } = await import("../worktree-LL62PLQB.js");
+            const repoRoot = await getMainRepoRootAsync(signal.worktreePath);
             if (repoRoot && signal.agentId) {
               const notes = await cleanupAgentWorktree(repoRoot, signal.agentId);
               if (notes) {
@@ -5412,7 +5815,7 @@ function startAutoWake() {
     if (!await ensureStoreForPolling()) return;
     try {
       const { getClient } = await import("./database.js");
-      const { pollOrphanedTasks, createAutoWakeRealDeps } = await import("../daemon-orchestration-7QB6QOXT.js");
+      const { pollOrphanedTasks, createAutoWakeRealDeps } = await import("../daemon-orchestration-FX4XZDR5.js");
       const deps = createAutoWakeRealDeps(getClient, process.cwd(), getTmuxSessionsAsync);
       const woken = await pollOrphanedTasks(deps);
       if (woken.length > 0) acted("auto_wake");
@@ -5424,7 +5827,7 @@ function startAutoWake() {
         const signalBase = path3.join(os2.homedir(), ".exe-os", "task-signals");
         if (existsSync4(signalBase)) {
           const { readdirSync: readdirSync2, statSync: statSyncFs } = await import("fs");
-          const { sendIntercomAsync } = await import("./tmux-routing.js");
+          const { sendIntercomAsync, extractRootExe } = await import("./tmux-routing.js");
           const sessionCache = path3.join(os2.homedir(), ".exe-os", "session-cache");
           const sessions = await getTmuxSessionsAsync();
           const signalDirs = [];
@@ -5463,7 +5866,7 @@ function startAutoWake() {
               if (age > 60 * 60 * 1e3) {
                 try {
                   unlinkSync2(signalPath);
-                  void import("../orchestration-events-5SIJOE4H.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+                  void import("../orchestration-events-WV4NWKZH.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
                     recordOE({ eventType: "signal.stale", source: "exe-daemon.autoWake", severity: "warn", payload: { file, ageMinutes: Math.round(age / 6e4) } });
                   }).catch(() => {
                   });
@@ -5492,9 +5895,17 @@ function startAutoWake() {
 `
                 );
               } 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)
+                const nudgeScope = scope ?? extractRootExe(match) ?? null;
+                const result = await sendIntercomAsync(match, { force: true, reason: "signal", callerSessionScope: nudgeScope });
+                if (result === "failed") {
+                  process.stderr.write(
+                    `[exed] Signal-nudge: delivery FAILED to ${match} (signal age ${Math.round(age / 1e3)}s, scope=${nudgeScope ?? "none"}) \u2014 signal kept; will retry next tick
+`
+                  );
+                } else {
+                  process.stderr.write(`[exed] Signal-nudge: ${result} intercom to ${match} (signal age ${Math.round(age / 1e3)}s)
 `);
+                }
               }
             }
           }
@@ -5523,7 +5934,7 @@ function startWalCheckpoint() {
     try {
       const { getClient, runWalCheckpoint } = await import("./database.js");
       const client = getClient();
-      const { findActiveDb } = await import("../db-backup-DLD4QZBO.js");
+      const { findActiveDb } = await import("../db-backup-W2QFSYQC.js");
       const dbPath = findActiveDb();
       const started = Date.now();
       const result = await runWalCheckpoint(client, dbPath, true);
@@ -5601,7 +6012,7 @@ function startStuckTaskRelease() {
         createStuckTaskRealDeps,
         escalateStuckBlockedTasks,
         createStuckBlockedRealDeps
-      } = await import("../daemon-orchestration-7QB6QOXT.js");
+      } = await import("../daemon-orchestration-FX4XZDR5.js");
       const deps = createStuckTaskRealDeps(getClient);
       const released = await releaseStuckTasks(deps);
       if (released.length > 0) {
@@ -5796,12 +6207,12 @@ function startTaskEnforcementScanner() {
   const tick = async () => traceDaemonTimer("task_enforcement", async () => {
     fired("task_enforcement");
     try {
-      const { runTaskEnforcementTick } = await import("../task-enforcement-VI7L43DC.js");
+      const { runTaskEnforcementTick } = await import("../task-enforcement-IPIZX2MM.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-CQEG5SSJ.js");
+      const { sessionScopeFilter } = await import("../task-scope-FOIW25HR.js");
       const transport = getTransport();
       const { sessions: allSessions, paneCache, aliveSessions } = await getSharedOrchestrationCaches();
       await yieldToEventLoop();
@@ -5812,10 +6223,10 @@ function startTaskEnforcementScanner() {
         sendKeysLiteral: transport.sendKeysLiteral?.bind(transport),
         isAlive: (session) => aliveSessions.has(session)
       };
-      const { checkAutoWakeGates } = await import("../daemon-orchestration-7QB6QOXT.js");
-      const { ensureEmployeeAsync, employeeSessionName } = await import("./tmux-routing.js");
+      const { checkAutoWakeGates } = await import("../daemon-orchestration-FX4XZDR5.js");
+      const { ensureEmployeeAsync, employeeSessionName, sendIntercomAsync } = await import("./tmux-routing.js");
       const { shouldAutoInstance } = await import("./employees.js");
-      const { recordOrchestrationEventBestEffort } = await import("../orchestration-events-5SIJOE4H.js");
+      const { recordOrchestrationEventBestEffort } = await import("../orchestration-events-WV4NWKZH.js");
       const projectDir = process.cwd();
       await runTaskEnforcementTick({
         transport: enforcementTransport,
@@ -5840,6 +6251,16 @@ function startTaskEnforcementScanner() {
 `));
           return { status: "intercom_unprocessed", sessionName: employeeSessionName(reviewerName, sessionScope) };
         },
+        // Bug 018aaf31: wake a LIVE-but-idle reviewer/coordinator that owns a
+        // needs_review item. Same intercom funnel as the worker-nudge; reason
+        // "completion" renders "An employee completed work — review it". The
+        // input-buffer/busy/idle/debounce guards inside sendIntercom decide
+        // whether to type, queue, or defer — so this never splices into a founder
+        // keystroke and never piles onto a busy reviewer.
+        reviewerNudge: (reviewerSession, sessionScope) => {
+          void sendIntercomAsync(reviewerSession, { callerSessionScope: sessionScope, reason: "completion" }).catch((err) => process.stderr.write(`[exed] Reviewer nudge async failed for ${reviewerSession}: ${err instanceof Error ? err.message : String(err)}
+`));
+        },
         zombieWorkerRecover: async (session, agentName, sessionScope, reason) => {
           const gateReason = checkAutoWakeGates(`mcp-zombie::${agentName}::${sessionScope || session}`, Date.now());
           if (gateReason) {
@@ -6097,7 +6518,7 @@ function startBackgroundJobGuardrails() {
   const tick = async () => traceDaemonTimer("background_job_guardrails", async () => {
     fired("background_job_guardrails");
     try {
-      const { enforceBackgroundJobGuardrailsAsync } = await import("../background-jobs-STURKDCS.js");
+      const { enforceBackgroundJobGuardrailsAsync } = await import("../background-jobs-EXR5RVGG.js");
       const actions = await enforceBackgroundJobGuardrailsAsync();
       if (actions.length > 0) {
         acted("background_job_guardrails");
@@ -6130,11 +6551,14 @@ function handleSignalShutdown() {
     ...signalAttribution
   });
   logShutdown(restartIntent ? "restart shutdown" : "graceful shutdown", "SIGTERM/SIGINT", signalAttribution);
-  void shutdown(restartIntent ? 75 : 0);
+  void shutdown(restartIntent ? 75 : 0, restartIntent ? reason ?? "restart-intent" : null);
 }
 process.on("SIGINT", handleSignalShutdown);
 process.on("SIGTERM", handleSignalShutdown);
 process.on("exit", (code) => {
+  if (_bootPhase !== "ready" && code !== 0) {
+    recordExitBreadcrumb("boot-abort", code, `boot_abort:${_bootPhase}`);
+  }
   if (_bootPhase === "ready") return;
   try {
     logDaemonHealth({
@@ -6252,7 +6676,7 @@ function startBugAutoFix() {
             for (const exeSession of exeSessions) {
               const ctoSession = `${ctoName}-${exeSession}`;
               if (sessions.includes(ctoSession)) {
-                await sendIntercomAsync(ctoSession);
+                await sendIntercomAsync(ctoSession, { callerSessionScope: exeSession });
                 break;
               }
             }
@@ -6428,9 +6852,9 @@ function startAutoUpdateCheck() {
       const effectiveChannel = updateChannel ?? "stable";
       if (effectiveChannel === "pinned") return;
       if (!autoInstall && !config.autoUpdate.checkOnBoot) return;
-      const { checkForUpdate, channelToInstallTag } = await import("../update-check-HFO4VHO4.js");
+      const { checkForUpdateAsync, channelToInstallTag } = await import("../update-check-3FHAWIG2.js");
       const packageRoot = new URL("../..", import.meta.url).pathname;
-      const result = checkForUpdate(packageRoot, effectiveChannel);
+      const result = await checkForUpdateAsync(packageRoot, effectiveChannel);
       if (!result.updateAvailable) return;
       acted("auto_update_check");
       const channelLabel = effectiveChannel === "canary" ? " (canary)" : "";
@@ -6531,7 +6955,7 @@ if (process.platform === "darwin") {
 logBoot({ socketPath: SOCKET_PATH, pidPath: PID_PATH });
 void (async () => {
   try {
-    const { cleanupCrashDebris } = await import("../db-backup-DLD4QZBO.js");
+    const { cleanupCrashDebris } = await import("../db-backup-W2QFSYQC.js");
     const removed = cleanupCrashDebris();
     if (removed > 0) {
       process.stderr.write(`[exed] Startup cleanup: pruned ${removed} crash-debris file(s) (backups/quarantine).
@@ -6677,9 +7101,7 @@ function startEventLoopLagDetector() {
   const SELF_INFLICTED_ROLLING_WINDOW_MS = parseFloat(process.env.EXE_SELF_INFLICTED_ROLLING_WINDOW_MS ?? "") || 3e5;
   const LAG_WARN_MS = 3e3;
   const LAG_CRITICAL_MS = 1e4;
-  const SELF_HEAL_SINGLE_MS = parseFloat(process.env.EXE_SELF_HEAL_SINGLE_MS ?? "") || 12e4;
-  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;
+  const { singleMs: SELF_HEAL_SINGLE_MS, consecutive: SELF_HEAL_CONSECUTIVE, thresholdMs: SELF_HEAL_THRESHOLD_MS } = resolveSelfHealThresholds();
   let consecutiveSevereBlocks = 0;
   let selfInflictedWindow = [];
   touchEventLoopHeartbeat();
@@ -6707,7 +7129,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-5SIJOE4H.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+      void import("../orchestration-events-WV4NWKZH.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
         recordOE({ eventType: "daemon.event_loop_blocked", source: "exe-daemon.lagDetector", severity: "error", durationMs: lag });
       }).catch(() => {
       });
@@ -6730,7 +7152,7 @@ function startEventLoopLagDetector() {
       }
       const load1m = os2.loadavg()[0] ?? 0;
       const cpuCount = os2.cpus().length || 1;
-      const starvationRatio = parseFloat(process.env.EXE_STARVATION_LOAD_RATIO ?? "1.5");
+      const starvationRatio = resolveSelfHealThresholds().starvationRatio;
       const catchUpActive = inBootCatchUpGrace();
       const decision = decideDaemonSelfHeal({
         lagMs: lag,
@@ -6808,7 +7230,7 @@ function startEventLoopLagDetector() {
         _lastSelfHealShutdownAtMs = Date.now();
         process.stderr.write(healMsg + "\n");
         logDaemonHealth({ event: "self_heal_restart", pid: process.pid, message: healMsg, data: { lagMs: lag, reason: "single_block" } });
-        void shutdown(75);
+        dispatchSelfHealRestart(lag, "single_block", SELF_HEAL_ACTION_DEPS);
         return;
       }
       if (decision.restart && decision.reason === "consecutive_blocks") {
@@ -6822,7 +7244,7 @@ function startEventLoopLagDetector() {
         _lastSelfHealShutdownAtMs = Date.now();
         process.stderr.write(healMsg + "\n");
         logDaemonHealth({ event: "self_heal_restart", pid: process.pid, message: healMsg, data: { lagMs: lag, reason: "consecutive_blocks", count: consecutiveSevereBlocks } });
-        void shutdown(75);
+        dispatchSelfHealRestart(lag, "consecutive_blocks", SELF_HEAL_ACTION_DEPS);
         return;
       }
     } else if (lag > LAG_WARN_MS) {
@@ -6889,7 +7311,7 @@ function startTaskFileResync() {
                 });
                 if (Number(res.rowsAffected ?? 0) > 0) {
                   synced++;
-                  void import("../orchestration-events-5SIJOE4H.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+                  void import("../orchestration-events-WV4NWKZH.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
                     recordOE({
                       eventType: "task_file.resynced",
                       source: "exe-daemon.taskFileResync",
@@ -6926,7 +7348,7 @@ function startTaskGroupBarriers() {
       fired("task_group_barriers");
       if (!await ensureStoreForPolling()) return;
       try {
-        const { pollTaskGroupBarriers } = await import("../daemon-orchestration-7QB6QOXT.js");
+        const { pollTaskGroupBarriers } = await import("../daemon-orchestration-FX4XZDR5.js");
         const firedCount = await pollTaskGroupBarriers();
         if (firedCount > 0) {
           acted("task_group_barriers");
@@ -6948,7 +7370,7 @@ function startCheckpointGc() {
       fired("checkpoint_gc");
       if (!await ensureStoreForPolling()) return;
       try {
-        const { gcStaleCheckpoints } = await import("../daemon-orchestration-7QB6QOXT.js");
+        const { gcStaleCheckpoints } = await import("../daemon-orchestration-FX4XZDR5.js");
         const cleared = await gcStaleCheckpoints();
         if (cleared > 0) {
           acted("checkpoint_gc");
@@ -6979,7 +7401,7 @@ function startDaemonHeartbeat() {
 function startDispatchAckCleanup() {
   setInterval(async () => {
     try {
-      const { cleanStaleDispatchAcks } = await import("../dispatch-ack-4S44HBWB.js");
+      const { cleanStaleDispatchAcks } = await import("../dispatch-ack-VYH3ONSS.js");
       cleanStaleDispatchAcks();
     } catch {
     }
@@ -6988,14 +7410,14 @@ function startDispatchAckCleanup() {
 function startProjectionWorkerDeferred() {
   setTimeout(async () => {
     try {
-      const { startProjectionWorker } = await import("../projection-worker-ZVOFHTXT.js");
+      const { startProjectionWorker } = await import("../projection-worker-FZ7YSN3G.js");
       startProjectionWorker();
     } catch {
     }
   }, 2e4);
 }
 async function startToolTelemetry() {
-  const { startToolTelemetryFlush } = await import("../tool-telemetry-ULIDUK3P.js");
+  const { startToolTelemetryFlush } = await import("../tool-telemetry-KBXSBDTK.js");
   startToolTelemetryFlush();
   process.stderr.write("[exed] Tool telemetry started (flush every 5m)\n");
 }
@@ -7026,6 +7448,7 @@ function startLocalFirstTimers() {
   setTimeout(() => void retryPendingMessages(), 15e3);
   void drainIngestOutbox();
   startIntercomQueueDrain();
+  startLedgerDrain();
   startReviewPolling();
   startSessionTTL();
   startTaskEnforcementScanner();
@@ -7160,7 +7583,7 @@ function startLocalFirstTimers() {
     fired("orphan_task_cleanup");
     try {
       if (!await ensureStoreForPolling()) return;
-      const { cleanOrphanedTaskFiles } = await import("../tasks-crud-UGK5A25L.js");
+      const { cleanOrphanedTaskFiles } = await import("../tasks-crud-HBDKE6C5.js");
       const count = await cleanOrphanedTaskFiles();
       if (count > 0) {
         acted("orphan_task_cleanup");
@@ -7176,7 +7599,7 @@ function startLocalFirstTimers() {
     fired("task_file_consistency");
     try {
       if (!await ensureStoreForPolling()) return;
-      const { checkTaskFileConsistency } = await import("../tasks-crud-UGK5A25L.js");
+      const { checkTaskFileConsistency } = await import("../tasks-crud-HBDKE6C5.js");
       const mismatches = await checkTaskFileConsistency();
       if (mismatches > 0) {
         acted("task_file_consistency");
@@ -7195,7 +7618,7 @@ function startLocalFirstTimers() {
   const TELEMETRY_DAILY_MS = 24 * 60 * 60 * 1e3;
   const telemetryDaily = async () => {
     try {
-      const { sendTelemetry, isTelemetryEnabled } = await import("../telemetry-upload-7LBYGPCB.js");
+      const { sendTelemetry, isTelemetryEnabled } = await import("../telemetry-upload-ZOXHRWR5.js");
       if (!isTelemetryEnabled()) return;
       const { upstream } = await sendTelemetry(24);
       if (upstream.startsWith("sent")) {
@@ -7307,7 +7730,76 @@ function startLocalFirstTimers() {
     }
   }, 3e4);
 }
+async function enterDegradedBreakerMode(crashCount) {
+  const requestedHost = process.env.EXE_MCP_HOST || "127.0.0.1";
+  const isRemote = !["127.0.0.1", "::1", "localhost"].includes(requestedHost);
+  const allowRemote = /^(1|true|yes|on)$/i.test(process.env.EXE_MCP_ALLOW_REMOTE ?? "");
+  const host = isRemote && !allowRemote ? "127.0.0.1" : requestedHost;
+  let port = 48739;
+  try {
+    port = await resolveAndClaimPort();
+  } catch {
+  }
+  const degradedBody = () => JSON.stringify({
+    jsonrpc: "2.0",
+    error: {
+      code: -32002,
+      message: `exe-os daemon is DEGRADED \u2014 restart circuit breaker OPEN after ${crashCount} crash restarts (bug 2fee6110). Heavy work is suspended to protect system memory. Recover: 'exe-os daemon reset-breaker' then relaunch. Details: 'exe-os daemon status'.`
+    },
+    id: null
+  });
+  const srv = createHttpServer((req, res) => {
+    try {
+      res.setHeader("Access-Control-Allow-Origin", "http://127.0.0.1");
+      const p = (req.url || "/").split("?")[0];
+      if (req.method === "GET" && p === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          status: "degraded",
+          reason: "restart_circuit_breaker_tripped",
+          crashRestartsInWindow: crashCount,
+          version: PACKAGE_VERSION,
+          alert: readBreakerAlert() ?? void 0,
+          recovery: "exe-os daemon reset-breaker"
+        }));
+        return;
+      }
+      res.writeHead(503, { "Content-Type": "application/json", "Retry-After": "300" });
+      res.end(degradedBody());
+    } catch {
+    }
+  });
+  await new Promise((resolve) => {
+    srv.once("error", (err) => {
+      process.stderr.write(`[exed] Degraded health server bind failed (${err.code || err.message}) \u2014 staying alive without it.
+`);
+      resolve();
+    });
+    srv.listen(port, host, () => {
+      process.stderr.write(`[exed] DEGRADED health server on ${host}:${port} (breaker tripped \u2014 503 + /health only).
+`);
+      resolve();
+    });
+  });
+  setInterval(() => {
+    process.stderr.write(
+      `[exed] DEGRADED (breaker open, ${crashCount} crashes). No DB/backups/timers. Recover: 'exe-os daemon reset-breaker'. Alert: ${restartBreakerAlertPath()}
+`
+    );
+  }, 5 * 60 * 1e3);
+}
 try {
+  const breaker = recordDaemonRestart();
+  process.stderr.write(
+    `[exed] Boot classified as ${breaker.bootClass} (${breaker.reasonLabel}); crashes=${breaker.crashInWindow}/${5}, restarts=${breaker.restartsInWindow} in window.
+`
+  );
+  if (breaker.trip) {
+    logRestartEvent("daemon_restart_breaker_tripped", { crash_in_window: breaker.crashInWindow, restarts_in_window: breaker.restartsInWindow });
+    await enterDegradedBreakerMode(breaker.crashInWindow);
+    await new Promise(() => {
+    });
+  }
   const mcpRegPath = new URL("../mcp/register-tools.js", import.meta.url).href;
   const { registerAllTools: regFn } = await import(
     /* @vite-ignore */
@@ -7350,6 +7842,7 @@ try {
 }
 export {
   decidePortHolderAction,
+  getLastBlockingTimer,
   injectRegisterAllTools,
   isCrashLoopBreakerActive,
   isEventLoopBlockedNow,