@askexenow/exe-os 0.9.113 → 0.9.115

package/dist/lib/exe-daemon.js

@@ -154,6 +154,17 @@ function normalizeOrchestration(raw) {
   const userOrg = raw.orchestration ?? {};
   raw.orchestration = { ...defaultOrg, ...userOrg };
 }
+function normalizeCloudEndpoint(raw) {
+  const cloud = raw.cloud;
+  if (!cloud?.endpoint) return;
+  const ep = String(cloud.endpoint);
+  if (ep === "https://askexe.com/cloud" || ep === "https://askexe.com/cloud/") {
+    cloud.endpoint = "https://cloud.askexe.com";
+    process.stderr.write(
+      "[config] Auto-migrated cloud endpoint: askexe.com/cloud \u2192 cloud.askexe.com\n"
+    );
+  }
+}
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await ensurePrivateDir(dir);
@@ -179,6 +190,7 @@ async function loadConfig() {
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
     normalizeOrchestration(migratedCfg);
+    normalizeCloudEndpoint(migratedCfg);
     const config2 = { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
     if (config2.dbPath.startsWith("~")) {
       config2.dbPath = config2.dbPath.replace(/^~/, os.homedir());
@@ -207,6 +219,7 @@ function loadConfigSync() {
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
     normalizeOrchestration(migratedCfg);
+    normalizeCloudEndpoint(migratedCfg);
     const config2 = { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
     if (config2.dbPath.startsWith("~")) {
       config2.dbPath = config2.dbPath.replace(/^~/, os.homedir());
@@ -567,6 +580,7 @@ __export(agent_config_exports, {
   clearAgentRuntime: () => clearAgentRuntime,
   getAgentRuntime: () => getAgentRuntime,
   loadAgentConfig: () => loadAgentConfig,
+  normalizeCcModelName: () => normalizeCcModelName,
   saveAgentConfig: () => saveAgentConfig,
   setAgentMcps: () => setAgentMcps,
   setAgentRuntime: () => setAgentRuntime
@@ -595,6 +609,13 @@ function getAgentRuntime(agentId) {
   if (orgDefault) return orgDefault;
   return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
 }
+function normalizeCcModelName(model) {
+  let ccModel = model.replace(/(\d+)\.(\d+)/g, "$1-$2");
+  if (/claude-(opus|sonnet)-4-[6-9]/.test(ccModel) && !ccModel.includes("[1m]")) {
+    ccModel += "[1m]";
+  }
+  return ccModel;
+}
 function setAgentRuntime(agentId, runtime, model, reasoning_effort, mcps) {
   const knownModels = KNOWN_RUNTIMES[runtime];
   if (!knownModels) {
@@ -5510,7 +5531,7 @@ __export(keychain_exports, {
   importMnemonic: () => importMnemonic,
   setMasterKey: () => setMasterKey
 });
-import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2, rename, copyFile } from "fs/promises";
 import { existsSync as existsSync12, statSync as statSync5 } from "fs";
 import { execSync as execSync3 } from "child_process";
 import path11 from "path";
@@ -5545,12 +5566,14 @@ function linuxSecretAvailable() {
 function isRootOnlyTrustedServerKeyFile(keyPath) {
   if (process.platform !== "linux") return false;
   try {
-    const uid = typeof os6.userInfo().uid === "number" ? os6.userInfo().uid : -1;
     const st = statSync5(keyPath);
     if (!st.isFile() || (st.mode & 63) !== 0) return false;
+    const uid = typeof os6.userInfo().uid === "number" ? os6.userInfo().uid : -1;
     if (uid === 0) return true;
     const exeOsDir = process.env.EXE_OS_DIR;
-    return Boolean(exeOsDir && path11.resolve(keyPath).startsWith(path11.resolve(exeOsDir) + path11.sep));
+    if (exeOsDir && path11.resolve(keyPath).startsWith(path11.resolve(exeOsDir) + path11.sep)) return true;
+    if (!linuxSecretAvailable()) return true;
+    return false;
   } catch {
     return false;
   }
@@ -5700,15 +5723,25 @@ async function writeMachineBoundFileFallback(b64) {
   await mkdir3(dir, { recursive: true });
   const keyPath = getKeyPath();
   const machineKey = deriveMachineKey();
-  if (machineKey) {
-    const encrypted = encryptWithMachineKey(b64, machineKey);
-    await writeFile3(keyPath, encrypted + "\n", "utf-8");
-    await chmod2(keyPath, 384);
-    return "encrypted";
+  const content = machineKey ? encryptWithMachineKey(b64, machineKey) + "\n" : b64 + "\n";
+  const result3 = machineKey ? "encrypted" : "plaintext";
+  const tmpPath = keyPath + ".tmp";
+  try {
+    if (existsSync12(keyPath)) {
+      await copyFile(keyPath, keyPath + ".bak").catch(() => {
+      });
+    }
+    await writeFile3(tmpPath, content, "utf-8");
+    await chmod2(tmpPath, 384);
+    await rename(tmpPath, keyPath);
+  } catch (err) {
+    try {
+      await unlink(tmpPath);
+    } catch {
+    }
+    throw err;
   }
-  await writeFile3(keyPath, b64 + "\n", "utf-8");
-  await chmod2(keyPath, 384);
-  return "plaintext";
+  return result3;
 }
 async function getMasterKey() {
   let nativeValue = macKeychainGet() ?? linuxSecretGet();
@@ -5775,7 +5808,7 @@ async function getMasterKey() {
       b64Value = content;
     }
     const key = Buffer.from(b64Value, "base64");
-    if (!content.startsWith(ENCRYPTED_PREFIX) && isRootOnlyTrustedServerKeyFile(keyPath)) {
+    if (isRootOnlyTrustedServerKeyFile(keyPath)) {
       return key;
     }
     const migrated = macKeychainSet(b64Value) || linuxSecretSet(b64Value);
@@ -12346,6 +12379,7 @@ var init_provider_table = __esm({
 // src/lib/intercom-queue.ts
 var intercom_queue_exports = {};
 __export(intercom_queue_exports, {
+  _resetDrainGuard: () => _resetDrainGuard,
   clearQueueForAgent: () => clearQueueForAgent,
   drainForSession: () => drainForSession,
   drainQueue: () => drainQueue2,
@@ -12391,38 +12425,47 @@ function queueIntercom(targetSession, reason) {
   writeQueue(queue);
 }
 function drainQueue2(isSessionBusy2, sendKeys) {
+  if (_draining) {
+    logQueue("SKIP_DRAIN \u2014 previous drain still running (possible tmux hang)");
+    return { drained: 0, failed: 0 };
+  }
   const queue = readQueue();
   if (queue.length === 0) return { drained: 0, failed: 0 };
+  _draining = true;
   const remaining = [];
   let drained = 0;
   let failed = 0;
-  for (const item of queue) {
-    const age = Date.now() - new Date(item.queuedAt).getTime();
-    if (age > TTL_MS2) {
-      logQueue(`EXPIRED \u2192 ${item.targetSession} (${Math.round(age / 6e4)}min old, reason: ${item.reason})`);
-      failed++;
-      continue;
-    }
-    try {
-      if (!isSessionBusy2(item.targetSession)) {
-        const success = sendKeys(item.targetSession);
-        if (success) {
-          logQueue(`DRAINED \u2192 ${item.targetSession} (after ${item.attempts} retries)`);
-          drained++;
-          continue;
+  try {
+    for (const item of queue) {
+      const age = Date.now() - new Date(item.queuedAt).getTime();
+      if (age > TTL_MS2) {
+        logQueue(`EXPIRED \u2192 ${item.targetSession} (${Math.round(age / 6e4)}min old, reason: ${item.reason})`);
+        failed++;
+        continue;
+      }
+      try {
+        if (!isSessionBusy2(item.targetSession)) {
+          const success = sendKeys(item.targetSession);
+          if (success) {
+            logQueue(`DRAINED \u2192 ${item.targetSession} (after ${item.attempts} retries)`);
+            drained++;
+            continue;
+          }
         }
+      } catch {
       }
-    } catch {
-    }
-    item.attempts++;
-    if (item.attempts >= MAX_RETRIES2) {
-      logQueue(`FAILED \u2192 ${item.targetSession} (${MAX_RETRIES2} retries exhausted, reason: ${item.reason})`);
-      failed++;
-      continue;
+      item.attempts++;
+      if (item.attempts >= MAX_RETRIES2) {
+        logQueue(`FAILED \u2192 ${item.targetSession} (${MAX_RETRIES2} retries exhausted, reason: ${item.reason})`);
+        failed++;
+        continue;
+      }
+      remaining.push(item);
     }
-    remaining.push(item);
+    writeQueue(remaining);
+  } finally {
+    _draining = false;
   }
-  writeQueue(remaining);
   return { drained, failed };
 }
 function drainForSession(targetSession, sendKeys) {
@@ -12447,6 +12490,9 @@ function clearQueueForAgent(agentName) {
     logQueue(`CLEARED ${before - filtered.length} stale item(s) for ${agentName}`);
   }
 }
+function _resetDrainGuard() {
+  _draining = false;
+}
 function logQueue(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [queue] ${msg}
 `;
@@ -12458,13 +12504,14 @@ function logQueue(msg) {
   } catch {
   }
 }
-var QUEUE_PATH2, MAX_RETRIES2, TTL_MS2, INTERCOM_LOG;
+var QUEUE_PATH2, MAX_RETRIES2, TTL_MS2, _draining, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
     QUEUE_PATH2 = path22.join(os9.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES2 = 5;
     TTL_MS2 = 60 * 60 * 1e3;
+    _draining = false;
     INTERCOM_LOG = path22.join(os9.homedir(), ".exe-os", "intercom.log");
   }
 });
@@ -13139,7 +13186,13 @@ async function createReviewForCompletedTask(row, result3, _baseDir, now2) {
     taskFile
   });
   const originalPriority = String(row.priority).toLowerCase();
-  const autoApprove = originalPriority === "p2" && result3?.toLowerCase().includes("tests pass");
+  const resultLower = result3?.toLowerCase() ?? "";
+  const hasTestEvidence = (
+    // Vitest/Jest output patterns (hard to fake without actually running tests)
+    /\d+\s+pass(ed|ing)/.test(resultLower) || /test files?\s+\d+\s+passed/.test(resultLower) || /tests?\s+\d+\s+passed/.test(resultLower)
+  );
+  const hasNoFailures = !/fail(ed|ure|ing)|error/i.test(resultLower);
+  const autoApprove = originalPriority === "p2" && hasTestEvidence && hasNoFailures;
   if (!autoApprove) {
     try {
       const key = getSessionKey();
@@ -13147,6 +13200,13 @@ async function createReviewForCompletedTask(row, result3, _baseDir, now2) {
       if (exeSession) {
         sendIntercom(exeSession);
       }
+      if (reviewer && reviewer !== coordinatorName && reviewer !== exeSession) {
+        const { employeeSessionName: employeeSessionName2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
+        if (exeSession) {
+          const reviewerSession = employeeSessionName2(reviewer, exeSession);
+          sendIntercom(reviewerSession);
+        }
+      }
     } catch {
     }
   }
@@ -13277,18 +13337,31 @@ function acquireSpawnLock2(sessionName) {
     mkdirSync10(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync22(lockFile)) {
-    try {
-      const lock = JSON.parse(readFileSync15(lockFile, "utf8"));
-      const age = Date.now() - lock.timestamp;
-      if (isProcessAlive(lock.pid) && age < 6e4) {
-        return false;
-      }
-    } catch {
+  const lockData = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
+  const { openSync: openSync5, closeSync: closeSync5, writeSync } = __require("fs");
+  const { constants: constants2 } = __require("fs");
+  try {
+    const fd = openSync5(lockFile, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL, 420);
+    writeSync(fd, lockData);
+    closeSync5(fd);
+    return true;
+  } catch (err) {
+    if (err?.code !== "EEXIST") {
+      return true;
     }
   }
-  writeFileSync12(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
-  return true;
+  try {
+    const lock = JSON.parse(readFileSync15(lockFile, "utf8"));
+    const age = Date.now() - lock.timestamp;
+    if (isProcessAlive(lock.pid) && age < 6e4) {
+      return false;
+    }
+    writeFileSync12(lockFile, lockData);
+    return true;
+  } catch {
+    writeFileSync12(lockFile, lockData);
+    return true;
+  }
 }
 function releaseSpawnLock2(sessionName) {
   try {
@@ -13367,6 +13440,21 @@ function parseParentExe(sessionName, agentId) {
 function extractRootExe(name) {
   if (!name) return null;
   if (!name.includes("-")) return name;
+  try {
+    const roster = (init_employees(), __toCommonJS(employees_exports)).loadEmployeesSync();
+    if (roster.length > 0) {
+      const sortedNames = roster.map((e) => e.name).sort((a, b) => b.length - a.length);
+      for (const agentName of sortedNames) {
+        const escaped = agentName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`^${escaped}\\d*-(.+)$`);
+        const match = name.match(regex);
+        if (match) {
+          return extractRootExe(match[1]);
+        }
+      }
+    }
+  } catch {
+  }
   const parts = name.split("-").filter(Boolean);
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
@@ -13385,6 +13473,10 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 function getParentExe(sessionKey) {
   try {
     const data = JSON.parse(readFileSync15(path25.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    if (data.registeredAt) {
+      const age = Date.now() - new Date(data.registeredAt).getTime();
+      if (age > PARENT_EXE_CACHE_TTL_MS) return null;
+    }
     return data.parentExe || null;
   } catch {
     return null;
@@ -13933,7 +14025,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
-  let envPrefix = `EXE_SESSION=${exeSession} EXE_SESSION_NAME=${sessionName}`;
+  let envPrefix = `EXE_SESSION=${exeSession} EXE_SESSION_NAME=${sessionName} EXE_SESSION_START_ISO=${(/* @__PURE__ */ new Date()).toISOString()}`;
   if (ccProvider !== DEFAULT_PROVIDER) {
     const cfg = PROVIDER_TABLE[ccProvider];
     if (cfg?.apiKeyEnv) {
@@ -13968,10 +14060,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   if (!useExeAgent && !useCodex && !useOpencode && !useBinSymlink) {
     if (agentRtConfig.runtime === "claude" && agentRtConfig.model) {
-      let ccModel = agentRtConfig.model.replace(/(\d+)\.(\d+)/g, "$1-$2");
-      if (/claude-(opus|sonnet)-4-[6-9]/.test(ccModel) && !ccModel.includes("[1m]")) {
-        ccModel += "[1m]";
-      }
+      const { normalizeCcModelName: normalizeCcModelName2 } = (init_agent_config(), __toCommonJS(agent_config_exports));
+      const ccModel = normalizeCcModelName2(agentRtConfig.model);
       envPrefix = `${envPrefix} ANTHROPIC_MODEL=${ccModel}`;
     }
   }
@@ -14072,7 +14162,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   releaseSpawnLock2(sessionName);
   return { sessionName };
 }
-var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, VALID_SESSION_NAME, VERIFY_PANE_LINES, INTERCOM_DEBOUNCE_MS, CODEX_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
+var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, VALID_SESSION_NAME, PARENT_EXE_CACHE_TTL_MS, VERIFY_PANE_LINES, INTERCOM_DEBOUNCE_MS, CODEX_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
 var init_tmux_routing = __esm({
   "src/lib/tmux-routing.ts"() {
     "use strict";
@@ -14092,6 +14182,7 @@ var init_tmux_routing = __esm({
     SESSION_CACHE = path25.join(os11.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
+    PARENT_EXE_CACHE_TTL_MS = 4 * 60 * 60 * 1e3;
     VERIFY_PANE_LINES = 200;
     INTERCOM_DEBOUNCE_MS = 3e4;
     CODEX_DEBOUNCE_MS = 12e4;
@@ -14142,6 +14233,17 @@ var init_task_scope = __esm({
 });
 
 // src/lib/notifications.ts
+var notifications_exports = {};
+__export(notifications_exports, {
+  cleanupOldNotifications: () => cleanupOldNotifications,
+  formatNotifications: () => formatNotifications,
+  markAsRead: () => markAsRead,
+  markAsReadByTaskFile: () => markAsReadByTaskFile,
+  markDoneTaskNotificationsAsRead: () => markDoneTaskNotificationsAsRead,
+  migrateJsonNotifications: () => migrateJsonNotifications,
+  readUnreadNotifications: () => readUnreadNotifications,
+  writeNotification: () => writeNotification
+});
 import crypto7 from "crypto";
 import path26 from "path";
 import os12 from "os";
@@ -14178,6 +14280,52 @@ async function writeNotification(notification) {
 `);
   }
 }
+async function readUnreadNotifications(agentFilter2, sessionScope) {
+  try {
+    const client = getClient();
+    const conditions = ["read = 0"];
+    const args = [];
+    const scope = strictSessionScopeFilter(sessionScope);
+    if (agentFilter2) {
+      conditions.push("agent_id = ?");
+      args.push(agentFilter2);
+    }
+    const result3 = await client.execute({
+      sql: `SELECT id, agent_id, agent_role, event, project, summary, task_file, session_scope, created_at
+            FROM notifications
+            WHERE ${conditions.join(" AND ")}${scope.sql}
+            ORDER BY created_at ASC`,
+      args: [...args, ...scope.args]
+    });
+    return result3.rows.map((r) => ({
+      id: String(r.id),
+      agentId: String(r.agent_id),
+      agentRole: String(r.agent_role),
+      event: String(r.event),
+      project: String(r.project),
+      summary: String(r.summary),
+      taskFile: r.task_file ? String(r.task_file) : void 0,
+      sessionScope: r.session_scope == null ? null : String(r.session_scope),
+      timestamp: String(r.created_at),
+      read: false
+    }));
+  } catch {
+    return [];
+  }
+}
+async function markAsRead(ids, sessionScope) {
+  if (ids.length === 0) return;
+  try {
+    const client = getClient();
+    const placeholders = ids.map(() => "?").join(", ");
+    const scope = strictSessionScopeFilter(sessionScope);
+    await client.execute({
+      sql: `UPDATE notifications SET read = 1 WHERE id IN (${placeholders})${scope.sql}`,
+      args: [...ids, ...scope.args]
+    });
+  } catch {
+  }
+}
 async function markAsReadByTaskFile(taskFile, sessionScope) {
   try {
     const client = getClient();
@@ -14190,11 +14338,144 @@ async function markAsReadByTaskFile(taskFile, sessionScope) {
   } catch {
   }
 }
+async function cleanupOldNotifications(daysOld = CLEANUP_DAYS, sessionScope) {
+  try {
+    const client = getClient();
+    const cutoff = new Date(
+      Date.now() - daysOld * 24 * 60 * 60 * 1e3
+    ).toISOString();
+    const scope = strictSessionScopeFilter(sessionScope);
+    const result3 = await client.execute({
+      sql: `DELETE FROM notifications WHERE created_at < ?${scope.sql}`,
+      args: [cutoff, ...scope.args]
+    });
+    return result3.rowsAffected;
+  } catch {
+    return 0;
+  }
+}
+async function markDoneTaskNotificationsAsRead(sessionScope) {
+  try {
+    const client = getClient();
+    const scope = strictSessionScopeFilter(sessionScope);
+    const result3 = await client.execute({
+      sql: `UPDATE notifications SET read = 1
+            WHERE read = 0
+              AND task_file IS NOT NULL
+              ${scope.sql}
+              AND task_file IN (
+                SELECT task_file FROM tasks WHERE status = 'done'${scope.sql}
+              )`,
+      args: [...scope.args, ...scope.args]
+    });
+    return result3.rowsAffected;
+  } catch {
+    return 0;
+  }
+}
+function formatNotifications(notifications) {
+  if (notifications.length === 0) return "";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const n of notifications) {
+    const key = `${n.agentId}|${n.agentRole}`;
+    if (!grouped.has(key)) grouped.set(key, []);
+    grouped.get(key).push(n);
+  }
+  const lines = [];
+  lines.push(`## Notifications (${notifications.length} unread)
+`);
+  for (const [key, items] of grouped) {
+    const [agentId, agentRole] = key.split("|");
+    lines.push(`**${agentId}** (${agentRole}):`);
+    for (const item of items) {
+      const ago = formatTimeAgo(item.timestamp);
+      const icon = eventIcon(item.event);
+      lines.push(`- ${icon} ${item.summary} (${item.project}) \u2014 ${ago}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function migrateJsonNotifications() {
+  const base = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || path26.join(os12.homedir(), ".exe-os");
+  const notifDir = path26.join(base, "notifications");
+  if (!existsSync23(notifDir)) return 0;
+  let migrated = 0;
+  try {
+    const files = readdirSync6(notifDir).filter((f) => f.endsWith(".json"));
+    if (files.length === 0) return 0;
+    const client = getClient();
+    for (const file of files) {
+      try {
+        const filePath = path26.join(notifDir, file);
+        const data = JSON.parse(readFileSync16(filePath, "utf8"));
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, session_scope, read, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          args: [
+            crypto7.randomUUID(),
+            data.agentId ?? "unknown",
+            data.agentRole ?? "unknown",
+            data.event ?? "session_summary",
+            data.project ?? "unknown",
+            data.summary ?? "",
+            data.taskFile ?? null,
+            null,
+            data.read ? 1 : 0,
+            data.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+          ]
+        });
+        unlinkSync8(filePath);
+        migrated++;
+      } catch {
+      }
+    }
+    try {
+      const remaining = readdirSync6(notifDir);
+      if (remaining.length === 0) {
+        rmdirSync(notifDir);
+      }
+    } catch {
+    }
+  } catch {
+  }
+  return migrated;
+}
+function eventIcon(event) {
+  switch (event) {
+    case "task_complete":
+      return "Completed:";
+    case "task_needs_fix":
+      return "Needs fix:";
+    case "session_summary":
+      return "Session:";
+    case "error_spike":
+      return "Errors:";
+    case "orphan_task":
+      return "Orphan:";
+    case "subtasks_complete":
+      return "Subtasks done:";
+    case "capacity_relaunch":
+      return "Relaunched:";
+  }
+}
+function formatTimeAgo(timestamp) {
+  const diffMs = Date.now() - new Date(timestamp).getTime();
+  const mins = Math.floor(diffMs / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+var CLEANUP_DAYS;
 var init_notifications = __esm({
   "src/lib/notifications.ts"() {
     "use strict";
     init_database();
     init_task_scope();
+    CLEANUP_DAYS = 7;
   }
 });
 
@@ -15564,6 +15845,20 @@ async function updateTask(input) {
       notifyTaskDone();
     }
     await markTaskNotificationsRead(taskFile);
+    if (input.status === "needs_review" && !isCoordinator) {
+      try {
+        const { writeNotification: writeNotification2 } = await Promise.resolve().then(() => (init_notifications(), notifications_exports));
+        await writeNotification2({
+          agentId: String(row.assigned_to),
+          agentRole: String(row.assigned_to),
+          event: "task_complete",
+          project: String(row.project_name),
+          summary: `"${String(row.title)}" is ready for review`,
+          taskFile
+        });
+      } catch {
+      }
+    }
     if (input.status === "done" || input.status === "closed") {
       try {
         await cascadeUnblock(taskId, input.baseDir, now2);
@@ -22316,6 +22611,7 @@ __export(daemon_orchestration_exports, {
   REVIEW_NUDGE_COOLDOWN_MS: () => REVIEW_NUDGE_COOLDOWN_MS,
   SESSION_CONTEXT_THRESHOLD_PCT: () => SESSION_CONTEXT_THRESHOLD_PCT,
   SESSION_TTL_HOURS: () => SESSION_TTL_HOURS,
+  STUCK_TASK_GRACE_MS: () => STUCK_TASK_GRACE_MS,
   _resetAutoWakeState: () => _resetAutoWakeState,
   checkSessionTTL: () => checkSessionTTL,
   classifyTtlKillReason: () => classifyTtlKillReason,
@@ -22325,12 +22621,14 @@ __export(daemon_orchestration_exports, {
   createOrphanReaperRealDeps: () => createOrphanReaperRealDeps,
   createReviewNudgeRealDeps: () => createReviewNudgeRealDeps,
   createSessionTTLRealDeps: () => createSessionTTLRealDeps,
+  createStuckTaskRealDeps: () => createStuckTaskRealDeps,
   loadNudgeState: () => loadNudgeState,
   pollIdleEmployees: () => pollIdleEmployees,
   pollIdleKill: () => pollIdleKill,
   pollOrphanedTasks: () => pollOrphanedTasks,
   pollReviewNudge: () => pollReviewNudge,
   reapOrphanedMcpProcesses: () => reapOrphanedMcpProcesses,
+  releaseStuckTasks: () => releaseStuckTasks,
   saveNudgeState: () => saveNudgeState,
   shouldAutoWake: () => shouldAutoWake,
   shouldKillIdleSession: () => shouldKillIdleSession,
@@ -22818,6 +23116,102 @@ async function pollOrphanedTasks(deps, nowMs = Date.now()) {
   }
   return woken;
 }
+async function releaseStuckTasks(deps, nowMs = Date.now()) {
+  let liveSessions;
+  try {
+    liveSessions = deps.listTmuxSessions();
+  } catch {
+    return [];
+  }
+  const liveAgents = /* @__PURE__ */ new Set();
+  for (const session of liveSessions) {
+    const agent = deps.parseAgentFromSession(session);
+    if (agent) liveAgents.add(agent);
+  }
+  for (const session of liveSessions) {
+    if (isExeSession(session)) liveAgents.add(session);
+  }
+  let tasks;
+  try {
+    tasks = await deps.queryInProgressTasks();
+  } catch {
+    return [];
+  }
+  const released = [];
+  for (const t of tasks) {
+    if (liveAgents.has(t.agentId)) continue;
+    const updatedMs = new Date(t.updatedAt).getTime();
+    if (isNaN(updatedMs) || nowMs - updatedMs < STUCK_TASK_GRACE_MS) continue;
+    const ageMinutes = Math.round((nowMs - updatedMs) / 6e4);
+    const reason = `[auto-release] Agent "${t.agentId}" session is dead and task has been in_progress for ${ageMinutes}m with no update. Marked blocked for triage.`;
+    try {
+      await deps.markTaskBlocked(t.taskId, reason);
+      released.push(t.taskId);
+      process.stderr.write(
+        `[stuck-release] Task ${t.taskId} (${t.agentId}) \u2014 in_progress for ${ageMinutes}m, agent dead \u2192 blocked
+`
+      );
+      if (deps.notifyOrphan) {
+        try {
+          await deps.notifyOrphan(t.taskId, t.agentId);
+        } catch {
+        }
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[stuck-release] Failed to release ${t.taskId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return released;
+}
+function createStuckTaskRealDeps(getClient2) {
+  return {
+    listTmuxSessions: () => {
+      const { listTmuxSessions: listTmuxSessions2 } = (init_tmux_status(), __toCommonJS(tmux_status_exports));
+      return listTmuxSessions2();
+    },
+    queryInProgressTasks: async () => {
+      const client = getClient2();
+      const result3 = await client.execute({
+        sql: `SELECT id, assigned_to, session_scope, updated_at FROM tasks
+              WHERE status = 'in_progress'
+              ORDER BY updated_at ASC`,
+        args: []
+      });
+      return result3.rows.map((r) => ({
+        taskId: String(r.id),
+        agentId: String(r.assigned_to),
+        sessionScope: r.session_scope ? String(r.session_scope) : null,
+        updatedAt: String(r.updated_at)
+      }));
+    },
+    markTaskBlocked: async (taskId, reason) => {
+      const client = getClient2();
+      await client.execute({
+        sql: `UPDATE tasks SET status = 'blocked', result = ?, updated_at = ? WHERE id = ?`,
+        args: [reason, (/* @__PURE__ */ new Date()).toISOString(), taskId]
+      });
+    },
+    parseAgentFromSession: (sessionName) => {
+      const { baseAgentName: baseAgentName2 } = (init_employees(), __toCommonJS(employees_exports));
+      if (!sessionName.includes("-")) return null;
+      const agentPart = sessionName.split("-")[0];
+      return baseAgentName2(agentPart);
+    },
+    notifyOrphan: async (taskId, agentId) => {
+      const { writeNotification: writeNotification2 } = (init_notifications(), __toCommonJS(notifications_exports));
+      await writeNotification2({
+        agentId,
+        agentRole: "employee",
+        event: "orphan_task",
+        project: "",
+        summary: `Agent "${agentId}" session died \u2014 task ${taskId.slice(0, 8)} auto-released to blocked for triage`
+      });
+    }
+  };
+}
 function createAutoWakeRealDeps(getClient2, projectDir) {
   return {
     listTmuxSessions: () => {
@@ -22910,7 +23304,7 @@ function createOrphanReaperRealDeps() {
     selfPid: process.pid
   };
 }
-var IDLE_NUDGE_DEDUP_MS, SESSION_TTL_HOURS, SESSION_CONTEXT_THRESHOLD_PCT, IDLE_KILL_INTERCOM_ACK_WINDOW_MS, REVIEW_NUDGE_COOLDOWN_MS, NUDGE_STATE_PATH, AUTO_WAKE_COOLDOWN_MS, AUTO_WAKE_MAX_RETRIES, _autoWakeLastSpawn, _autoWakeTaskRetries, ORPHAN_SIGKILL_DELAY_MS, ORPHAN_PATTERNS;
+var IDLE_NUDGE_DEDUP_MS, SESSION_TTL_HOURS, SESSION_CONTEXT_THRESHOLD_PCT, IDLE_KILL_INTERCOM_ACK_WINDOW_MS, REVIEW_NUDGE_COOLDOWN_MS, NUDGE_STATE_PATH, AUTO_WAKE_COOLDOWN_MS, AUTO_WAKE_MAX_RETRIES, _autoWakeLastSpawn, _autoWakeTaskRetries, STUCK_TASK_GRACE_MS, ORPHAN_SIGKILL_DELAY_MS, ORPHAN_PATTERNS;
 var init_daemon_orchestration = __esm({
   "src/lib/daemon-orchestration.ts"() {
     "use strict";
@@ -22927,6 +23321,7 @@ var init_daemon_orchestration = __esm({
     AUTO_WAKE_MAX_RETRIES = 3;
     _autoWakeLastSpawn = /* @__PURE__ */ new Map();
     _autoWakeTaskRetries = /* @__PURE__ */ new Map();
+    STUCK_TASK_GRACE_MS = 5 * 60 * 1e3;
     ORPHAN_SIGKILL_DELAY_MS = 5e3;
     ORPHAN_PATTERNS = [
       "exe-os/dist/mcp/server.js",
@@ -23057,7 +23452,21 @@ function tryAcquireWorkerSlot() {
     for (const f of files) {
       if (!f.endsWith(".pid")) continue;
       if (f.startsWith("res-")) {
-        alive++;
+        const resParts = f.replace(".pid", "").split("-");
+        const resPid = parseInt(resParts[1] ?? "", 10);
+        if (!isNaN(resPid) && resPid > 0) {
+          try {
+            process.kill(resPid, 0);
+            alive++;
+          } catch {
+            try {
+              unlinkSync10(path35.join(WORKER_PID_DIR, f));
+            } catch {
+            }
+          }
+        } else {
+          alive++;
+        }
         continue;
       }
       const dashIdx = f.lastIndexOf("-");
@@ -25089,6 +25498,7 @@ __export(cloud_sync_exports, {
   markCloudReuploadRequired: () => markCloudReuploadRequired,
   mergeConfig: () => mergeConfig,
   mergeRosterFromRemote: () => mergeRosterFromRemote,
+  migrateEndpoint: () => migrateEndpoint,
   pushToPostgres: () => pushToPostgres,
   recordRosterDeletion: () => recordRosterDeletion
 });
@@ -25259,6 +25669,15 @@ async function fetchWithRetry(url, init) {
   }
   throw lastError;
 }
+function migrateEndpoint(endpoint2) {
+  if (endpoint2 === "https://askexe.com/cloud" || endpoint2 === "https://askexe.com/cloud/") {
+    process.stderr.write(
+      "[cloud-sync] Auto-migrating endpoint from askexe.com/cloud to cloud.askexe.com (bypasses Cloudflare WAF for datacenter IPs)\n"
+    );
+    return "https://cloud.askexe.com";
+  }
+  return endpoint2;
+}
 function assertSecureEndpoint(endpoint2) {
   if (endpoint2.startsWith("https://")) return;
   if (endpoint2.startsWith("http://")) {
@@ -25396,6 +25815,7 @@ async function markCloudReuploadRequired(client = getClient()) {
   await client.execute("INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('cloud_reupload_required', '1')");
 }
 async function cloudSync(config2) {
+  config2 = { ...config2, endpoint: migrateEndpoint(config2.endpoint) };
   if (!isSyncCryptoInitialized()) {
     try {
       const { getMasterKey: getMasterKey2 } = await Promise.resolve().then(() => (init_keychain(), keychain_exports));
@@ -37163,7 +37583,25 @@ async function startMcpHttpServer() {
       }
       const agentId = req.headers["x-agent-id"] || "default";
       const agentRole = req.headers["x-agent-role"] || "employee";
-      const sessionHint = req.headers["x-exe-session"] || "";
+      let sessionHint = req.headers["x-exe-session"] || "";
+      if (sessionHint.includes("$(") || sessionHint.includes("#{") || sessionHint.includes("tmux")) {
+        sessionHint = "";
+      }
+      if (!sessionHint) {
+        try {
+          const { getTransport: getTransport2 } = (init_transport(), __toCommonJS(transport_exports));
+          const transport2 = getTransport2();
+          const liveSessions = transport2.listSessions();
+          const agentSessions = liveSessions.filter((s) => s.startsWith(agentId + "-"));
+          if (agentSessions.length === 1) {
+            sessionHint = agentSessions[0];
+          } else {
+            const roots = liveSessions.filter((s) => !s.includes("-") && /^[a-z]+\d*$/.test(s));
+            if (roots.length === 1) sessionHint = roots[0];
+          }
+        } catch {
+        }
+      }
       const runtime = inferMcpRuntime({
         runtimeHeader: req.headers["x-agent-runtime"] || req.headers["x-runtime"],
         userAgent: req.headers["user-agent"],
@@ -37792,10 +38230,10 @@ function startIntercomQueueDrain() {
             const rtConfig = getAgentRuntime2(agentName);
             const nudgeMsg = "You have pending notifications. Run list_tasks to check for assigned work.";
             if (rtConfig.runtime === "codex" || rtConfig.runtime === "opencode") {
-              transport.sendKeys(session, nudgeMsg);
-              try {
-                __require("child_process").execSync(`tmux send-keys -t ${session} Tab`, { timeout: 2e3 });
-              } catch {
+              if (transport.sendKeysLiteral) {
+                transport.sendKeysLiteral(session, nudgeMsg);
+              } else {
+                transport.sendKeys(session, nudgeMsg);
               }
             } else {
               transport.sendKeys(session, nudgeMsg);
@@ -37871,6 +38309,31 @@ function startAutoWake() {
   process.stderr.write(`[exed] Auto-wake started (every ${AUTO_WAKE_INTERVAL_MS / 1e3}s)
 `);
 }
+var STUCK_TASK_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
+function startStuckTaskRelease() {
+  const tick = async () => {
+    fired("stuck_task_release");
+    if (!await ensureStoreForPolling()) return;
+    try {
+      const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+      const { releaseStuckTasks: releaseStuckTasks2, createStuckTaskRealDeps: createStuckTaskRealDeps2 } = await Promise.resolve().then(() => (init_daemon_orchestration(), daemon_orchestration_exports));
+      const deps = createStuckTaskRealDeps2(getClient2);
+      const released = await releaseStuckTasks2(deps);
+      if (released.length > 0) {
+        acted("stuck_task_release");
+        process.stderr.write(`[exed] Stuck-release: ${released.length} task(s) moved to blocked
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`[exed] Stuck-release error: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+  };
+  const timer = setInterval(() => void tick(), STUCK_TASK_CHECK_INTERVAL_MS);
+  timer.unref();
+  process.stderr.write(`[exed] Stuck-task release started (every ${STUCK_TASK_CHECK_INTERVAL_MS / 1e3}s)
+`);
+}
 var TOTAL_MEM_GB = os24.totalmem() / 1024 ** 3;
 var RSS_WARN_BYTES = Number(process.env.EXE_RSS_WARN_MB) * 1024 * 1024 || (TOTAL_MEM_GB >= 64 ? 6 * 1024 ** 3 : TOTAL_MEM_GB >= 32 ? 4 * 1024 ** 3 : TOTAL_MEM_GB >= 16 ? 2.5 * 1024 ** 3 : 1.5 * 1024 ** 3);
 var RSS_RESTART_BYTES = Number(process.env.EXE_RSS_RESTART_MB) * 1024 * 1024 || (TOTAL_MEM_GB >= 64 ? 8 * 1024 ** 3 : TOTAL_MEM_GB >= 32 ? 6 * 1024 ** 3 : TOTAL_MEM_GB >= 16 ? 4 * 1024 ** 3 : 3 * 1024 ** 3);
@@ -38211,6 +38674,7 @@ try {
   startOrphanReaper();
   startAgentStats();
   startAutoWake();
+  startStuckTaskRelease();
   startGraphExtraction();
   startMemoryQueueDrain();
   startIntercomQueueDrain();