@askexenow/exe-os 0.9.342 → 0.9.343

package/dist/lib/exe-daemon.js

@@ -4,10 +4,20 @@ import {
   restartBootsInWindow,
   restartBreakerAlertPath,
   writeDaemonExitBreadcrumb
-} from "../chunk-HJ447YER.js";
+} from "../chunk-S3FIQCSM.js";
 import {
   pushNotifyAsync
-} from "../chunk-3SW4OEHB.js";
+} from "../chunk-KIUNO3JP.js";
+import {
+  disposeDbWriteWorker,
+  isDbWriteWorkerReady,
+  isWriteWorkerEnabled,
+  spawnDbWriteWorker,
+  writeMemoryInWorker
+} from "../chunk-LUQ57SRM.js";
+import {
+  shouldScheduleDaemonRestartHandoff
+} from "../chunk-PWRC5XZO.js";
 import {
   clearDaemonReady,
   eventLoopHeartbeatPath,
@@ -17,7 +27,7 @@ import {
   getMcpToolFamily,
   inferMcpRuntime,
   recordMcpHttpEvent
-} from "../chunk-RAXVPNMR.js";
+} from "../chunk-ZUBUP66T.js";
 import {
   deserializeArgs,
   serializeResultSet
@@ -29,11 +39,14 @@ import {
   findScopedDuplicate,
   governMemoryRecord,
   schedulePostWriteMemoryHygiene
-} from "../chunk-6XWTQUO4.js";
+} from "../chunk-4MLSFZLY.js";
 import "../chunk-4QCFFW2H.js";
 import {
   BUSY_PATTERN
 } from "../chunk-GWDSB25T.js";
+import {
+  sweepPauseTotalMs
+} from "../chunk-M6DZYWZH.js";
 import {
   attributeSignalSource,
   consumeRestartIntentDetail,
@@ -45,7 +58,7 @@ import {
   ensureDaemonToken,
   reconcileSessionAgentIdentity,
   shouldEnforceSessionIdentity
-} from "../chunk-X2Q5NLUL.js";
+} from "../chunk-5VV2YMMB.js";
 import {
   DAEMON_RSS_RESTART_DEBOUNCE,
   DAEMON_RSS_STARTUP_GRACE_MS,
@@ -82,7 +95,7 @@ import {
   EXE_AI_DIR,
   MODELS_DIR,
   resolveEmbedModelFile
-} from "../chunk-WZHZCDDO.js";
+} from "../chunk-OL4JFQ2T.js";
 import "../chunk-BYTDMAGB.js";
 import "../chunk-MLKGABMK.js";
 
@@ -92,7 +105,7 @@ import net from "net";
 import v8 from "v8";
 import { createServer as createHttpServer, request as httpRequest } from "http";
 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 { writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, mkdirSync as mkdirSync3, existsSync as existsSync5, readFileSync as readFileSync5, chmodSync, readdirSync, renameSync, statSync as statSync2 } from "fs";
 import { writeFile } from "fs/promises";
 import { execSync as execSyncNode, execFile as execFileNode } from "child_process";
 import { promisify } from "util";
@@ -322,6 +335,11 @@ function initMetrics() {
   });
 }
 
+// src/lib/daemon-timer-warnings.ts
+function shouldWarnSlowTimer(durationMs, slept, thresholdMs) {
+  return !slept && durationMs >= thresholdMs;
+}
+
 // src/lib/mcp-init-grace.ts
 var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function awaitPendingMcpInit(ownerKey, requestSessionId, deps, transientMatch) {
@@ -376,6 +394,176 @@ async function awaitPendingMcpInit(ownerKey, requestSessionId, deps, transientMa
   return null;
 }
 
+// src/lib/daemon-coverage-gap.ts
+import { closeSync, existsSync as existsSync2, mkdirSync, openSync, readFileSync as readFileSync2, readSync, statSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var HEALTH_LOG_TAIL_BYTES = 512 * 1024;
+var DEFAULT_COVERAGE_GAP_THRESHOLD_MS = 30 * 60 * 1e3;
+var DEFAULT_COVERAGE_GAP_ALERT_THRESHOLD_MS = 60 * 60 * 1e3;
+function resolveCoverageGapAlertThresholdMs() {
+  const raw = Number(process.env.EXE_HEARTBEAT_GAP_ALERT_MS);
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : DEFAULT_COVERAGE_GAP_ALERT_THRESHOLD_MS;
+}
+var COVERAGE_GAP_ALERT_THRESHOLD_MS = resolveCoverageGapAlertThresholdMs();
+function shouldAlertCoverageGap(a, alertThresholdMs) {
+  return Number.isFinite(a.gapMs) && a.gapMs > 0 && a.gapMs > alertThresholdMs;
+}
+function shouldWriteCoverageGapAlert(bootClass, a, alertThresholdMs) {
+  return bootClass === "coverage_gap" && a !== void 0 && shouldAlertCoverageGap(a, alertThresholdMs);
+}
+var COVERAGE_GAP_ALERT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function clearCoverageGapAlertIfExpired(maxAgeMs = COVERAGE_GAP_ALERT_MAX_AGE_MS) {
+  try {
+    const alert = readCoverageGapAlert();
+    if (!alert) return;
+    const detectedAt = typeof alert.detectedAt === "string" ? Date.parse(alert.detectedAt) : NaN;
+    if (!Number.isFinite(detectedAt) || Date.now() - detectedAt > maxAgeMs) {
+      clearCoverageGapAlert();
+    }
+  } catch {
+  }
+}
+function coverageGapAlertPath() {
+  const home = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? join(homedir(), ".exe-os");
+  return join(home, "daemon-coverage-gap.ALERT.json");
+}
+function isoOrNull(ts) {
+  return ts !== null && Number.isFinite(ts) ? new Date(ts).toISOString() : null;
+}
+function writeCoverageGapAlert(a, ctx) {
+  try {
+    const hours = a.gapMs / (60 * 60 * 1e3);
+    const lastHeartbeatAt = isoOrNull(ctx.lastHeartbeatTs);
+    const hostRebootAt = a.rebootSpansGap ? isoOrNull(ctx.hostBootTs) : null;
+    const rebootClause = a.rebootSpansGap && hostRebootAt ? `, host rebooted ${hostRebootAt}` : ", no host reboot was detected";
+    const payload = {
+      detectedAt: new Date(ctx.nowMs).toISOString(),
+      gapMs: a.gapMs,
+      gapHours: Number(hours.toFixed(1)),
+      lastHeartbeatAt,
+      rebootSpansGap: a.rebootSpansGap,
+      reason: `Daemon was down ~${hours.toFixed(1)}h: last heartbeat ${lastHeartbeatAt ?? "unknown"}${rebootClause}, daemon only starts at GUI login (LaunchAgent) - this was a coverage gap, not a crash.`,
+      limitation: "Root cause: the daemon is a GUI LaunchAgent and does not run pre-login after reboot."
+    };
+    if (a.rebootSpansGap) payload.hostRebootAt = hostRebootAt;
+    const p = coverageGapAlertPath();
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync2(p, JSON.stringify(payload, null, 2), { mode: 384 });
+  } catch {
+  }
+}
+function clearCoverageGapAlert() {
+  try {
+    const p = coverageGapAlertPath();
+    if (existsSync2(p)) unlinkSync(p);
+  } catch {
+  }
+}
+function readCoverageGapAlert() {
+  try {
+    const p = coverageGapAlertPath();
+    if (!existsSync2(p)) return null;
+    return JSON.parse(readFileSync2(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function hostBootTimeMs(nowMs, uptimeSec) {
+  return nowMs - uptimeSec * 1e3;
+}
+function readTail(p, maxBytes = HEALTH_LOG_TAIL_BYTES) {
+  let fd = null;
+  try {
+    const st = statSync(p);
+    const size = Math.max(0, Math.floor(st.size));
+    const len = Math.min(size, maxBytes);
+    const start = Math.max(0, size - len);
+    const buf = Buffer.alloc(len);
+    fd = openSync(p, "r");
+    const bytesRead = readSync(fd, buf, 0, len, start);
+    return buf.subarray(0, bytesRead).toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+var PROOF_OF_LIFE_EVENTS = /* @__PURE__ */ new Set(["heartbeat", "boot"]);
+function lastHeartbeatFromHealthLog(p, excludePid) {
+  try {
+    const tail = readTail(p);
+    if (!tail) return null;
+    const lines = tail.split(/\r?\n/);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i]?.trim();
+      if (!line || !line.includes('"event"')) continue;
+      if (!line.includes('"heartbeat"') && !line.includes('"boot"')) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed.event !== "string" || !PROOF_OF_LIFE_EVENTS.has(parsed.event)) continue;
+        if (excludePid !== null && typeof parsed.pid === "number" && parsed.pid === excludePid) continue;
+        if (typeof parsed.ts !== "string") continue;
+        const ts = Date.parse(parsed.ts);
+        if (Number.isFinite(ts)) return ts;
+      } catch {
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function readLastHeartbeatTsMs(paths) {
+  try {
+    const signals = [];
+    const excludePid = paths?.excludePid === void 0 ? process.pid : paths.excludePid;
+    const logDir = join(homedir(), ".exe-os", "logs");
+    const mainLog = paths?.logPath ?? join(logDir, "daemon-health.log");
+    const rotatedLog = paths?.rotatedLogPath ?? join(logDir, "daemon-health.log.1");
+    const mainHeartbeat = lastHeartbeatFromHealthLog(mainLog, excludePid);
+    if (mainHeartbeat !== null) signals.push(mainHeartbeat);
+    else {
+      const rotatedHeartbeat = lastHeartbeatFromHealthLog(rotatedLog, excludePid);
+      if (rotatedHeartbeat !== null) signals.push(rotatedHeartbeat);
+    }
+    try {
+      const heartbeatPath = paths?.heartbeatFilePath ?? eventLoopHeartbeatPath();
+      if (existsSync2(heartbeatPath)) {
+        const mtimeMs = statSync(heartbeatPath).mtimeMs;
+        if (Number.isFinite(mtimeMs)) signals.push(mtimeMs);
+      }
+    } catch {
+    }
+    return signals.length ? Math.max(...signals) : null;
+  } catch {
+    return null;
+  }
+}
+function assessCoverageGap(ctx) {
+  const gapThresholdMs = ctx.gapThresholdMs ?? DEFAULT_COVERAGE_GAP_THRESHOLD_MS;
+  const lastHeartbeatTs = ctx.lastHeartbeatTs;
+  if (lastHeartbeatTs === null) {
+    return {
+      isCoverageGap: false,
+      gapMs: 0,
+      rebootSpansGap: false,
+      label: "no coverage-gap evidence"
+    };
+  }
+  const gapMs = ctx.nowMs - lastHeartbeatTs;
+  const rebootSpansGap = ctx.hostBootTs !== null && ctx.hostBootTs > lastHeartbeatTs;
+  const isCoverageGap = gapMs > gapThresholdMs;
+  const hours = (gapMs / (60 * 60 * 1e3)).toFixed(1);
+  const label = rebootSpansGap ? `coverage-gap (died ~${hours}h ago; host reboot at ${new Date(ctx.hostBootTs).toISOString()})` : `coverage-gap (died ~${hours}h ago; no reboot detected)`;
+  return { isCoverageGap, gapMs, rebootSpansGap, label };
+}
+
 // src/lib/daemon-self-heal-dispatch.ts
 function dispatchSelfHealRestart(lagMs, trigger, deps) {
   deps.writeBreadcrumb(lagMs, trigger);
@@ -391,7 +579,7 @@ function resolveSelfHealThresholds(env = process.env) {
 }
 
 // src/lib/daemon-restart-backoff.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, mkdirSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2 } from "fs";
 import { createHash } from "crypto";
 import path2 from "path";
 import os from "os";
@@ -437,8 +625,8 @@ function stateFile(workerKey) {
 function loadBackoffState(workerKey) {
   try {
     const f = stateFile(workerKey);
-    if (!existsSync2(f)) return null;
-    const parsed = JSON.parse(readFileSync2(f, "utf8"));
+    if (!existsSync3(f)) return null;
+    const parsed = JSON.parse(readFileSync3(f, "utf8"));
     if (typeof parsed.consecutiveFailures !== "number" || typeof parsed.lastFailureAt !== "number") {
       return null;
     }
@@ -453,15 +641,15 @@ function loadBackoffState(workerKey) {
 }
 function saveBackoffState(workerKey, state) {
   try {
-    if (!existsSync2(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
-    writeFileSync2(stateFile(workerKey), JSON.stringify(state), { mode: 384 });
+    if (!existsSync3(STATE_DIR)) mkdirSync2(STATE_DIR, { recursive: true });
+    writeFileSync3(stateFile(workerKey), JSON.stringify(state), { mode: 384 });
   } catch {
   }
 }
 function resetBackoffState(workerKey) {
   try {
     const f = stateFile(workerKey);
-    if (existsSync2(f)) unlinkSync(f);
+    if (existsSync3(f)) unlinkSync2(f);
   } catch {
   }
 }
@@ -525,6 +713,31 @@ function isHostCpuStarved(load1m, cpuCount, ratio) {
   const cores = Number.isFinite(cpuCount) && cpuCount > 0 ? cpuCount : 1;
   return load1m > cores * ratio;
 }
+function pruneLoadSamples(samples, keepSinceMs) {
+  return samples.filter((sample) => Number.isFinite(sample.ts) && sample.ts >= keepSinceMs);
+}
+function maxLoadOverWindow(samples, windowStartMs, currentLoad1m) {
+  const candidates = [currentLoad1m];
+  for (const sample of samples) {
+    if (sample.ts >= windowStartMs && Number.isFinite(sample.load1m)) {
+      candidates.push(sample.load1m);
+    }
+  }
+  const finite = candidates.filter((load) => Number.isFinite(load));
+  return finite.length > 0 ? Math.max(...finite) : currentLoad1m;
+}
+function updateLoadWindow(samples, nowMs, load1m, wallElapsedMs, keepMs) {
+  const blockStartMs = nowMs - wallElapsedMs - 2500;
+  const next = pruneLoadSamples(
+    [...samples, { ts: nowMs, load1m }],
+    Math.min(nowMs - keepMs, blockStartMs)
+  );
+  return {
+    samples: next,
+    maxLoad1mOverWindow: maxLoadOverWindow(next, blockStartMs, load1m),
+    blockStartMs
+  };
+}
 function decideDaemonSelfHeal(s) {
   const alive = s.processAlive ?? true;
   if (!alive) {
@@ -543,7 +756,11 @@ function decideDaemonSelfHeal(s) {
     selfInflictedSuppressedMsAfter: sumOf(prunedWindow)
   };
   const cleared = { selfInflictedWindowAfter: [], selfInflictedStreakAfter: 0, selfInflictedSuppressedMsAfter: 0 };
-  if (isHostCpuStarved(s.load1m, s.cpuCount, s.starvationRatio)) {
+  const loadCandidates = [s.load1m, s.maxLoad1mOverWindow].filter(
+    (load) => typeof load === "number" && Number.isFinite(load) && load > 0
+  );
+  const effectiveLoad1m = loadCandidates.length > 0 ? Math.max(...loadCandidates) : s.load1m;
+  if (isHostCpuStarved(effectiveLoad1m, s.cpuCount, s.starvationRatio)) {
     return { restart: false, reason: "starved_backoff", consecutiveSevereAfter: 0, ...carry };
   }
   if (s.catchUpActive) {
@@ -589,22 +806,68 @@ function decideBootBackoff(s) {
   if (!isHostCpuStarved(s.load1m, s.cpuCount, s.starvationRatio)) {
     return { wait: false, delayMs: 0, reason: "not_starved" };
   }
-  if (s.attempt >= s.maxAttempts) {
+  const clientsWaiting = s.clientsWaiting === true;
+  const baseDelayMs = clientsWaiting ? s.baseDelayMs / 2 : s.baseDelayMs;
+  const maxDelayMs = clientsWaiting ? s.maxDelayMs / 2 : s.maxDelayMs;
+  const maxAttempts = clientsWaiting ? Math.min(s.maxAttempts, 2) : s.maxAttempts;
+  if (s.attempt >= maxAttempts) {
     return { wait: false, delayMs: 0, reason: "max_attempts_proceed" };
   }
-  const base = Number.isFinite(s.baseDelayMs) && s.baseDelayMs > 0 ? s.baseDelayMs : 0;
-  const cap = Number.isFinite(s.maxDelayMs) && s.maxDelayMs > 0 ? s.maxDelayMs : base;
+  const base = Number.isFinite(baseDelayMs) && baseDelayMs > 0 ? baseDelayMs : 0;
+  const cap = Number.isFinite(maxDelayMs) && maxDelayMs > 0 ? maxDelayMs : base;
   const exp = base * Math.pow(2, Math.max(0, s.attempt));
   const delayMs = Math.min(cap, exp);
   return { wait: true, delayMs, reason: "backoff" };
 }
+function computeBootRetryAfterSeconds(nowMs, readyEtaMs, opts = {}) {
+  const defaultS = opts.defaultS ?? 3;
+  if (readyEtaMs === null) return defaultS;
+  const minS = opts.minS ?? 1;
+  const maxS = opts.maxS ?? 60;
+  return Math.min(maxS, Math.max(minS, Math.ceil((readyEtaMs - nowMs) / 1e3)));
+}
+
+// src/lib/bootstrap-response.ts
+function buildBootstrapResponse(input) {
+  const headers = { "Content-Type": "application/json" };
+  if (input.method === "GET" && input.path === "/health") {
+    return {
+      statusCode: 200,
+      headers,
+      body: JSON.stringify(input.failedReason === null ? { status: "starting", version: input.version } : { status: "failed", reason: input.failedReason, version: input.version, recovery: "exe-os setup" })
+    };
+  }
+  if (input.failedReason !== null) {
+    return {
+      statusCode: 503,
+      headers: { ...headers, "Retry-After": "300" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        error: {
+          code: -32002,
+          message: `Terminal DB init failure (${input.failedReason}) - MCP will not start. Recover: 'exe-os setup'.`
+        },
+        id: null
+      })
+    };
+  }
+  return {
+    statusCode: 503,
+    headers: { ...headers, "Retry-After": String(input.retryAfterSeconds) },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      error: { code: -32001, message: "Daemon initializing \u2014 MCP not ready yet. Retry in a few seconds." },
+      id: null
+    })
+  };
+}
 
 // src/lib/daemon-env.ts
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
-import { homedir } from "os";
-import { join } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
 function daemonEnvPath() {
-  return join(homedir(), ".exe-os", "daemon.env");
+  return join2(homedir2(), ".exe-os", "daemon.env");
 }
 function parseDaemonEnv(contents) {
   const out = {};
@@ -639,8 +902,8 @@ function applyDaemonEnv(parsed, env = process.env) {
 function loadDaemonEnv(path4 = daemonEnvPath()) {
   let contents;
   try {
-    if (!existsSync3(path4)) return 0;
-    contents = readFileSync3(path4, "utf8");
+    if (!existsSync4(path4)) return 0;
+    contents = readFileSync4(path4, "utf8");
   } catch {
     return 0;
   }
@@ -661,7 +924,7 @@ function stabilizeDaemonCwd() {
   } catch (err) {
     const moduleDir = path3.dirname(fileURLToPath(import.meta.url));
     const packageRoot = path3.resolve(moduleDir, "../..");
-    const fallback = existsSync4(path3.join(packageRoot, "package.json")) ? packageRoot : os2.homedir();
+    const fallback = existsSync5(path3.join(packageRoot, "package.json")) ? packageRoot : os2.homedir();
     try {
       process.chdir(fallback);
       process.stderr.write(
@@ -686,7 +949,7 @@ var REVIEW_POLL_INTERVAL_MS = 60 * 1e3;
 var DAEMON_TOKEN_ENV = "EXE_DAEMON_TOKEN";
 var PACKAGE_VERSION = (() => {
   try {
-    const pkg = JSON.parse(readFileSync4(new URL("../../package.json", import.meta.url), "utf8"));
+    const pkg = JSON.parse(readFileSync5(new URL("../../package.json", import.meta.url), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "unknown";
   } catch {
     return "unknown";
@@ -702,6 +965,7 @@ var _rerankPendingCallbacks = /* @__PURE__ */ new Map();
 var _shuttingDown = false;
 var _drainingWrites = false;
 var _mcpSessionDetailsRef = null;
+var _mcpSessionLastSeenRef = null;
 var _activeWrites = 0;
 var _mcpHttpReady = Promise.resolve();
 var _daemonToken = "";
@@ -1029,6 +1293,7 @@ function setBootPhase(phase) {
 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 TIMER_SLOW_WARN_MS = Number(process.env.EXE_TIMER_SLOW_WARN_MS) || 1e3;
 var _timerInFlight = /* @__PURE__ */ new Set();
 function shouldTraceDaemonTimer(durationMs = 0) {
   return Date.now() - _startedAt2 < TIMER_TRACE_BOOT_WINDOW_MS || durationMs >= TIMER_TRACE_SLOW_MS;
@@ -1082,12 +1347,17 @@ async function traceDaemonTimer(name, fn) {
   }
   _timerInFlight.add(name);
   const probe = captureClockProbe();
+  const pauseSnapshot = sweepPauseTotalMs();
   const traceStart = shouldTraceDaemonTimer();
   if (traceStart) {
     process.stderr.write(`[exed] Timer start: ${name}
 `);
   }
+  const watchdogStart = Date.now();
   const timeoutHandle = setTimeout(() => {
+    const pausedMs = sweepPauseTotalMs() - pauseSnapshot;
+    const busyMs = Date.now() - watchdogStart - pausedMs;
+    if (busyMs < TIMER_TIMEOUT_MS) return;
     _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
@@ -1109,8 +1379,31 @@ 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() };
+    const sweepPausedMs = Math.max(0, sweepPauseTotalMs() - pauseSnapshot);
+    const busyMs = Math.max(0, durationMs - sweepPausedMs);
+    if (!slept && busyMs >= TIMER_TIMEOUT_MS) {
+      _lastBlockingTimer = { name, durationMs: busyMs, ts: Date.now() };
+    }
+    if (shouldWarnSlowTimer(busyMs, slept, TIMER_SLOW_WARN_MS)) {
+      const msg = `[exed] Timer SLOW: ${name} busy ${busyMs}ms (wall ${durationMs}ms, sweep-paused ${sweepPausedMs}ms) \u2014 exceeded ${TIMER_SLOW_WARN_MS}ms per-tick budget (event loop was held)`;
+      process.stderr.write(`${msg}
+`);
+      logDaemonHealth({
+        event: "process_stats",
+        pid: process.pid,
+        message: msg,
+        data: {
+          type: "timer_slow",
+          timer: name,
+          durationMs,
+          busyMs,
+          sweepPausedMs,
+          thresholdMs: TIMER_SLOW_WARN_MS,
+          wallMs: Math.round(span.wallMs),
+          sleptMs: Math.round(span.sleptMs),
+          uptimeMs: Date.now() - _startedAt2
+        }
+      });
     }
     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)` : "";
@@ -1178,18 +1471,18 @@ function recordDaemonCrash() {
   const now = Date.now();
   let counter = { crashes: [] };
   try {
-    counter = JSON.parse(readFileSync4(CRASH_LOOP_COUNTER_PATH, "utf8"));
+    counter = JSON.parse(readFileSync5(CRASH_LOOP_COUNTER_PATH, "utf8"));
   } catch {
   }
   counter.crashes = counter.crashes.filter((t) => now - t < CRASH_LOOP_WINDOW_MS);
   counter.crashes.push(now);
   try {
-    writeFileSync3(CRASH_LOOP_COUNTER_PATH, JSON.stringify(counter), "utf8");
+    writeFileSync4(CRASH_LOOP_COUNTER_PATH, JSON.stringify(counter), "utf8");
   } catch {
   }
   if (counter.crashes.length >= CRASH_LOOP_THRESHOLD) {
     try {
-      writeFileSync3(CRASH_LOOP_BREAKER_PATH, JSON.stringify({
+      writeFileSync4(CRASH_LOOP_BREAKER_PATH, JSON.stringify({
         trippedAt: (/* @__PURE__ */ new Date()).toISOString(),
         crashCount: counter.crashes.length,
         windowMs: CRASH_LOOP_WINDOW_MS
@@ -1206,10 +1499,10 @@ function recordDaemonCrash() {
 }
 function isCrashLoopBreakerActive() {
   try {
-    if (!existsSync4(CRASH_LOOP_BREAKER_PATH)) return false;
-    const ageMs = Date.now() - statSync(CRASH_LOOP_BREAKER_PATH).mtimeMs;
+    if (!existsSync5(CRASH_LOOP_BREAKER_PATH)) return false;
+    const ageMs = Date.now() - statSync2(CRASH_LOOP_BREAKER_PATH).mtimeMs;
     if (ageMs > CRASH_LOOP_BREAKER_TTL_MS) {
-      unlinkSync2(CRASH_LOOP_BREAKER_PATH);
+      unlinkSync3(CRASH_LOOP_BREAKER_PATH);
       process.stderr.write(`[exed] Crash-loop breaker expired after ${Math.round(ageMs / 6e4)}min \u2014 cleared.
 `);
       return false;
@@ -1221,7 +1514,7 @@ function isCrashLoopBreakerActive() {
 }
 function resetCrashCounterOnHealthy() {
   try {
-    unlinkSync2(CRASH_LOOP_COUNTER_PATH);
+    unlinkSync3(CRASH_LOOP_COUNTER_PATH);
   } catch {
   }
 }
@@ -1247,10 +1540,10 @@ function currentEmbedConfigFingerprint() {
 }
 function clearStaleOomMarker() {
   try {
-    if (!existsSync4(OOM_MARKER_PATH)) return false;
-    const ageMs = Date.now() - statSync(OOM_MARKER_PATH).mtimeMs;
+    if (!existsSync5(OOM_MARKER_PATH)) return false;
+    const ageMs = Date.now() - statSync2(OOM_MARKER_PATH).mtimeMs;
     if (ageMs < OOM_MARKER_TTL_MS) return false;
-    unlinkSync2(OOM_MARKER_PATH);
+    unlinkSync3(OOM_MARKER_PATH);
     process.stderr.write(`[exed] Cleared stale embedding OOM marker after ${Math.round(ageMs / 36e5)}h.
 `);
     return true;
@@ -1264,7 +1557,7 @@ function eventLoopBlockedMarkerPath() {
 }
 function isEventLoopBlockedNow(freshMs = EVENT_LOOP_BLOCKED_FRESH_MS) {
   try {
-    const ageMs = Date.now() - statSync(eventLoopBlockedMarkerPath()).mtimeMs;
+    const ageMs = Date.now() - statSync2(eventLoopBlockedMarkerPath()).mtimeMs;
     return ageMs < freshMs && ageMs > -freshMs;
   } catch {
     return false;
@@ -1273,8 +1566,8 @@ function isEventLoopBlockedNow(freshMs = EVENT_LOOP_BLOCKED_FRESH_MS) {
 function touchEventLoopHeartbeat() {
   try {
     const p = eventLoopHeartbeatPath();
-    mkdirSync2(path3.dirname(p), { recursive: true });
-    writeFileSync3(p, String(Date.now()));
+    mkdirSync3(path3.dirname(p), { recursive: true });
+    writeFileSync4(p, String(Date.now()));
   } catch {
   }
 }
@@ -1282,8 +1575,8 @@ function checkLaunchdPlistHealth() {
   try {
     if (process.platform !== "darwin") return;
     const plistPath = path3.join(os2.homedir(), "Library", "LaunchAgents", "com.askexe.exed.plist");
-    if (!existsSync4(plistPath)) return;
-    const plist = readFileSync4(plistPath, "utf8");
+    if (!existsSync5(plistPath)) return;
+    const plist = readFileSync5(plistPath, "utf8");
     const expectedHeap = computeDaemonHeapCapMb();
     const heapMatch = plist.match(/--max-old-space-size=(\d+)/);
     const heap = heapMatch?.[1] ? parseInt(heapMatch[1], 10) : null;
@@ -1354,7 +1647,7 @@ async function loadModel() {
   } catch {
   }
   const modelPath = path3.join(MODELS_DIR, MODEL_FILE);
-  if (!existsSync4(modelPath)) {
+  if (!existsSync5(modelPath)) {
     process.stderr.write(`[exed] No model at ${modelPath} \u2014 running without embeddings (VPS mode).
 `);
     _embeddingsDisabledByDesign = true;
@@ -1365,19 +1658,19 @@ async function loadModel() {
     process.stderr.write(`[exed] Embedding config changed \u2014 cleared stale embed-worker backoff (one prompt retry under new config).
 `);
     try {
-      if (existsSync4(EMBED_TIMEOUT_MARKER_PATH)) unlinkSync2(EMBED_TIMEOUT_MARKER_PATH);
+      if (existsSync5(EMBED_TIMEOUT_MARKER_PATH)) unlinkSync3(EMBED_TIMEOUT_MARKER_PATH);
     } catch {
     }
     _embedConsecutiveTimeouts = 0;
   }
   clearStaleOomMarker();
-  if (existsSync4(OOM_MARKER_PATH)) {
+  if (existsSync5(OOM_MARKER_PATH)) {
     process.stderr.write(`[exed] Skipping embeddings \u2014 OOM marker exists. Delete ${OOM_MARKER_PATH} to retry.
 `);
     _embeddingsDisabledByDesign = true;
     return;
   }
-  if (existsSync4(EMBED_TIMEOUT_MARKER_PATH)) {
+  if (existsSync5(EMBED_TIMEOUT_MARKER_PATH)) {
     process.stderr.write(`[exed] Skipping embeddings \u2014 inference-timeout marker exists (local embeddings non-functional on this host). Set EXE_EMBEDDINGS=0 or delete ${EMBED_TIMEOUT_MARKER_PATH} to retry.
 `);
     _embeddingsDisabledByDesign = true;
@@ -1432,7 +1725,7 @@ async function loadModel() {
   process.stderr.write("[exed] Spawning embed worker process...\n");
   try {
     const workerPath = path3.join(path3.dirname(new URL(import.meta.url).pathname), "embed-worker.js");
-    if (!existsSync4(workerPath)) {
+    if (!existsSync5(workerPath)) {
       process.stderr.write(`[exed] Embed worker not found at ${workerPath} \u2014 running without embeddings.
 `);
       return;
@@ -1518,8 +1811,8 @@ async function loadModel() {
       const oomShaped = code === 134 || signal === "SIGKILL" || signal === "SIGABRT";
       if (oomShaped) {
         try {
-          mkdirSync2(path3.dirname(OOM_MARKER_PATH), { recursive: true });
-          writeFileSync3(OOM_MARKER_PATH, `embed-worker OOM exit (code=${code}, signal=${signal ?? "none"}) at ${(/* @__PURE__ */ new Date()).toISOString()}
+          mkdirSync3(path3.dirname(OOM_MARKER_PATH), { recursive: true });
+          writeFileSync4(OOM_MARKER_PATH, `embed-worker OOM exit (code=${code}, signal=${signal ?? "none"}) at ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
           process.stderr.write(`[exed] Embed worker OOM-shaped exit \u2014 wrote OOM marker; respawns will skip model load until it TTL-clears.
 `);
@@ -1539,7 +1832,7 @@ async function loadModel() {
         void (async () => {
           try {
             if (_storeInitialized) {
-              const { writeNotification } = await import("../notifications-4UT53CDG.js");
+              const { writeNotification } = await import("../notifications-6XCSUTJW.js");
               await writeNotification({
                 agentId: "exe",
                 agentRole: "system",
@@ -1620,8 +1913,8 @@ function disableEmbeddingsForInferenceTimeouts() {
   if (_embeddingsDisabledByDesign) return;
   _embeddingsDisabledByDesign = true;
   try {
-    mkdirSync2(path3.dirname(EMBED_TIMEOUT_MARKER_PATH), { recursive: true });
-    writeFileSync3(
+    mkdirSync3(path3.dirname(EMBED_TIMEOUT_MARKER_PATH), { recursive: true });
+    writeFileSync4(
       EMBED_TIMEOUT_MARKER_PATH,
       `embed inference timed out ${_embedConsecutiveTimeouts}x consecutively at ${(/* @__PURE__ */ new Date()).toISOString()}
 `
@@ -1655,7 +1948,7 @@ function disableEmbeddingsForInferenceTimeouts() {
   void (async () => {
     try {
       if (_storeInitialized) {
-        const { writeNotification } = await import("../notifications-4UT53CDG.js");
+        const { writeNotification } = await import("../notifications-6XCSUTJW.js");
         await writeNotification({
           agentId: "exe",
           agentRole: "system",
@@ -1843,11 +2136,11 @@ async function shutdown(exitCode = 0, reason = null) {
 `
     );
     try {
-      unlinkSync2(SOCKET_PATH);
+      unlinkSync3(SOCKET_PATH);
     } catch {
     }
     try {
-      unlinkSync2(PID_PATH);
+      unlinkSync3(PID_PATH);
     } catch {
     }
     process.kill(process.pid, "SIGKILL");
@@ -1875,7 +2168,7 @@ async function shutdown(exitCode = 0, reason = null) {
       preRestartDedupWindowMs,
       findActiveDb,
       shouldSkipBackupUnderMemoryPressure
-    } = await import("../db-backup-W2QFSYQC.js");
+    } = await import("./db-backup.js");
     const PRE_RESTART_DEDUP_MS = preRestartDedupWindowMs();
     const PRE_RESTART_STORM_CAP = (() => {
       const v = Number(process.env.EXE_PRE_RESTART_STORM_CAP);
@@ -1898,10 +2191,10 @@ async function shutdown(exitCode = 0, reason = null) {
       const dbPath = findActiveDb();
       let dbBytes = 0;
       try {
-        dbBytes = dbPath ? statSync(dbPath).size : 0;
+        dbBytes = dbPath ? statSync2(dbPath).size : 0;
       } catch {
       }
-      const { getAvailableMemoryBytesSync } = await import("../memory-pressure-watchdog-HN5X7AVN.js");
+      const { getAvailableMemoryBytesSync } = await import("../memory-pressure-watchdog-PSVJ5BCF.js");
       const freeBytes = getAvailableMemoryBytesSync();
       if (shouldSkipBackupUnderMemoryPressure(freeBytes, dbBytes)) {
         memoryGateSkip = true;
@@ -1932,6 +2225,7 @@ async function shutdown(exitCode = 0, reason = null) {
     process.stderr.write(`[exed] Pre-restart backup failed (non-fatal): ${e instanceof Error ? e.message : String(e)}
 `);
   }
+  const restartHandoff = shouldScheduleDaemonRestartHandoff(exitCode, reason);
   try {
     const { getClient } = await import("./database.js");
     const client = getClient();
@@ -1945,12 +2239,20 @@ async function shutdown(exitCode = 0, reason = null) {
 `);
   }
   try {
-    const { stopProjectionWorker } = await import("../projection-worker-FZ7YSN3G.js");
+    const { disposeDatabase } = await import("./database.js");
+    await disposeDatabase();
+    process.stderr.write("[exed] Database disposed before restart handoff.\n");
+  } catch (e) {
+    process.stderr.write(`[exed] Database dispose failed during shutdown: ${e instanceof Error ? e.message : String(e)}
+`);
+  }
+  try {
+    const { stopProjectionWorker } = await import("../projection-worker-CKC2E22U.js");
     stopProjectionWorker();
   } catch {
   }
   try {
-    const { disposeShards } = await import("../shard-manager-35PWFR3B.js");
+    const { disposeShards } = await import("../shard-manager-OETALPDW.js");
     disposeShards();
   } catch {
   }
@@ -1968,18 +2270,15 @@ async function shutdown(exitCode = 0, reason = null) {
   } catch {
   }
   try {
-    const sessionsToSave = _mcpSessionDetailsRef ? Array.from(_mcpSessionDetailsRef.entries()).map(([sid, d]) => ({
-      sessionId: sid,
-      agentId: d.agentId,
-      agentRole: d.agentRole,
-      runtime: d.runtime,
-      sessionHint: d.sessionHint,
-      savedAt: Date.now()
-    })) : [];
-    if (sessionsToSave.length > 0) {
-      const sessPath = path3.join(EXE_AI_DIR, "mcp-sessions-persist.json");
-      writeFileSync3(sessPath, JSON.stringify(sessionsToSave) + "\n", { mode: 384 });
-      process.stderr.write(`[exed] Persisted ${sessionsToSave.length} MCP session(s) for next daemon.
+    disposeDbWriteWorker();
+  } catch {
+  }
+  try {
+    const { persistMcpSessions, buildPersistedSessions } = await import("../mcp-session-persist-PS7BIG44.js");
+    const sessionsToSave = _mcpSessionDetailsRef ? buildPersistedSessions(_mcpSessionDetailsRef.entries(), _mcpSessionLastSeenRef ?? /* @__PURE__ */ new Map(), Date.now()) : [];
+    const persisted = persistMcpSessions(sessionsToSave, EXE_AI_DIR);
+    if (persisted > 0) {
+      process.stderr.write(`[exed] Persisted ${persisted} MCP session(s) for next daemon.
 `);
     }
   } catch (e) {
@@ -1987,17 +2286,50 @@ async function shutdown(exitCode = 0, reason = null) {
 `);
   }
   try {
-    unlinkSync2(SOCKET_PATH);
+    unlinkSync3(SOCKET_PATH);
   } catch (e) {
     process.stderr.write(`[exed] socket cleanup: ${e.message}
 `);
   }
   try {
-    unlinkSync2(PID_PATH);
+    unlinkSync3(PID_PATH);
   } catch (e) {
     process.stderr.write(`[exed] pid cleanup: ${e.message}
 `);
   }
+  if (restartHandoff) {
+    try {
+      const moduleDir = path3.dirname(fileURLToPath(import.meta.url));
+      const helperPath = path3.resolve(moduleDir, "../bin/daemon-restart-handoff.js");
+      const daemonPath = fileURLToPath(import.meta.url);
+      const logPath = path3.join(EXE_AI_DIR, "logs", "exed.log");
+      const lockPath = path3.join(EXE_AI_DIR, "exed-spawn.lock");
+      const heapCapMb = computeDaemonHeapCapMb(os2.totalmem() / (1024 * 1024 * 1024));
+      const config = {
+        oldPid: process.pid,
+        daemonPath,
+        pidPath: PID_PATH,
+        socketPath: SOCKET_PATH,
+        lockPath,
+        logPath,
+        heapCapMb
+      };
+      const child = spawn(process.execPath, [helperPath], {
+        detached: true,
+        stdio: "ignore",
+        env: {
+          ...process.env,
+          EXE_DAEMON_HANDOFF_CONFIG: JSON.stringify(config)
+        }
+      });
+      child.unref();
+      process.stderr.write(`[exed] Restart handoff helper scheduled (pid ${child.pid ?? "unknown"}).
+`);
+    } catch (e) {
+      process.stderr.write(`[exed] Restart handoff helper schedule failed: ${e instanceof Error ? e.message : String(e)}
+`);
+    }
+  }
   process.stderr.write(`[exed] Shutdown complete (exit ${exitCode}${exitCode === 0 ? "" : " \u2014 restart-intent, launchd will relaunch"}).
 `);
   process.exit(exitCode);
@@ -2011,7 +2343,7 @@ async function handleHealthCheck(socket, requestId) {
   let pipelineStatus = "unknown";
   if (dbConnected) {
     try {
-      await import("../pipeline-router-LM53NMWJ.js");
+      await import("../pipeline-router-N2LDNFJ5.js");
       pipelineStatus = "ok";
     } catch {
       pipelineStatus = "unavailable";
@@ -2196,11 +2528,11 @@ var _ingestCount = 0;
 var INGEST_OUTBOX_DIR = path3.join(EXE_AI_DIR, "ingest-outbox");
 function persistIngestOutbox(req) {
   try {
-    mkdirSync2(INGEST_OUTBOX_DIR, { recursive: true });
+    mkdirSync3(INGEST_OUTBOX_DIR, { recursive: true });
     const id = randomUUID();
     const finalPath = path3.join(INGEST_OUTBOX_DIR, `${Date.now()}-${id}.json`);
     const tmpPath = `${finalPath}.tmp`;
-    writeFileSync3(tmpPath, JSON.stringify(req) + "\n", { mode: 384 });
+    writeFileSync4(tmpPath, JSON.stringify(req) + "\n", { mode: 384 });
     renameSync(tmpPath, finalPath);
     return finalPath;
   } catch (err) {
@@ -2211,12 +2543,12 @@ function persistIngestOutbox(req) {
 }
 async function drainIngestOutbox() {
   try {
-    if (!existsSync4(INGEST_OUTBOX_DIR)) return;
+    if (!existsSync5(INGEST_OUTBOX_DIR)) return;
     const files = readdirSync(INGEST_OUTBOX_DIR).filter((f) => f.endsWith(".json")).sort().slice(0, 500);
     for (const file of files) {
       const fullPath = path3.join(INGEST_OUTBOX_DIR, file);
       try {
-        const req = JSON.parse(readFileSync4(fullPath, "utf8"));
+        const req = JSON.parse(readFileSync5(fullPath, "utf8"));
         await handleIngest(req, fullPath);
       } catch (err) {
         process.stderr.write(`[exed] Ingest outbox drain failed for ${file}: ${err instanceof Error ? err.message : String(err)}
@@ -2235,7 +2567,7 @@ async function handleIngest(req, outboxPath) {
     if (!req.rawText || req.rawText.length < 50) {
       if (persistedPath) {
         try {
-          unlinkSync2(persistedPath);
+          unlinkSync3(persistedPath);
         } catch {
         }
       }
@@ -2258,7 +2590,7 @@ async function handleIngest(req, outboxPath) {
     _ingestCount++;
     if (persistedPath) {
       try {
-        unlinkSync2(persistedPath);
+        unlinkSync3(persistedPath);
       } catch {
       }
     }
@@ -2306,16 +2638,16 @@ async function handleBatchWriteMemory(socket, requestId, entries) {
     });
   }
 }
-async function writeMemoryRecord(entry) {
+async function writeMemoryRecord(entry, opts = {}) {
   if (_drainingWrites) throw new Error("Server shutting down \u2014 writes paused");
   _activeWrites++;
   try {
-    return await _writeMemoryRecordInner(entry);
+    return await _writeMemoryRecordInner(entry, opts.syncOnly === true);
   } finally {
     _activeWrites--;
   }
 }
-async function _writeMemoryRecordInner(entry) {
+async function _writeMemoryRecordInner(entry, syncOnly = false) {
   const id = randomUUID();
   const now = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
   const governed = governMemoryRecord({
@@ -2337,15 +2669,8 @@ async function _writeMemoryRecordInner(entry) {
   });
   if (governed.shouldDrop) return id;
   const record = governed.record;
-  const duplicate = await findScopedDuplicate({
-    contentHash: governed.contentHash,
-    agentId: record.agent_id,
-    projectName: record.project_name,
-    memoryType: record.memory_type ?? "raw"
-  });
-  if (duplicate) return duplicate;
   let vectorBlob = null;
-  if (_embedWorkerReady && !governed.skipEmbedding) {
+  if (!syncOnly && _embedWorkerReady && !governed.skipEmbedding) {
     try {
       const vectors = await embedTexts([record.raw_text]);
       if (vectors.length > 0 && vectors[0].length === EMBEDDING_DIM) {
@@ -2357,11 +2682,33 @@ async function _writeMemoryRecordInner(entry) {
 `);
     }
   }
-  const { getClient } = await import("./database.js");
-  const client = getClient();
   const hasVector = vectorBlob !== null;
   const embeddingModel = hasVector ? activeEmbeddingModelName() : null;
-  await client.execute({
+  if (!syncOnly && isWriteWorkerEnabled() && isDbWriteWorkerReady()) {
+    try {
+      const result = await writeMemoryInWorker({
+        record,
+        contentHash: governed.contentHash,
+        vectorBlob,
+        embeddingModel,
+        trajectory: entry.trajectory ?? null
+      });
+      return result.memoryId;
+    } catch (e) {
+      process.stderr.write(`[exed] write worker failed (${e instanceof Error ? e.message : String(e)}) - falling back to main-thread write
+`);
+    }
+  }
+  const duplicate = await findScopedDuplicate({
+    contentHash: governed.contentHash,
+    agentId: record.agent_id,
+    projectName: record.project_name,
+    memoryType: record.memory_type ?? "raw"
+  });
+  if (duplicate) return duplicate;
+  const { getClient } = await import("./database.js");
+  const client = getClient();
+  const insertResult = await client.execute({
     sql: hasVector ? `INSERT OR IGNORE INTO memories
            (id, agent_id, agent_role, session_id, timestamp, tool_name, project_name,
             has_error, raw_text, vector, version, task_id, importance, status,
@@ -2416,10 +2763,19 @@ async function _writeMemoryRecordInner(entry) {
       embeddingModel
     ]
   });
+  if (Number(insertResult.rowsAffected) === 0) {
+    const winner = await findScopedDuplicate({
+      contentHash: governed.contentHash,
+      agentId: record.agent_id,
+      projectName: record.project_name,
+      memoryType: record.memory_type ?? "raw"
+    });
+    return winner ?? id;
+  }
   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-3FXYMHKW.js");
+    const { insertOntologyForMemory } = await import("../agentic-ontology-SCG6UUHK.js");
     await insertOntologyForMemory({
       id,
       agent_id: record.agent_id,
@@ -2443,20 +2799,33 @@ async function _writeMemoryRecordInner(entry) {
 }
 var MEMORY_DRAIN_INTERVAL_MS = 30 * 1e3;
 var MEMORY_DRAIN_BATCH = Math.max(1, Number(process.env.EXE_MEMORY_DRAIN_BATCH) || 1);
+var MEMORY_DRAIN_TX_BATCH = Math.max(1, Number(process.env.EXE_MEMORY_DRAIN_TX_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, processQueueEntries } = await import("../memory-queue-2UOOF27L.js");
+      const { ackQueue, claimQueue, retryQueueEntries, processQueueEntries } = await import("../memory-queue-ZI7DX44D.js");
       const lease = claimQueue();
       if (!lease || lease.entries.length === 0) return;
       acted("memory_queue_drain");
       const entries = lease.entries;
-      const result = await processQueueEntries(entries, (entry) => writeMemoryRecord(entry), {
+      const useTxBatch = !_embedWorkerReady && !(isWriteWorkerEnabled() && isDbWriteWorkerReady());
+      const txClient = useTxBatch ? (await import("./database.js")).getClient() : null;
+      const drainSyncOnly = useTxBatch;
+      const result = await processQueueEntries(entries, (entry) => writeMemoryRecord(entry, { syncOnly: drainSyncOnly }), {
         isDraining: () => _drainingWrites,
-        batchSize: MEMORY_DRAIN_BATCH,
+        batchSize: useTxBatch ? MEMORY_DRAIN_TX_BATCH : MEMORY_DRAIN_BATCH,
         yieldFn: yieldToEventLoop,
+        beginBatch: txClient ? async () => {
+          await txClient.execute("BEGIN IMMEDIATE");
+        } : void 0,
+        commitBatch: txClient ? async () => {
+          await txClient.execute("COMMIT");
+        } : void 0,
+        rollbackBatch: txClient ? async () => {
+          await txClient.execute("ROLLBACK");
+        } : void 0,
         onWriteError: (_entry, err) => {
           process.stderr.write(
             `[exed] Queue drain write error: ${err instanceof Error ? err.message : String(err)}
@@ -2484,7 +2853,24 @@ function startMemoryQueueDrain() {
       );
     }
   });
-  void drain();
+  void (async () => {
+    const holdStartedAt = Date.now();
+    const HOLD_CAP_MS = Number(process.env.EXE_STARTUP_DRAIN_GRACE_CAP_MS) || 30 * 60 * 1e3;
+    const hold = setInterval(() => {
+      if (Date.now() - holdStartedAt >= HOLD_CAP_MS) {
+        clearInterval(hold);
+        return;
+      }
+      extendBootCatchUp(6e4);
+    }, 3e4);
+    hold.unref();
+    extendBootCatchUp(6e4);
+    try {
+      await drain();
+    } finally {
+      clearInterval(hold);
+    }
+  })();
   const timer = setInterval(() => void drain(), MEMORY_DRAIN_INTERVAL_MS);
   timer.unref();
   process.stderr.write(`[exed] Memory queue drain started (every ${MEMORY_DRAIN_INTERVAL_MS / 1e3}s)
@@ -2494,19 +2880,19 @@ var MESSAGE_DRAIN_INTERVAL_MS = 3e4;
 function retryMessageQueueEntries(leasePath, entries) {
   if (entries.length === 0) {
     try {
-      unlinkSync2(leasePath);
+      unlinkSync3(leasePath);
     } catch {
     }
     return;
   }
-  writeFileSync3(leasePath, entries.map((entry) => JSON.stringify(entry)).join("\n") + "\n");
+  writeFileSync4(leasePath, entries.map((entry) => JSON.stringify(entry)).join("\n") + "\n");
 }
 function startMessageQueueDrain() {
   const drain = async () => traceDaemonTimer("message_queue_drain", async () => {
     fired("message_queue_drain");
     if (!await ensureStoreForPolling()) return;
     try {
-      const { claimMessageQueue, ackMessageQueue } = await import("../message-queue-client-4EOQRUXW.js");
+      const { claimMessageQueue, ackMessageQueue } = await import("../message-queue-client-WMIO5FL5.js");
       const lease = claimMessageQueue();
       if (!lease || lease.entries.length === 0) return;
       acted("message_queue_drain");
@@ -2610,7 +2996,7 @@ async function retryPendingMessages() {
   }
 }
 function startServer() {
-  mkdirSync2(path3.dirname(SOCKET_PATH), { recursive: true });
+  mkdirSync3(path3.dirname(SOCKET_PATH), { recursive: true });
   try {
     chmodSync(path3.dirname(SOCKET_PATH), 448);
   } catch {
@@ -2620,18 +3006,18 @@ function startServer() {
     const oldPath = path3.join(path3.dirname(SOCKET_PATH), oldFile);
     try {
       if (oldFile.endsWith(".pid")) {
-        const pid = parseInt(readFileSync4(oldPath, "utf8").trim(), 10);
+        const pid = parseInt(readFileSync5(oldPath, "utf8").trim(), 10);
         if (pid > 0) try {
           process.kill(pid, "SIGKILL");
         } catch {
         }
       }
-      unlinkSync2(oldPath);
+      unlinkSync3(oldPath);
     } catch {
     }
   }
   try {
-    unlinkSync2(SOCKET_PATH);
+    unlinkSync3(SOCKET_PATH);
   } catch {
   }
   const server = net.createServer((socket) => {
@@ -2845,6 +3231,8 @@ async function resolveAndClaimPort() {
 async function startMcpHttpServer() {
   process.stderr.write("[exed] MCP HTTP: starting setup...\n");
   let _bootstrapServerRef = null;
+  let _bootstrapFailedReason = null;
+  let _bootReadyEtaMs = null;
   try {
     let parseDurationMs2 = function(value, fallback, options = {}) {
       if (!value) return fallback;
@@ -3020,6 +3408,18 @@ async function startMcpHttpServer() {
         }
         global.gc?.();
       }
+      try {
+        void import("../mcp-session-persist-PS7BIG44.js").then(({ persistMcpSessions, buildPersistedSessions }) => {
+          const sessionsToSave = buildPersistedSessions(sessionDetails.entries(), sessionLastSeen, Date.now());
+          persistMcpSessions(sessionsToSave, EXE_AI_DIR);
+        }).catch((e) => {
+          process.stderr.write(`[exed] Session persist failed (non-fatal): ${e instanceof Error ? e.message : String(e)}
+`);
+        });
+      } catch (e) {
+        process.stderr.write(`[exed] Session persist failed (non-fatal): ${e instanceof Error ? e.message : String(e)}
+`);
+      }
     }, getJsonRpcId2 = function(body) {
       if (body && typeof body === "object" && !Array.isArray(body) && "id" in body) {
         const id = body.id;
@@ -3055,21 +3455,21 @@ async function startMcpHttpServer() {
     const _earlyAllowRemote = /^(1|true|yes|on)$/i.test(process.env.EXE_MCP_ALLOW_REMOTE ?? "");
     const RESOLVED_MCP_HOST = _earlyIsRemoteHost && !_earlyAllowRemote ? "127.0.0.1" : _earlyRequestedHost;
     const RESOLVED_MCP_PORT = await resolveAndClaimPort();
+    const DB_INIT_ETA_MS = 2e4;
     _bootstrapServerRef = createHttpServer((req, res) => {
       try {
         res.setHeader("Access-Control-Allow-Origin", "http://127.0.0.1");
-        const path4 = (req.url || "/").split("?")[0];
-        if (req.method === "GET" && path4 === "/health") {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ status: "starting", version: PACKAGE_VERSION }));
-          return;
-        }
-        res.writeHead(503, { "Content-Type": "application/json", "Retry-After": "3" });
-        res.end(JSON.stringify({
-          jsonrpc: "2.0",
-          error: { code: -32001, message: "Daemon initializing \u2014 MCP not ready yet. Retry in a few seconds." },
-          id: null
-        }));
+        const path4 = (req.url || "/").split("?")[0] ?? "/";
+        const retryAfterSeconds = computeBootRetryAfterSeconds(Date.now(), _bootReadyEtaMs);
+        const response = buildBootstrapResponse({
+          failedReason: _bootstrapFailedReason,
+          method: req.method ?? "",
+          path: path4,
+          retryAfterSeconds,
+          version: PACKAGE_VERSION
+        });
+        res.writeHead(response.statusCode, response.headers);
+        res.end(response.body);
       } catch {
       }
     });
@@ -3096,33 +3496,62 @@ async function startMcpHttpServer() {
       const BOOT_BACKOFF_MAX_MS = parseInt(process.env.EXE_BOOT_BACKOFF_MAX_MS ?? "") || 15e3;
       const BOOT_BACKOFF_MAX_ATTEMPTS = parseInt(process.env.EXE_BOOT_BACKOFF_MAX_ATTEMPTS ?? "") || 5;
       const starvationRatio = parseFloat(process.env.EXE_STARVATION_LOAD_RATIO ?? "1.5");
+      let clientsWaiting = false;
+      try {
+        const sessPath = path3.join(EXE_AI_DIR, "mcp-sessions-persist.json");
+        if (existsSync5(sessPath)) {
+          const saved = JSON.parse(readFileSync5(sessPath, "utf-8"));
+          const { hasRecentWaitingClients, mcpSessionRestoreMaxAgeMs } = await import("../mcp-session-persist-PS7BIG44.js");
+          clientsWaiting = hasRecentWaitingClients(saved, Date.now(), mcpSessionRestoreMaxAgeMs());
+        }
+      } catch {
+        clientsWaiting = false;
+      }
+      let loggedClientsWaitingBackoff = false;
       for (let attempt = 0; ; attempt++) {
+        const load1m = os2.loadavg()[0] ?? 0;
+        const cpuCount = os2.cpus().length || 1;
         const decision = decideBootBackoff({
-          load1m: os2.loadavg()[0] ?? 0,
-          cpuCount: os2.cpus().length || 1,
+          load1m,
+          cpuCount,
           starvationRatio,
           attempt,
           baseDelayMs: BOOT_BACKOFF_BASE_MS,
           maxDelayMs: BOOT_BACKOFF_MAX_MS,
-          maxAttempts: BOOT_BACKOFF_MAX_ATTEMPTS
+          maxAttempts: BOOT_BACKOFF_MAX_ATTEMPTS,
+          clientsWaiting
         });
+        if (clientsWaiting && !loggedClientsWaitingBackoff) {
+          const normalDecision = decideBootBackoff({
+            load1m,
+            cpuCount,
+            starvationRatio,
+            attempt,
+            baseDelayMs: BOOT_BACKOFF_BASE_MS,
+            maxDelayMs: BOOT_BACKOFF_MAX_MS,
+            maxAttempts: BOOT_BACKOFF_MAX_ATTEMPTS
+          });
+          if (normalDecision.wait !== decision.wait || normalDecision.delayMs !== decision.delayMs || normalDecision.reason !== decision.reason) {
+            process.stderr.write("[exed] Boot backoff: shortened because persisted MCP clients are waiting.\n");
+            loggedClientsWaitingBackoff = true;
+          }
+        }
         if (!decision.wait) {
+          _bootReadyEtaMs = Date.now() + DB_INIT_ETA_MS;
           if (decision.reason === "max_attempts_proceed") {
             process.stderr.write(
-              `[exed] Boot backoff: still starved after ${BOOT_BACKOFF_MAX_ATTEMPTS} attempts \u2014 proceeding with DB init anyway.
+              `[exed] Boot backoff: still starved after ${attempt} attempts \u2014 proceeding with DB init anyway.
 `
             );
             logDaemonHealth({
               event: "boot_backoff_starvation",
               pid: process.pid,
-              message: `boot backoff exhausted (${BOOT_BACKOFF_MAX_ATTEMPTS} attempts) \u2014 proceeding`,
-              data: { load1m: os2.loadavg()[0] ?? 0, cpuCount: os2.cpus().length || 1, attempts: attempt }
+              message: `boot backoff exhausted (${attempt} attempts) \u2014 proceeding`,
+              data: { load1m, cpuCount, attempts: attempt }
             });
           }
           break;
         }
-        const load1m = os2.loadavg()[0] ?? 0;
-        const cpuCount = os2.cpus().length || 1;
         process.stderr.write(
           `[exed] Boot backoff: CPU starved (load=${load1m.toFixed(2)} cpus=${cpuCount}) \u2014 delaying DB init ${Math.round(decision.delayMs / 1e3)}s (attempt ${attempt + 1}/${BOOT_BACKOFF_MAX_ATTEMPTS}).
 `
@@ -3133,6 +3562,7 @@ async function startMcpHttpServer() {
           message: `boot delayed ${Math.round(decision.delayMs / 1e3)}s before DB init \u2014 CPU starved (load=${load1m.toFixed(2)} / cpus=${cpuCount})`,
           data: { load1m, cpuCount, loadPerCore: load1m / cpuCount, delayMs: decision.delayMs, attempt }
         });
+        _bootReadyEtaMs = Date.now() + decision.delayMs + DB_INIT_ETA_MS;
         await new Promise((resolve) => setTimeout(resolve, decision.delayMs));
       }
     }
@@ -3143,16 +3573,17 @@ async function startMcpHttpServer() {
         "[exed] MCP HTTP: DB init failed \u2014 MCP HTTP endpoint will NOT start. Run 'exe-os setup' to fix keychain/encryption.\n"
       );
       if (_bootstrapServerRef) {
-        const srv = _bootstrapServerRef;
-        _bootstrapServerRef = null;
-        srv.close();
+        _bootstrapFailedReason = "db_init";
+        process.stderr.write(
+          "[exed] MCP HTTP: failed-health responder remains alive on the port so tooling can distinguish terminal DB init failure from startup.\n"
+        );
       }
       return;
     }
     process.stderr.write("[exed] MCP HTTP: DB ready\n");
     setBootPhase("db_ready");
     _storeInitialized = true;
-    const { initLicenseGate, getCachedLicenseGate } = await import("../license-gate-QTRQHV4F.js");
+    const { initLicenseGate, getCachedLicenseGate } = await import("../license-gate-3KPSNYVA.js");
     const gateResult = await initLicenseGate();
     if (!gateResult.hasKey) {
       process.stderr.write(
@@ -3167,13 +3598,13 @@ async function startMcpHttpServer() {
     let _cachedWrapTelemetry = null;
     async function getWrapTelemetry() {
       if (!_cachedWrapTelemetry) {
-        const { wrapServerWithTelemetry } = await import("../tool-telemetry-KBXSBDTK.js");
+        const { wrapServerWithTelemetry } = await import("../tool-telemetry-4MF2HIWR.js");
         _cachedWrapTelemetry = wrapServerWithTelemetry;
       }
       return _cachedWrapTelemetry;
     }
     Promise.all([
-      import("../tool-capability-index-VYF5GNJ2.js"),
+      import("../tool-capability-index-QOFFCWDS.js"),
       import("../tool-gates-3IC7DK4R.js")
     ]).then(async ([{ getToolCapabilityIndex }, { TOOL_CATEGORIES }]) => {
       const gateState = getCachedLicenseGate();
@@ -3239,7 +3670,7 @@ async function startMcpHttpServer() {
       const expectedBuf = Buffer.from(_daemonToken);
       if (tokenBuf.length === expectedBuf.length && timingSafeEqual(tokenBuf, expectedBuf)) return true;
       try {
-        const { verifyAccessToken } = await import("../oauth-server-67YBDP32.js");
+        const { verifyAccessToken } = await import("../oauth-server-HPQCBLZQ.js");
         const result = verifyAccessToken(token);
         return result.valid;
       } catch {
@@ -3248,28 +3679,28 @@ async function startMcpHttpServer() {
     }
     const pendingStaleSessionRecoveries = /* @__PURE__ */ new Map();
     _mcpSessionDetailsRef = sessionDetails;
+    _mcpSessionLastSeenRef = sessionLastSeen;
     try {
+      const { filterRestorableSessions, mcpSessionRestoreMaxAgeMs } = await import("../mcp-session-persist-PS7BIG44.js");
       const sessPath = path3.join(EXE_AI_DIR, "mcp-sessions-persist.json");
-      if (existsSync4(sessPath)) {
-        const raw = readFileSync4(sessPath, "utf-8");
+      if (existsSync5(sessPath)) {
+        const raw = readFileSync5(sessPath, "utf-8");
         const saved = JSON.parse(raw);
-        const MAX_AGE_MS = 5 * 60 * 1e3;
+        const MAX_AGE_MS = mcpSessionRestoreMaxAgeMs();
         const now = Date.now();
         let restored = 0;
-        for (const s of saved) {
-          if (now - s.savedAt < MAX_AGE_MS) {
-            sessionLastSeen.set(s.sessionId, s.savedAt);
-            sessionDetails.set(s.sessionId, {
-              agentId: s.agentId,
-              agentRole: s.agentRole,
-              runtime: s.runtime,
-              sessionHint: s.sessionHint
-            });
-            restored++;
-          }
+        for (const s of filterRestorableSessions(saved, now, MAX_AGE_MS)) {
+          sessionLastSeen.set(s.sessionId, s.savedAt);
+          sessionDetails.set(s.sessionId, {
+            agentId: s.agentId,
+            agentRole: s.agentRole,
+            runtime: s.runtime,
+            sessionHint: s.sessionHint
+          });
+          restored++;
         }
         try {
-          unlinkSync2(sessPath);
+          unlinkSync3(sessPath);
         } catch {
         }
         if (restored > 0) {
@@ -3492,7 +3923,7 @@ async function startMcpHttpServer() {
         return;
       }
       try {
-        const { handleOAuthRoute } = await import("../oauth-server-67YBDP32.js");
+        const { handleOAuthRoute } = await import("../oauth-server-HPQCBLZQ.js");
         const handled = await handleOAuthRoute(req, res, url, MCP_HTTP_PORT);
         if (handled) return;
       } catch (err) {
@@ -3524,7 +3955,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-LEXMUQ5B.js");
+          const { loadWebhookConfig, verifyHmac, processWebhook } = await import("../webhook-pipe-HH7XXXYC.js");
           const webhookConfig = await loadWebhookConfig();
           const serviceConfig = webhookConfig[serviceName];
           if (!serviceConfig) {
@@ -3620,7 +4051,7 @@ async function startMcpHttpServer() {
             contextPct: body.context_pct
           });
           if (body.context_pct !== void 0 && body.context_pct > 70) {
-            void import("../orchestration-events-WV4NWKZH.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+            void import("../orchestration-events-5XDNVNR2.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
               recordOE({
                 eventType: "context.pressure",
                 source: "exe-daemon.heartbeat",
@@ -3705,7 +4136,7 @@ async function startMcpHttpServer() {
       let sessionHint = req.headers["x-exe-session-name"] || req.headers["x-exe-session"] || "";
       if (sessionHint) {
         try {
-          const { sanitizeSessionHintHeader, rejectForgedSessionHint } = await import("../mcp-session-identity-T7H2EKFQ.js");
+          const { sanitizeSessionHintHeader, rejectForgedSessionHint } = await import("../mcp-session-identity-S7GSVRR6.js");
           const rawHint = sessionHint;
           sessionHint = sanitizeSessionHintHeader(sessionHint);
           if (!sessionHint) {
@@ -3740,7 +4171,7 @@ async function startMcpHttpServer() {
         try {
           const liveSessions = await getTmuxSessionsAsync();
           const paneCommands = await getPaneCommandsAsync();
-          const { resolveMcpSessionHint } = await import("../mcp-session-identity-T7H2EKFQ.js");
+          const { resolveMcpSessionHint } = await import("../mcp-session-identity-S7GSVRR6.js");
           let registrySessions = [];
           try {
             const { listSessions: listRegistrySessions } = await import("./session-registry.js");
@@ -3876,7 +4307,7 @@ async function startMcpHttpServer() {
               bindLive = await getTmuxSessionsAsync();
             } catch {
             }
-            const { isLauncherCorroboratedIdentity } = await import("../mcp-session-identity-T7H2EKFQ.js");
+            const { isLauncherCorroboratedIdentity } = await import("../mcp-session-identity-S7GSVRR6.js");
             const corroborated = isLauncherCorroboratedIdentity({
               agentId,
               registrySessions: bindRegistry,
@@ -4119,7 +4550,7 @@ async function startMcpHttpServer() {
         }
       }
       try {
-        const { reconcileHintWithRegistryIdentity } = await import("../mcp-session-identity-T7H2EKFQ.js");
+        const { reconcileHintWithRegistryIdentity } = await import("../mcp-session-identity-S7GSVRR6.js");
         const { listSessions: listRegistrySessions } = await import("./session-registry.js");
         const recon = reconcileHintWithRegistryIdentity({
           agentId,
@@ -4257,7 +4688,7 @@ async function startMcpHttpServer() {
 `);
         _boundMcpPort = MCP_HTTP_PORT;
         writeDaemonReady({ pid: process.pid, port: MCP_HTTP_PORT });
-        void import("../mcp-port-config-6HYY6J7K.js").then(({ persistMcpPortToConfig }) => persistMcpPortToConfig(String(MCP_HTTP_PORT))).catch(() => {
+        void import("../mcp-port-config-PA3W3BJK.js").then(({ persistMcpPortToConfig }) => persistMcpPortToConfig(String(MCP_HTTP_PORT))).catch(() => {
         });
         recordMcpHttpEvent({
           level: "info",
@@ -4316,9 +4747,9 @@ async function ensureStoreForPolling() {
       await initDatabase({ dbPath: config.dbPath, encryptionKey: masterKey.toString("hex") });
       await ensureSchema();
       try {
-        const { isLedgerEnabled } = await import("../notification-ledger-SZEPGJQ7.js");
+        const { isLedgerEnabled } = await import("../notification-ledger-A6MYLQAN.js");
         if (isLedgerEnabled()) {
-          const { bumpBootGeneration } = await import("../boot-generation-BL2ISK4U.js");
+          const { bumpBootGeneration } = await import("../boot-generation-CFA5NKSK.js");
           const { setDaemonReadyGeneration } = await import("../daemon-ready-signal-LPAZWQOV.js");
           const generation = await bumpBootGeneration();
           setDaemonReadyGeneration(generation);
@@ -4332,8 +4763,18 @@ async function ensureStoreForPolling() {
       try {
         const { spawnDbReadWorker } = await import("./db-read-worker-client.js");
         spawnDbReadWorker(config.dbPath, masterKey.toString("hex"));
+        const { registerBackupOffload } = await import("./db-backup.js");
+        registerBackupOffload({ dbPath: config.dbPath, encryptionKeyHex: masterKey.toString("hex") });
       } catch (e) {
         process.stderr.write(`[exed] DB read worker spawn failed (non-fatal): ${e instanceof Error ? e.message : String(e)}
+`);
+      }
+      try {
+        if (isWriteWorkerEnabled()) {
+          spawnDbWriteWorker(config.dbPath, masterKey.toString("hex"));
+        }
+      } catch (e) {
+        process.stderr.write(`[exed] DB write worker spawn failed (non-fatal): ${e instanceof Error ? e.message : String(e)}
 `);
       }
     }
@@ -4348,13 +4789,13 @@ async function ensureStoreForPolling() {
   }
 }
 async function startReviewPolling() {
-  const polling = await import("../review-polling-HXAFJZDA.js");
+  const polling = await import("../review-polling-DLPMK3QW.js");
   const state = {
     lastIntercomSent: /* @__PURE__ */ new Map(),
     lastNudgeSent: /* @__PURE__ */ new Map(),
     intervalMs: REVIEW_POLL_INTERVAL_MS
   };
-  const { pollReviewNudge, createReviewNudgeRealDeps, loadNudgeState } = await import("../daemon-orchestration-FX4XZDR5.js");
+  const { pollReviewNudge, createReviewNudgeRealDeps, loadNudgeState } = await import("../daemon-orchestration-GGSRCXR3.js");
   const nudgeState = loadNudgeState();
   const tick = async () => traceDaemonTimer("review_polling", async () => {
     fired("review_polling");
@@ -4400,7 +4841,7 @@ function startSessionTTL() {
       if (!await ensureStoreForPolling()) return;
       if (inPostRestartDestructiveGrace("session_ttl")) return;
       const { getClient } = await import("./database.js");
-      const { checkSessionTTL, createSessionTTLRealDeps } = await import("../daemon-orchestration-FX4XZDR5.js");
+      const { checkSessionTTL, createSessionTTLRealDeps } = await import("../daemon-orchestration-GGSRCXR3.js");
       const deps = createSessionTTLRealDeps(getClient);
       const killed = await checkSessionTTL(deps, _wedgeObservations);
       if (killed.length > 0) acted("session_ttl");
@@ -4426,7 +4867,7 @@ function startIdleKill() {
     if (inPostRestartDestructiveGrace("idle_kill")) return;
     try {
       const signalDir = path3.join(os2.homedir(), ".exe-os", "task-signals");
-      if (existsSync4(signalDir)) {
+      if (existsSync5(signalDir)) {
         const files = (await import("fs")).readdirSync(signalDir).filter((f) => f.endsWith(".terminate"));
         for (const file of files) {
           const agentId = file.replace(".terminate", "");
@@ -4440,9 +4881,9 @@ function startIdleKill() {
 `);
               acted("idle_kill");
             }
-            unlinkSync2(signalPath);
+            unlinkSync3(signalPath);
           } catch {
-            unlinkSync2(signalPath);
+            unlinkSync3(signalPath);
           }
         }
       }
@@ -4452,7 +4893,7 @@ function startIdleKill() {
       const cfg = await getCachedConfig();
       if (!cfg) return;
       const { getClient } = await import("./database.js");
-      const { pollIdleKill, createIdleKillRealDeps } = await import("../daemon-orchestration-FX4XZDR5.js");
+      const { pollIdleKill, createIdleKillRealDeps } = await import("../daemon-orchestration-GGSRCXR3.js");
       const { sessions: liveSessions, paneCache, aliveSessions } = await getSharedOrchestrationCaches();
       const realDeps = createIdleKillRealDeps(
         getClient,
@@ -4525,7 +4966,7 @@ function startConsolidation() {
 `);
       }
       try {
-        const { createBackupAsync, enforceRetention } = await import("../db-backup-W2QFSYQC.js");
+        const { createBackupAsync, enforceRetention } = await import("./db-backup.js");
         const p = await createBackupAsync("pre-consolidation");
         if (p) enforceRetention("pre-consolidation");
       } catch (e) {
@@ -4758,7 +5199,7 @@ function startSkillRefinement() {
     if (!shouldRunHeavyJob("skill_refinement")) return;
     try {
       if (!await ensureStoreForPolling()) return;
-      const { runSkillRefinement } = await import("../skill-refinement-DVSYXBBP.js");
+      const { runSkillRefinement } = await import("../skill-refinement-ACXLAK2G.js");
       const result = await runSkillRefinement();
       if (result.reviewed > 0) {
         acted("skill_refinement");
@@ -4784,8 +5225,8 @@ function startStaleBranchSweep() {
   const tick = async () => {
     fired("stale_branch_sweep");
     try {
-      const { discoverRepoPaths } = await import("../worktree-sweep-WTK3MTKH.js");
-      const { scanUnmergedBranchesCached } = await import("../branch-hygiene-TZWK6QCF.js");
+      const { discoverRepoPaths } = await import("../worktree-sweep-VSL7TRQK.js");
+      const { scanUnmergedBranchesCached } = await import("../branch-hygiene-PILXQQDF.js");
       const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       for (const k of _staleBranchAlertedToday) {
         if (!k.endsWith(today)) _staleBranchAlertedToday.delete(k);
@@ -4816,7 +5257,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-4UT53CDG.js");
+          const { writeNotification } = await import("../notifications-6XCSUTJW.js");
           await writeNotification({
             agentId: "exe",
             agentRole: "system",
@@ -5273,14 +5714,14 @@ function startReflectionSweep() {
       );
       let runReflection;
       try {
-        ({ runReflection } = await import("../memory-reflection-WVNFBJAA.js"));
+        ({ runReflection } = await import("../memory-reflection-3VPYJS2G.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)}
 `);
         return;
       }
-      const { runBudgetedSweep } = await import("../sweep-budget-WB2FKPYN.js");
+      const { runBudgetedSweep } = await import("../sweep-budget-LQYBMDTK.js");
       let totalInsights = 0;
       await runBudgetedSweep(
         agents.rows,
@@ -5314,7 +5755,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-ZRDW7QBX.js");
+        const { insertMemoryCardsForBatch } = await import("../memory-cards-47NYPFC3.js");
         const batchSize = 500;
         let offset = 0;
         let totalCards = 0;
@@ -5359,7 +5800,7 @@ function startDatabaseBackup() {
   const tick = async () => {
     fired("db_backup");
     try {
-      const { createBackupAsync, enforceRetention, hasBackupToday, hasRecentBackup } = await import("../db-backup-W2QFSYQC.js");
+      const { createBackupAsync, enforceRetention, hasBackupToday, hasRecentBackup } = await import("./db-backup.js");
       if (!hasRecentBackup("guaranteed", DB_BACKUP_TARGET_WINDOW_MS)) {
         const guaranteedPath = await createBackupAsync("guaranteed");
         if (guaranteedPath) {
@@ -5382,7 +5823,7 @@ function startDatabaseBackup() {
 `
         );
         try {
-          const { maybeVerifyDailyBackup } = await import("../backup-verify-3Y2FHGZU.js");
+          const { maybeVerifyDailyBackup } = await import("../backup-verify-KDLOT4RP.js");
           const verdict = await maybeVerifyDailyBackup(backupPath);
           if (verdict && !verdict.ok) {
             process.stderr.write(
@@ -5459,7 +5900,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-O3BV56ZX.js");
+      const { sweepExpiredSessionEvents, DEFAULT_SESSION_EVENTS_RETENTION_DAYS } = await import("../session-events-N5VRC6IT.js");
       const days = SESSION_EVENTS_RETENTION_DAYS ?? DEFAULT_SESSION_EVENTS_RETENTION_DAYS;
       const count = await sweepExpiredSessionEvents(getClient(), days);
       if (count > 0) {
@@ -5490,7 +5931,7 @@ function startIntercomQueueDrain() {
   const tick = async () => traceDaemonTimer("intercom_queue_drain", async () => {
     fired("intercom_queue_drain");
     try {
-      const { drainQueueAsync, readQueue } = await import("../intercom-queue-ZFEQALR3.js");
+      const { drainQueueAsync, readQueue } = await import("../intercom-queue-NFOLOBTT.js");
       const {
         sendIntercomAsync: centralSendIntercomAsync,
         countScopedPendingReviews,
@@ -5622,7 +6063,7 @@ function startLedgerDrain() {
   const tick = async () => traceDaemonTimer("ledger_drain", async () => {
     fired("ledger_drain");
     try {
-      const { isLedgerEnabled, drainLedger } = await import("../notification-ledger-SZEPGJQ7.js");
+      const { isLedgerEnabled, drainLedger } = await import("../notification-ledger-A6MYLQAN.js");
       if (!isLedgerEnabled()) return;
       const result = await drainLedger({
         // Shadow "would-deliver": idle target = would-deliver, busy = retry.
@@ -5661,7 +6102,7 @@ function startOrphanReaper() {
   const tick = async () => traceDaemonTimer("orphan_reaper", async () => {
     fired("orphan_reaper");
     try {
-      const { reapOrphanedMcpProcesses, createOrphanReaperRealDepsAsync } = await import("../daemon-orchestration-FX4XZDR5.js");
+      const { reapOrphanedMcpProcesses, createOrphanReaperRealDepsAsync } = await import("../daemon-orchestration-GGSRCXR3.js");
       const deps = await createOrphanReaperRealDepsAsync();
       const reaped = await reapOrphanedMcpProcesses(deps);
       if (reaped.length > 0) acted("orphan_reaper");
@@ -5686,7 +6127,7 @@ function startZombieAgentReaper() {
   const tick = async () => traceDaemonTimer("zombie_agent_reaper", async () => {
     fired("zombie_agent_reaper");
     try {
-      const { reapZombieAgentProcesses, createZombieAgentReaperRealDepsAsync } = await import("../daemon-orchestration-FX4XZDR5.js");
+      const { reapZombieAgentProcesses, createZombieAgentReaperRealDepsAsync } = await import("../daemon-orchestration-GGSRCXR3.js");
       const deps = await createZombieAgentReaperRealDepsAsync();
       const reaped = reapZombieAgentProcesses(deps);
       if (reaped.length > 0) acted("zombie_agent_reaper");
@@ -5710,7 +6151,7 @@ async function startDaemonMemoryPressureWatchdog() {
   try {
     const cfg = await getCachedConfig();
     if (!cfg) return;
-    const { startMemoryPressureWatchdog: startWatchdog, MEMORY_PRESSURE_WATCHDOG_DEFAULTS } = await import("../memory-pressure-watchdog-HN5X7AVN.js");
+    const { startMemoryPressureWatchdog: startWatchdog, MEMORY_PRESSURE_WATCHDOG_DEFAULTS } = await import("../memory-pressure-watchdog-PSVJ5BCF.js");
     const watchdogCfg = {
       ...MEMORY_PRESSURE_WATCHDOG_DEFAULTS,
       ...cfg.memoryPressureWatchdog ?? {}
@@ -5741,7 +6182,7 @@ function startWorktreeReaper() {
   const tick = async () => traceDaemonTimer("worktree_reaper", async () => {
     fired("worktree_reaper");
     try {
-      const { reapOrphanedWorktrees, createWorktreeReaperRealDeps } = await import("../daemon-orchestration-FX4XZDR5.js");
+      const { reapOrphanedWorktrees, createWorktreeReaperRealDeps } = await import("../daemon-orchestration-GGSRCXR3.js");
       const deps = await createWorktreeReaperRealDeps();
       const result = await reapOrphanedWorktrees(deps);
       if (result.pruned.length > 0) {
@@ -5781,8 +6222,8 @@ function startWorktreeReaper() {
               }
               continue;
             }
-            const { cleanupAgentWorktree } = await import("../worktree-sweep-WTK3MTKH.js");
-            const { getMainRepoRootAsync } = await import("../worktree-LL62PLQB.js");
+            const { cleanupAgentWorktree } = await import("../worktree-sweep-VSL7TRQK.js");
+            const { getMainRepoRootAsync } = await import("../worktree-VDCY44ZP.js");
             const repoRoot = await getMainRepoRootAsync(signal.worktreePath);
             if (repoRoot && signal.agentId) {
               const notes = await cleanupAgentWorktree(repoRoot, signal.agentId);
@@ -5815,7 +6256,7 @@ function startAutoWake() {
     if (!await ensureStoreForPolling()) return;
     try {
       const { getClient } = await import("./database.js");
-      const { pollOrphanedTasks, createAutoWakeRealDeps } = await import("../daemon-orchestration-FX4XZDR5.js");
+      const { pollOrphanedTasks, createAutoWakeRealDeps } = await import("../daemon-orchestration-GGSRCXR3.js");
       const deps = createAutoWakeRealDeps(getClient, process.cwd(), getTmuxSessionsAsync);
       const woken = await pollOrphanedTasks(deps);
       if (woken.length > 0) acted("auto_wake");
@@ -5825,7 +6266,7 @@ function startAutoWake() {
       }
       try {
         const signalBase = path3.join(os2.homedir(), ".exe-os", "task-signals");
-        if (existsSync4(signalBase)) {
+        if (existsSync5(signalBase)) {
           const { readdirSync: readdirSync2, statSync: statSyncFs } = await import("fs");
           const { sendIntercomAsync, extractRootExe } = await import("./tmux-routing.js");
           const sessionCache = path3.join(os2.homedir(), ".exe-os", "session-cache");
@@ -5841,11 +6282,11 @@ function startAutoWake() {
             if (cached && Date.now() - cached.ts < 3e4) return cached.runtime;
             try {
               const dispatchInfoPath = path3.join(sessionCache, `dispatch-info-${sessionName}.json`);
-              if (!existsSync4(dispatchInfoPath)) {
+              if (!existsSync5(dispatchInfoPath)) {
                 _runtimeCache.set(sessionName, { runtime: "claude", ts: Date.now() });
                 return "claude";
               }
-              const raw = JSON.parse(readFileSync4(dispatchInfoPath, "utf8"));
+              const raw = JSON.parse(readFileSync5(dispatchInfoPath, "utf8"));
               const rt = raw.runtime ?? "claude";
               _runtimeCache.set(sessionName, { runtime: rt, ts: Date.now() });
               return rt;
@@ -5865,8 +6306,8 @@ function startAutoWake() {
               const age = Date.now() - statSyncFs(signalPath).mtimeMs;
               if (age > 60 * 60 * 1e3) {
                 try {
-                  unlinkSync2(signalPath);
-                  void import("../orchestration-events-WV4NWKZH.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+                  unlinkSync3(signalPath);
+                  void import("../orchestration-events-5XDNVNR2.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
                     recordOE({ eventType: "signal.stale", source: "exe-daemon.autoWake", severity: "warn", payload: { file, ageMinutes: Math.round(age / 6e4) } });
                   }).catch(() => {
                   });
@@ -5934,7 +6375,7 @@ function startWalCheckpoint() {
     try {
       const { getClient, runWalCheckpoint } = await import("./database.js");
       const client = getClient();
-      const { findActiveDb } = await import("../db-backup-W2QFSYQC.js");
+      const { findActiveDb } = await import("./db-backup.js");
       const dbPath = findActiveDb();
       const started = Date.now();
       const result = await runWalCheckpoint(client, dbPath, true);
@@ -6012,7 +6453,7 @@ function startStuckTaskRelease() {
         createStuckTaskRealDeps,
         escalateStuckBlockedTasks,
         createStuckBlockedRealDeps
-      } = await import("../daemon-orchestration-FX4XZDR5.js");
+      } = await import("../daemon-orchestration-GGSRCXR3.js");
       const deps = createStuckTaskRealDeps(getClient);
       const released = await releaseStuckTasks(deps);
       if (released.length > 0) {
@@ -6207,12 +6648,12 @@ function startTaskEnforcementScanner() {
   const tick = async () => traceDaemonTimer("task_enforcement", async () => {
     fired("task_enforcement");
     try {
-      const { runTaskEnforcementTick } = await import("../task-enforcement-IPIZX2MM.js");
+      const { runTaskEnforcementTick } = await import("../task-enforcement-C7MMJTKX.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-FOIW25HR.js");
+      const { sessionScopeFilter } = await import("../task-scope-DK666AKV.js");
       const transport = getTransport();
       const { sessions: allSessions, paneCache, aliveSessions } = await getSharedOrchestrationCaches();
       await yieldToEventLoop();
@@ -6223,10 +6664,10 @@ function startTaskEnforcementScanner() {
         sendKeysLiteral: transport.sendKeysLiteral?.bind(transport),
         isAlive: (session) => aliveSessions.has(session)
       };
-      const { checkAutoWakeGates } = await import("../daemon-orchestration-FX4XZDR5.js");
+      const { checkAutoWakeGates } = await import("../daemon-orchestration-GGSRCXR3.js");
       const { ensureEmployeeAsync, employeeSessionName, sendIntercomAsync } = await import("./tmux-routing.js");
       const { shouldAutoInstance } = await import("./employees.js");
-      const { recordOrchestrationEventBestEffort } = await import("../orchestration-events-WV4NWKZH.js");
+      const { recordOrchestrationEventBestEffort } = await import("../orchestration-events-5XDNVNR2.js");
       const projectDir = process.cwd();
       await runTaskEnforcementTick({
         transport: enforcementTransport,
@@ -6360,8 +6801,8 @@ function startRssWatchdog() {
 `
         );
         try {
-          mkdirSync2(path3.dirname(OOM_MARKER_PATH), { recursive: true });
-          writeFileSync3(OOM_MARKER_PATH, `RSS=${(effectiveRss / 1024 / 1024).toFixed(0)}MB at ${(/* @__PURE__ */ new Date()).toISOString()}
+          mkdirSync3(path3.dirname(OOM_MARKER_PATH), { recursive: true });
+          writeFileSync4(OOM_MARKER_PATH, `RSS=${(effectiveRss / 1024 / 1024).toFixed(0)}MB at ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
           process.stderr.write(`[exed] Wrote OOM marker at ${OOM_MARKER_PATH}
 `);
@@ -6475,14 +6916,14 @@ function startApiWatchdog() {
           process.stderr.write(`[exed] API watchdog nudged ${session} (attempt ${nudgeCount}/3, matched: ${matchedPattern.source})
 `);
           try {
-            const { appendFileSync, mkdirSync: mkdirSync3, statSync: statSyncFs, renameSync: renameSyncFs } = await import("fs");
-            const { join: join2 } = await import("path");
-            const logDir = join2(process.env.EXE_OS_DIR ?? join2(process.env.HOME ?? "", ".exe-os"), "logs");
+            const { appendFileSync, mkdirSync: mkdirSync4, statSync: statSyncFs, renameSync: renameSyncFs } = await import("fs");
+            const { join: join3 } = await import("path");
+            const logDir = join3(process.env.EXE_OS_DIR ?? join3(process.env.HOME ?? "", ".exe-os"), "logs");
             try {
-              mkdirSync3(logDir, { recursive: true });
+              mkdirSync4(logDir, { recursive: true });
             } catch {
             }
-            const watchdogLogPath = join2(logDir, "api-watchdog.jsonl");
+            const watchdogLogPath = join3(logDir, "api-watchdog.jsonl");
             try {
               const wStat = statSyncFs(watchdogLogPath);
               if (wStat.size > 5 * 1024 * 1024) renameSyncFs(watchdogLogPath, watchdogLogPath + ".1");
@@ -6518,7 +6959,7 @@ function startBackgroundJobGuardrails() {
   const tick = async () => traceDaemonTimer("background_job_guardrails", async () => {
     fired("background_job_guardrails");
     try {
-      const { enforceBackgroundJobGuardrailsAsync } = await import("../background-jobs-EXR5RVGG.js");
+      const { enforceBackgroundJobGuardrailsAsync } = await import("../background-jobs-KKRO3QRO.js");
       const actions = await enforceBackgroundJobGuardrailsAsync();
       if (actions.length > 0) {
         acted("background_job_guardrails");
@@ -6709,18 +7150,18 @@ process.on("uncaughtException", (err) => {
   } catch {
   }
   try {
-    unlinkSync2(SOCKET_PATH);
+    unlinkSync3(SOCKET_PATH);
   } catch (_) {
   }
   try {
-    unlinkSync2(PID_PATH);
+    unlinkSync3(PID_PATH);
   } catch (_) {
   }
   setTimeout(() => process.exit(1), 3e3);
 });
 function readProcEnviron(pid) {
   try {
-    const raw = readFileSync4(`/proc/${pid}/environ`, "utf8");
+    const raw = readFileSync5(`/proc/${pid}/environ`, "utf8");
     const env = {};
     for (const part of raw.split("\0")) {
       const idx = part.indexOf("=");
@@ -6773,18 +7214,18 @@ function killOrphanDaemons() {
 }
 function checkExistingDaemon() {
   try {
-    if (!existsSync4(PID_PATH)) {
+    if (!existsSync5(PID_PATH)) {
       killOrphanDaemons();
       return false;
     }
-    const pid = parseInt(readFileSync4(PID_PATH, "utf8").trim(), 10);
+    const pid = parseInt(readFileSync5(PID_PATH, "utf8").trim(), 10);
     if (!pid || isNaN(pid)) {
       killOrphanDaemons();
       return false;
     }
     if (pid === process.pid) {
       try {
-        unlinkSync2(PID_PATH);
+        unlinkSync3(PID_PATH);
       } catch {
       }
       return false;
@@ -6795,11 +7236,11 @@ function checkExistingDaemon() {
         process.stderr.write(`[exed] PID ${pid} is a zombie \u2014 cleaning up and proceeding.
 `);
         try {
-          unlinkSync2(PID_PATH);
+          unlinkSync3(PID_PATH);
         } catch {
         }
         try {
-          unlinkSync2(SOCKET_PATH);
+          unlinkSync3(SOCKET_PATH);
         } catch {
         }
         killOrphanDaemons();
@@ -6809,11 +7250,11 @@ function checkExistingDaemon() {
       process.stderr.write(`[exed] PID ${pid} no longer exists \u2014 cleaning stale PID file.
 `);
       try {
-        unlinkSync2(PID_PATH);
+        unlinkSync3(PID_PATH);
       } catch {
       }
       try {
-        unlinkSync2(SOCKET_PATH);
+        unlinkSync3(SOCKET_PATH);
       } catch {
       }
       killOrphanDaemons();
@@ -6835,7 +7276,7 @@ function checkExistingDaemon() {
       return true;
     }
     try {
-      unlinkSync2(PID_PATH);
+      unlinkSync3(PID_PATH);
     } catch {
     }
     killOrphanDaemons();
@@ -6908,21 +7349,21 @@ function startAutoUpdateCheck() {
 if (checkExistingDaemon()) {
   process.exit(0);
 }
-writeFileSync3(PID_PATH, String(process.pid));
+writeFileSync4(PID_PATH, String(process.pid));
 try {
   chmodSync(PID_PATH, 384);
 } catch {
 }
 markAsDaemonProcess();
 var DAEMON_BOOT_PATH = path3.join(EXE_AI_DIR, "daemon-boot-ts");
-writeFileSync3(DAEMON_BOOT_PATH, (/* @__PURE__ */ new Date()).toISOString());
+writeFileSync4(DAEMON_BOOT_PATH, (/* @__PURE__ */ new Date()).toISOString());
 try {
   chmodSync(DAEMON_BOOT_PATH, 420);
 } catch {
 }
 await new Promise((r) => setTimeout(r, 500));
 try {
-  const claimedPid = parseInt(readFileSync4(PID_PATH, "utf8").trim(), 10);
+  const claimedPid = parseInt(readFileSync5(PID_PATH, "utf8").trim(), 10);
   if (claimedPid !== process.pid) {
     process.stderr.write(
       `[exed] Race detected \u2014 PID ${claimedPid} claimed the lock. Exiting cleanly.
@@ -6941,12 +7382,12 @@ process.env.EXE_IS_DAEMON = "1";
 if (process.platform === "darwin") {
   try {
     const oldPlist = path3.join(os2.homedir(), "Library", "LaunchAgents", "com.askexe.exed-keepalive.plist");
-    if (existsSync4(oldPlist)) {
+    if (existsSync5(oldPlist)) {
       try {
         execSyncNode(`launchctl unload "${oldPlist}" 2>/dev/null`, { timeout: 5e3 });
       } catch {
       }
-      unlinkSync2(oldPlist);
+      unlinkSync3(oldPlist);
       process.stderr.write("[exed] Removed old keepalive plist (replaced by launchd KeepAlive).\n");
     }
   } catch {
@@ -6955,7 +7396,7 @@ if (process.platform === "darwin") {
 logBoot({ socketPath: SOCKET_PATH, pidPath: PID_PATH });
 void (async () => {
   try {
-    const { cleanupCrashDebris } = await import("../db-backup-W2QFSYQC.js");
+    const { cleanupCrashDebris } = await import("./db-backup.js");
     const removed = cleanupCrashDebris();
     if (removed > 0) {
       process.stderr.write(`[exed] Startup cleanup: pruned ${removed} crash-debris file(s) (backups/quarantine).
@@ -7104,11 +7545,16 @@ function startEventLoopLagDetector() {
   const { singleMs: SELF_HEAL_SINGLE_MS, consecutive: SELF_HEAL_CONSECUTIVE, thresholdMs: SELF_HEAL_THRESHOLD_MS } = resolveSelfHealThresholds();
   let consecutiveSevereBlocks = 0;
   let selfInflictedWindow = [];
+  const LOAD_SAMPLE_KEEP_MS = Math.max(12e4, SELF_HEAL_SINGLE_MS + 6e4);
+  let loadSamples = [];
   touchEventLoopHeartbeat();
   const lagTimer = setInterval(() => {
     touchEventLoopHeartbeat();
     const wallElapsedMs = monotonicElapsedMs(lastTick);
     const lag = wallElapsedMs - 2e3;
+    const sampledLoad1m = os2.loadavg()[0] ?? 0;
+    const loadWindow = updateLoadWindow(loadSamples, Date.now(), sampledLoad1m, wallElapsedMs, LOAD_SAMPLE_KEEP_MS);
+    loadSamples = loadWindow.samples;
     const cpuDelta = process.cpuUsage(lastCpu);
     lastCpu = process.cpuUsage();
     const selfCpuBusyFraction = wallElapsedMs > 0 ? (cpuDelta.user + cpuDelta.system) / 1e3 / wallElapsedMs : 0;
@@ -7119,7 +7565,7 @@ function startEventLoopLagDetector() {
     if (clockJump) {
       consecutiveSevereBlocks = 0;
       try {
-        unlinkSync2(path3.join(os2.homedir(), ".exe-os", "session-cache", "event-loop-blocked.marker"));
+        unlinkSync3(path3.join(os2.homedir(), ".exe-os", "session-cache", "event-loop-blocked.marker"));
       } catch {
       }
       process.stderr.write("[exed] Event loop lag detector: wall-clock jump/sleep detected; reset without self-heal.\n");
@@ -7129,12 +7575,12 @@ 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-WV4NWKZH.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+      void import("../orchestration-events-5XDNVNR2.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
         recordOE({ eventType: "daemon.event_loop_blocked", source: "exe-daemon.lagDetector", severity: "error", durationMs: lag });
       }).catch(() => {
       });
       try {
-        writeFileSync3(path3.join(os2.homedir(), ".exe-os", "session-cache", "event-loop-blocked.marker"), `lag=${lag}ms at ${(/* @__PURE__ */ new Date()).toISOString()}
+        writeFileSync4(path3.join(os2.homedir(), ".exe-os", "session-cache", "event-loop-blocked.marker"), `lag=${lag}ms at ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
       } catch {
       }
@@ -7150,13 +7596,15 @@ function startEventLoopLagDetector() {
         });
       } catch {
       }
-      const load1m = os2.loadavg()[0] ?? 0;
+      const load1m = sampledLoad1m;
+      const maxLoad1mOverWindow = loadWindow.maxLoad1mOverWindow;
       const cpuCount = os2.cpus().length || 1;
       const starvationRatio = resolveSelfHealThresholds().starvationRatio;
       const catchUpActive = inBootCatchUpGrace();
       const decision = decideDaemonSelfHeal({
         lagMs: lag,
         load1m,
+        maxLoad1mOverWindow,
         cpuCount,
         starvationRatio,
         singleBlockMs: SELF_HEAL_SINGLE_MS,
@@ -7180,14 +7628,14 @@ function startEventLoopLagDetector() {
       selfInflictedWindow = decision.selfInflictedWindowAfter;
       if (decision.reason === "starved_backoff") {
         process.stderr.write(
-          `[exed] SELF-HEAL SUPPRESSED: load=${load1m.toFixed(2)} cpus=${cpuCount} \u2014 lag is CPU starvation, not internal hang. Skipping restart.
+          `[exed] SELF-HEAL SUPPRESSED: load=${load1m.toFixed(2)} maxOverWindow=${maxLoad1mOverWindow.toFixed(2)} cpus=${cpuCount} \u2014 lag is CPU starvation, not internal hang. Skipping restart.
 `
         );
         logDaemonHealth({
           event: "self_heal_suppressed_starvation",
           pid: process.pid,
-          message: `CPU starved (load=${load1m.toFixed(2)} / cpus=${cpuCount}) \u2014 restart skipped`,
-          data: { lagMs: lag, load1m, cpuCount }
+          message: `CPU starved (load=${load1m.toFixed(2)} maxOverWindow=${maxLoad1mOverWindow.toFixed(2)} / cpus=${cpuCount}) \u2014 restart skipped`,
+          data: { lagMs: lag, load1m, maxLoad1mOverWindow, cpuCount }
         });
         return;
       }
@@ -7274,9 +7722,11 @@ function startTaskFileResync() {
       if (!await ensureStoreForPolling()) return;
       const { readdir, readFile } = await import("fs/promises");
       const { getClient } = await import("./database.js");
+      const { runBudgetedSweep } = await import("../sweep-budget-LQYBMDTK.js");
       const client = getClient();
       const tasksRoot = path3.join(os2.homedir(), ".exe-os", "tasks");
       let synced = 0;
+      const paths = [];
       let fileCount = 0;
       const walkAsync = async (dir) => {
         let entries;
@@ -7292,47 +7742,50 @@ function startTaskFileResync() {
             continue;
           }
           if (!e.name.endsWith(".md")) continue;
-          try {
-            const content = await readFile(full, "utf8");
-            const id = content.match(/\*\*ID:\*\*\s*([a-f0-9-]+)/)?.[1];
-            const title = content.split("\n")[0]?.replace(/^# /, "") || "";
-            const assignedTo = content.match(/\*\*Assigned to:\*\*\s*(\w+)/)?.[1];
-            const assignedBy = content.match(/\*\*Assigned by:\*\*\s*(\w+)/)?.[1] || "exe";
-            const project = content.match(/\*\*Project:\*\*\s*([\w-]+)/)?.[1] || "exe-os";
-            const status = content.match(/\*\*Status:\*\*\s*(\w+)/)?.[1] || "open";
-            const priority = content.match(/\*\*Priority:\*\*\s*(\w+)/)?.[1] || "p1";
-            const scope = full.match(/tasks\/([^/]+)\//)?.[1] || null;
-            if (id && assignedTo) {
-              try {
-                const res = await client.execute({
-                  sql: `INSERT OR IGNORE INTO tasks (id, title, assigned_to, assigned_by, project_name, status, priority, task_file, session_scope, created_at, updated_at)
+          paths.push(full);
+          if (++fileCount % 10 === 0) await yieldToEventLoop();
+        }
+      };
+      await walkAsync(tasksRoot);
+      await runBudgetedSweep(paths, async (full) => {
+        try {
+          const content = await readFile(full, "utf8");
+          const id = content.match(/\*\*ID:\*\*\s*([a-f0-9-]+)/)?.[1];
+          const title = content.split("\n")[0]?.replace(/^# /, "") || "";
+          const assignedTo = content.match(/\*\*Assigned to:\*\*\s*(\w+)/)?.[1];
+          const assignedBy = content.match(/\*\*Assigned by:\*\*\s*(\w+)/)?.[1] || "exe";
+          const project = content.match(/\*\*Project:\*\*\s*([\w-]+)/)?.[1] || "exe-os";
+          const status = content.match(/\*\*Status:\*\*\s*(\w+)/)?.[1] || "open";
+          const priority = content.match(/\*\*Priority:\*\*\s*(\w+)/)?.[1] || "p1";
+          const scope = full.match(/tasks\/([^/]+)\//)?.[1] || null;
+          if (id && assignedTo) {
+            try {
+              const res = await client.execute({
+                sql: `INSERT OR IGNORE INTO tasks (id, title, assigned_to, assigned_by, project_name, status, priority, task_file, session_scope, created_at, updated_at)
                         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-                  args: [id, title, assignedTo, assignedBy, project, status, priority, full, scope, (/* @__PURE__ */ new Date()).toISOString(), (/* @__PURE__ */ new Date()).toISOString()]
-                });
-                if (Number(res.rowsAffected ?? 0) > 0) {
-                  synced++;
-                  void import("../orchestration-events-WV4NWKZH.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
-                    recordOE({
-                      eventType: "task_file.resynced",
-                      source: "exe-daemon.taskFileResync",
-                      taskId: id,
-                      agentId: assignedTo,
-                      sessionScope: scope,
-                      projectName: project,
-                      payload: { status, priority }
-                    });
-                  }).catch(() => {
+                args: [id, title, assignedTo, assignedBy, project, status, priority, full, scope, (/* @__PURE__ */ new Date()).toISOString(), (/* @__PURE__ */ new Date()).toISOString()]
+              });
+              if (Number(res.rowsAffected ?? 0) > 0) {
+                synced++;
+                void import("../orchestration-events-5XDNVNR2.js").then(({ recordOrchestrationEventBestEffort: recordOE }) => {
+                  recordOE({
+                    eventType: "task_file.resynced",
+                    source: "exe-daemon.taskFileResync",
+                    taskId: id,
+                    agentId: assignedTo,
+                    sessionScope: scope,
+                    projectName: project,
+                    payload: { status, priority }
                   });
-                }
-              } catch {
+                }).catch(() => {
+                });
               }
+            } catch {
             }
-          } catch {
           }
-          if (++fileCount % 10 === 0) await yieldToEventLoop();
+        } catch {
         }
-      };
-      await walkAsync(tasksRoot);
+      }, { label: "task_file_resync" });
       if (synced > 0) process.stderr.write(`[exed] Task re-sync: ${synced} missing DB rows restored from disk.
 `);
     } catch (e) {
@@ -7348,7 +7801,7 @@ function startTaskGroupBarriers() {
       fired("task_group_barriers");
       if (!await ensureStoreForPolling()) return;
       try {
-        const { pollTaskGroupBarriers } = await import("../daemon-orchestration-FX4XZDR5.js");
+        const { pollTaskGroupBarriers } = await import("../daemon-orchestration-GGSRCXR3.js");
         const firedCount = await pollTaskGroupBarriers();
         if (firedCount > 0) {
           acted("task_group_barriers");
@@ -7370,7 +7823,7 @@ function startCheckpointGc() {
       fired("checkpoint_gc");
       if (!await ensureStoreForPolling()) return;
       try {
-        const { gcStaleCheckpoints } = await import("../daemon-orchestration-FX4XZDR5.js");
+        const { gcStaleCheckpoints } = await import("../daemon-orchestration-GGSRCXR3.js");
         const cleared = await gcStaleCheckpoints();
         if (cleared > 0) {
           acted("checkpoint_gc");
@@ -7410,14 +7863,14 @@ function startDispatchAckCleanup() {
 function startProjectionWorkerDeferred() {
   setTimeout(async () => {
     try {
-      const { startProjectionWorker } = await import("../projection-worker-FZ7YSN3G.js");
+      const { startProjectionWorker } = await import("../projection-worker-CKC2E22U.js");
       startProjectionWorker();
     } catch {
     }
   }, 2e4);
 }
 async function startToolTelemetry() {
-  const { startToolTelemetryFlush } = await import("../tool-telemetry-KBXSBDTK.js");
+  const { startToolTelemetryFlush } = await import("../tool-telemetry-4MF2HIWR.js");
   startToolTelemetryFlush();
   process.stderr.write("[exed] Tool telemetry started (flush every 5m)\n");
 }
@@ -7553,8 +8006,8 @@ function startLocalFirstTimers() {
       }
       _intercomDedupCompleted = true;
       try {
-        const { writeFileSync: writeFileSync4 } = await import("fs");
-        writeFileSync4(markerPath, (/* @__PURE__ */ new Date()).toISOString(), "utf8");
+        const { writeFileSync: writeFileSync5 } = await import("fs");
+        writeFileSync5(markerPath, (/* @__PURE__ */ new Date()).toISOString(), "utf8");
       } catch {
       }
     } catch (err) {
@@ -7583,7 +8036,7 @@ function startLocalFirstTimers() {
     fired("orphan_task_cleanup");
     try {
       if (!await ensureStoreForPolling()) return;
-      const { cleanOrphanedTaskFiles } = await import("../tasks-crud-HBDKE6C5.js");
+      const { cleanOrphanedTaskFiles } = await import("../tasks-crud-DFPIAAEC.js");
       const count = await cleanOrphanedTaskFiles();
       if (count > 0) {
         acted("orphan_task_cleanup");
@@ -7599,7 +8052,7 @@ function startLocalFirstTimers() {
     fired("task_file_consistency");
     try {
       if (!await ensureStoreForPolling()) return;
-      const { checkTaskFileConsistency } = await import("../tasks-crud-HBDKE6C5.js");
+      const { checkTaskFileConsistency } = await import("../tasks-crud-DFPIAAEC.js");
       const mismatches = await checkTaskFileConsistency();
       if (mismatches > 0) {
         acted("task_file_consistency");
@@ -7618,7 +8071,7 @@ function startLocalFirstTimers() {
   const TELEMETRY_DAILY_MS = 24 * 60 * 60 * 1e3;
   const telemetryDaily = async () => {
     try {
-      const { sendTelemetry, isTelemetryEnabled } = await import("../telemetry-upload-ZOXHRWR5.js");
+      const { sendTelemetry, isTelemetryEnabled } = await import("../telemetry-upload-Y5F6WYLD.js");
       if (!isTelemetryEnabled()) return;
       const { upstream } = await sendTelemetry(24);
       if (upstream.startsWith("sent")) {
@@ -7789,11 +8242,63 @@ async function enterDegradedBreakerMode(crashCount) {
   }, 5 * 60 * 1e3);
 }
 try {
-  const breaker = recordDaemonRestart();
+  let coverageGap;
+  let coverageGapLastHeartbeatTs = null;
+  let coverageGapHostBootTs = null;
+  let coverageGapNowMs = Date.now();
+  try {
+    coverageGapNowMs = Date.now();
+    coverageGapLastHeartbeatTs = readLastHeartbeatTsMs();
+    coverageGapHostBootTs = hostBootTimeMs(coverageGapNowMs, os2.uptime());
+    const rawThreshold = Number(process.env.EXE_COVERAGE_GAP_THRESHOLD_MS);
+    coverageGap = assessCoverageGap({
+      lastHeartbeatTs: coverageGapLastHeartbeatTs,
+      hostBootTs: coverageGapHostBootTs,
+      nowMs: coverageGapNowMs,
+      ...Number.isFinite(rawThreshold) && rawThreshold > 0 ? { gapThresholdMs: Math.floor(rawThreshold) } : {}
+    });
+  } catch {
+    coverageGap = void 0;
+  }
+  const breaker = recordDaemonRestart(void 0, coverageGap);
   process.stderr.write(
     `[exed] Boot classified as ${breaker.bootClass} (${breaker.reasonLabel}); crashes=${breaker.crashInWindow}/${5}, restarts=${breaker.restartsInWindow} in window.
 `
   );
+  try {
+    touchEventLoopHeartbeat();
+  } catch {
+  }
+  try {
+    if (coverageGap && shouldWriteCoverageGapAlert(breaker.bootClass, coverageGap, COVERAGE_GAP_ALERT_THRESHOLD_MS)) {
+      const gapHours = (coverageGap.gapMs / (60 * 60 * 1e3)).toFixed(1);
+      const lastHeartbeatIso = coverageGapLastHeartbeatTs !== null ? new Date(coverageGapLastHeartbeatTs).toISOString() : "unknown";
+      const rebootIso = coverageGap.rebootSpansGap && coverageGapHostBootTs !== null ? `, reboot=${new Date(coverageGapHostBootTs).toISOString()}` : "";
+      process.stderr.write(
+        `[exed] COVERAGE GAP: daemon was down ~${gapHours}h; lastHeartbeat=${lastHeartbeatIso}${rebootIso}; GUI LaunchAgent does not run pre-login.
+`
+      );
+      logDaemonHealth({
+        event: "coverage_gap",
+        pid: process.pid,
+        message: `Daemon coverage gap detected (~${gapHours}h)`,
+        data: {
+          gapMs: coverageGap.gapMs,
+          lastHeartbeatTs: coverageGapLastHeartbeatTs,
+          hostBootTs: coverageGapHostBootTs,
+          rebootSpansGap: coverageGap.rebootSpansGap
+        }
+      });
+      writeCoverageGapAlert(coverageGap, {
+        lastHeartbeatTs: coverageGapLastHeartbeatTs,
+        hostBootTs: coverageGapHostBootTs,
+        nowMs: coverageGapNowMs
+      });
+    } else if (coverageGap) {
+      clearCoverageGapAlertIfExpired();
+    }
+  } catch {
+  }
   if (breaker.trip) {
     logRestartEvent("daemon_restart_breaker_tripped", { crash_in_window: breaker.crashInWindow, restarts_in_window: breaker.restartsInWindow });
     await enterDegradedBreakerMode(breaker.crashInWindow);
@@ -7831,11 +8336,11 @@ try {
   process.stderr.write(`[exed] FATAL: ${err instanceof Error ? err.message : String(err)}
 `);
   try {
-    unlinkSync2(SOCKET_PATH);
+    unlinkSync3(SOCKET_PATH);
   } catch {
   }
   try {
-    unlinkSync2(PID_PATH);
+    unlinkSync3(PID_PATH);
   } catch {
   }
   process.exit(1);