@askexenow/exe-os 0.9.322 → 0.9.324

package/dist/{chunk-PLBDXCYZ.js → chunk-KUJGADX6.js}

@@ -1,14 +1,18 @@
 import {
   ensureAgentSymlink
-} from "./chunk-HWC5W34K.js";
+} from "./chunk-7PLMYXPG.js";
 import {
   ensureWorktree,
   getGitRoot,
   isWorktreeDirty
-} from "./chunk-KLG53B63.js";
+} from "./chunk-KJOQLNX2.js";
 import {
-  queueIntercom
-} from "./chunk-4FVVJ7ME.js";
+  incrementSkillSuccess
+} from "./chunk-Y2KBHLEO.js";
+import {
+  reviewSignalPath,
+  taskSignalDir
+} from "./chunk-EIKATSE4.js";
 import {
   LEASE_MINUTES,
   leaseExpiryIso
@@ -18,8 +22,9 @@ import {
   serializeMessage
 } from "./chunk-4JERP7NT.js";
 import {
+  listSessions,
   registerSession
-} from "./chunk-ABGDTMKC.js";
+} from "./chunk-JRD7ARQ6.js";
 import {
   listTmuxSessions
 } from "./chunk-SSTLTIF3.js";
@@ -28,23 +33,26 @@ import {
 } from "./chunk-RMOBQ6A5.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-HV5CUDOE.js";
+} from "./chunk-F6TJIWN5.js";
 import {
   assertRuntimeModelCompatible,
   getAgentRuntime,
   normalizeCcModelName,
   resolveSpawnRuntimeConfig
-} from "./chunk-QVFJCFNM.js";
+} from "./chunk-FROUDYRT.js";
 import {
   RUNTIME_TABLE
 } from "./chunk-NGP6LSV2.js";
 import {
   PlanLimitError,
   assertEmployeeLimitSync
-} from "./chunk-EPBB2OD3.js";
+} from "./chunk-BB5IKY7B.js";
 import {
   getSessionKey
 } from "./chunk-CVYC6DUW.js";
+import {
+  writeMemoryViaDaemon
+} from "./chunk-GIFDGNIL.js";
 import {
   getProjectName
 } from "./chunk-OPU3NYOO.js";
@@ -66,10 +74,10 @@ import {
   loadEmployees,
   loadEmployeesSync,
   offloadReadIfMain
-} from "./chunk-XLNF3CIO.js";
+} from "./chunk-QGOMYIVT.js";
 import {
   loadDeviceId
-} from "./chunk-VY7345RO.js";
+} from "./chunk-BMSAJ2IH.js";
 import {
   EXE_AI_DIR
 } from "./chunk-7Y5UDEVM.js";
@@ -81,9 +89,9 @@ import {
 // src/lib/tmux-routing.ts
 import { execFile, execFileSync as execFileSync2 } from "child_process";
 import { promisify } from "util";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync7, appendFileSync as appendFileSync2, openSync, closeSync, writeSync, renameSync as renameSync2, constants, statSync as statSync2 } from "fs";
-import path7 from "path";
-import os5 from "os";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, existsSync as existsSync9, appendFileSync as appendFileSync3, openSync as openSync2, closeSync as closeSync2, writeSync as writeSync2, renameSync as renameSync3, constants as constants2, statSync as statSync4 } from "fs";
+import path8 from "path";
+import os6 from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/cc-help-cache.ts
@@ -142,56 +150,491 @@ function _resetCcHelpCache() {
 function _resetCcAgentSupportCache() {
   _resetCcHelpCache();
 }
-function claudeSupportsAgentFlag() {
-  return /(^|\s)--agent(\b|=)/.test(getCcHelpOutputCached());
+function claudeSupportsAgentFlag() {
+  return /(^|\s)--agent(\b|=)/.test(getCcHelpOutputCached());
+}
+
+// src/lib/provider-table.ts
+var PROVIDER_TABLE = {
+  opencode: {
+    baseUrl: "https://opencode.ai/zen/go",
+    apiKeyEnv: "OPENCODE_API_KEY",
+    defaultModel: "kimi-k2.7-code"
+  }
+};
+var DEFAULT_PROVIDER = "default";
+function detectActiveProvider(env = process.env) {
+  const baseUrl = env.ANTHROPIC_BASE_URL;
+  if (!baseUrl) return DEFAULT_PROVIDER;
+  for (const [name, cfg] of Object.entries(PROVIDER_TABLE)) {
+    if (cfg.baseUrl === baseUrl) return name;
+  }
+  return DEFAULT_PROVIDER;
+}
+
+// src/lib/intercom-queue.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync, existsSync as existsSync3, mkdirSync as mkdirSync2, appendFileSync, openSync, closeSync, writeSync, unlinkSync as unlinkSync2, constants, statSync } from "fs";
+import path3 from "path";
+import os3 from "os";
+
+// src/lib/notifications.ts
+import crypto from "crypto";
+import path2 from "path";
+import os2 from "os";
+import {
+  readFileSync as readFileSync2,
+  readdirSync,
+  unlinkSync,
+  existsSync as existsSync2,
+  rmdirSync
+} from "fs";
+var CLEANUP_DAYS = 7;
+async function writeNotification(notification) {
+  try {
+    const client = getClient();
+    const id = crypto.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sessionScope = notification.sessionScope === void 0 ? getCurrentSessionScope() : notification.sessionScope;
+    await client.execute({
+      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, session_scope, read, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?)`,
+      args: [
+        id,
+        notification.agentId,
+        notification.agentRole,
+        notification.event,
+        notification.project,
+        notification.summary,
+        notification.taskFile ?? null,
+        sessionScope,
+        now
+      ]
+    });
+  } catch (err) {
+    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+async function readUnreadNotifications(agentFilter, sessionScope) {
+  try {
+    const client = getClient();
+    const conditions = ["read = 0"];
+    const args = [];
+    const scope = strictSessionScopeFilter(sessionScope ?? void 0);
+    if (agentFilter) {
+      conditions.push("agent_id = ?");
+      args.push(agentFilter);
+    }
+    const result = 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 result.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 ?? void 0);
+    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();
+    const scope = strictSessionScopeFilter(sessionScope);
+    await client.execute({
+      sql: `UPDATE notifications SET read = 1
+            WHERE task_file = ? AND read = 0${scope.sql}`,
+      args: [taskFile, ...scope.args]
+    });
+  } 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 ?? void 0);
+    const result = await client.execute({
+      sql: `DELETE FROM notifications WHERE created_at < ?${scope.sql}`,
+      args: [cutoff, ...scope.args]
+    });
+    return result.rowsAffected;
+  } catch {
+    return 0;
+  }
+}
+async function markDoneTaskNotificationsAsRead(sessionScope) {
+  try {
+    const client = getClient();
+    const scope = strictSessionScopeFilter(sessionScope ?? void 0);
+    const result = 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 IN ('done', 'closed', 'cancelled')
+              )`,
+      args: [...scope.args]
+    });
+    return result.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 || path2.join(os2.homedir(), ".exe-os");
+  const notifDir = path2.join(base, "notifications");
+  if (!existsSync2(notifDir)) return 0;
+  let migrated = 0;
+  try {
+    const files = readdirSync(notifDir).filter((f) => f.endsWith(".json"));
+    if (files.length === 0) return 0;
+    const client = getClient();
+    for (const file of files) {
+      try {
+        const filePath = path2.join(notifDir, file);
+        const data = JSON.parse(readFileSync2(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: [
+            crypto.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()
+          ]
+        });
+        unlinkSync(filePath);
+        migrated++;
+      } catch {
+      }
+    }
+    try {
+      const remaining = readdirSync(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 "task_group_barrier":
+      return "Task group:";
+    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`;
+}
+
+// src/lib/intercom-queue.ts
+var QUEUE_PATH = path3.join(os3.homedir(), ".exe-os", "intercom-queue.json");
+var QUEUE_LOCK_PATH = `${QUEUE_PATH}.lock`;
+var MAX_RETRIES = 10;
+var TTL_MS = 60 * 60 * 1e3;
+function ensureDir() {
+  const dir = path3.dirname(QUEUE_PATH);
+  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
+}
+function acquireQueueLock() {
+  ensureDir();
+  const data = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
+  const deadline = Date.now() + 250;
+  while (Date.now() < deadline) {
+    try {
+      const fd = openSync(QUEUE_LOCK_PATH, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 384);
+      writeSync(fd, data);
+      closeSync(fd);
+      return true;
+    } catch (err) {
+      if (err.code !== "EEXIST") return false;
+      try {
+        const lock = JSON.parse(readFileSync3(QUEUE_LOCK_PATH, "utf8"));
+        if (Date.now() - Number(lock.timestamp ?? 0) > 3e4) unlinkSync2(QUEUE_LOCK_PATH);
+      } catch {
+        try {
+          unlinkSync2(QUEUE_LOCK_PATH);
+        } catch {
+        }
+      }
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+  }
+  return false;
+}
+function releaseQueueLock() {
+  try {
+    unlinkSync2(QUEUE_LOCK_PATH);
+  } catch {
+  }
+}
+function readQueue() {
+  try {
+    if (!existsSync3(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync3(QUEUE_PATH, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function writeQueue(queue) {
+  ensureDir();
+  const tmp = `${QUEUE_PATH}.tmp`;
+  writeFileSync2(tmp, JSON.stringify(queue, null, 2), { mode: 384 });
+  renameSync(tmp, QUEUE_PATH);
+}
+function queueIntercom(targetSession, reason, intercomReason = "nudge") {
+  if (!acquireQueueLock()) return;
+  try {
+    const queue = readQueue();
+    const existing = queue.find((q) => q.targetSession === targetSession);
+    if (existing) {
+      existing.attempts++;
+      existing.queuedAt = (/* @__PURE__ */ new Date()).toISOString();
+      existing.reason = reason;
+      existing.intercomReason = intercomReason;
+    } else {
+      queue.push({
+        targetSession,
+        queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        attempts: 0,
+        reason,
+        intercomReason
+      });
+    }
+    writeQueue(queue);
+  } finally {
+    releaseQueueLock();
+  }
+}
+function notifyExpiredIntercom(item) {
+  const dashIdx = item.targetSession.indexOf("-");
+  const agentId = (dashIdx > 0 ? item.targetSession.slice(0, dashIdx) : item.targetSession).replace(/\d+$/, "") || item.targetSession;
+  const sessionScope = dashIdx > 0 ? item.targetSession.slice(dashIdx + 1) : item.targetSession;
+  void writeNotification({
+    agentId,
+    agentRole: "employee",
+    event: "error_spike",
+    project: "",
+    summary: `Intercom to ${item.targetSession} expired undelivered after 1h (${item.attempts} attempts, reason: ${item.reason}). Dropped from the retry queue \u2014 check the target session and re-send if still relevant.`,
+    sessionScope
+  });
+}
+var _draining = false;
+function drainQueue(isSessionBusy2, sendKeys, notifyExpiry = notifyExpiredIntercom) {
+  if (_draining) {
+    logQueue("SKIP_DRAIN \u2014 previous drain still running (possible tmux hang)");
+    return { drained: 0, failed: 0 };
+  }
+  _draining = true;
+  const remaining = [];
+  let drained = 0;
+  let failed = 0;
+  let lockAcquired = false;
+  try {
+    lockAcquired = acquireQueueLock();
+    if (!lockAcquired) return { drained: 0, failed: 0 };
+    const queue = readQueue();
+    if (queue.length === 0) return { drained: 0, failed: 0 };
+    for (const item of queue) {
+      const age = Date.now() - new Date(item.queuedAt).getTime();
+      if (age > TTL_MS) {
+        logQueue(`EXPIRED \u2192 ${item.targetSession} (${Math.round(age / 6e4)}min old, reason: ${item.reason})`);
+        try {
+          notifyExpiry(item);
+        } catch (err) {
+          logQueue(`EXPIRY_NOTIFY_FAILED \u2192 ${item.targetSession}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        failed++;
+        continue;
+      }
+      try {
+        if (!isSessionBusy2(item.targetSession)) {
+          const success = sendKeys(item.targetSession, item);
+          if (success) {
+            logQueue(`DRAINED \u2192 ${item.targetSession} (after ${item.attempts} retries)`);
+            drained++;
+            continue;
+          }
+        }
+      } catch {
+      }
+      item.attempts++;
+      if (item.attempts >= MAX_RETRIES) {
+        logQueue(`PENDING \u2192 ${item.targetSession} (${MAX_RETRIES} retries exhausted, keeping queued, reason: ${item.reason})`);
+        item.attempts = MAX_RETRIES;
+        remaining.push(item);
+        failed++;
+        continue;
+      }
+      remaining.push(item);
+    }
+    writeQueue(remaining);
+  } finally {
+    if (lockAcquired) releaseQueueLock();
+    _draining = false;
+  }
+  return { drained, failed };
+}
+function drainForSession(targetSession, sendKeys) {
+  if (!acquireQueueLock()) return false;
+  try {
+    const queue = readQueue();
+    const match = queue.findIndex((q) => q.targetSession === targetSession);
+    if (match < 0) return false;
+    const item = queue[match];
+    const success = sendKeys(targetSession, item);
+    if (success) {
+      queue.splice(match, 1);
+      writeQueue(queue);
+      logQueue(`DRAINED \u2192 ${targetSession} (prompt-submit trigger)`);
+      return true;
+    }
+    return false;
+  } finally {
+    releaseQueueLock();
+  }
 }
-
-// src/lib/provider-table.ts
-var PROVIDER_TABLE = {
-  opencode: {
-    baseUrl: "https://opencode.ai/zen/go",
-    apiKeyEnv: "OPENCODE_API_KEY",
-    defaultModel: "kimi-k2.7-code"
+function clearQueueForAgent(agentName) {
+  if (!acquireQueueLock()) return;
+  try {
+    const queue = readQueue();
+    const before = queue.length;
+    const filtered = queue.filter((q) => !q.targetSession.startsWith(`${agentName}-`));
+    if (filtered.length < before) {
+      writeQueue(filtered);
+      logQueue(`CLEARED ${before - filtered.length} stale item(s) for ${agentName}`);
+    }
+  } finally {
+    releaseQueueLock();
   }
-};
-var DEFAULT_PROVIDER = "default";
-function detectActiveProvider(env = process.env) {
-  const baseUrl = env.ANTHROPIC_BASE_URL;
-  if (!baseUrl) return DEFAULT_PROVIDER;
-  for (const [name, cfg] of Object.entries(PROVIDER_TABLE)) {
-    if (cfg.baseUrl === baseUrl) return name;
+}
+function _resetDrainGuard() {
+  _draining = false;
+}
+var INTERCOM_LOG = path3.join(os3.homedir(), ".exe-os", "intercom.log");
+var INTERCOM_LOG_MAX_BYTES = 1024 * 1024;
+function logQueue(msg) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [queue] ${msg}
+`;
+  process.stderr.write(`[intercom-queue] ${msg}
+`);
+  try {
+    if (existsSync3(INTERCOM_LOG) && statSync(INTERCOM_LOG).size > INTERCOM_LOG_MAX_BYTES) {
+      renameSync(INTERCOM_LOG, `${INTERCOM_LOG}.1`);
+    }
+    appendFileSync(INTERCOM_LOG, line);
+  } catch {
   }
-  return DEFAULT_PROVIDER;
 }
 
 // src/lib/tmux-routing.ts
-import { unlinkSync as unlinkSync3 } from "fs";
+import { unlinkSync as unlinkSync4 } from "fs";
 
 // src/lib/routing-log.ts
-import { appendFileSync, mkdirSync as mkdirSync2, existsSync as existsSync2, statSync, renameSync } from "fs";
-import path2 from "path";
-import os2 from "os";
-var LOG_DIR = path2.join(os2.homedir(), ".exe-os", "logs");
-var LOG_FILE = path2.join(LOG_DIR, "routing.log");
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync4, statSync as statSync2, renameSync as renameSync2 } from "fs";
+import path4 from "path";
+import os4 from "os";
+var LOG_DIR = path4.join(os4.homedir(), ".exe-os", "logs");
+var LOG_FILE = path4.join(LOG_DIR, "routing.log");
 var dirChecked = false;
 var MAX_LOG_BYTES = 5 * 1024 * 1024;
-function ensureDir() {
+function ensureDir2() {
   if (dirChecked) return;
-  if (!existsSync2(LOG_DIR)) mkdirSync2(LOG_DIR, { recursive: true });
+  if (!existsSync4(LOG_DIR)) mkdirSync3(LOG_DIR, { recursive: true });
   dirChecked = true;
 }
 function rotateIfNeeded() {
   try {
-    const stat = statSync(LOG_FILE);
+    const stat = statSync2(LOG_FILE);
     if (stat.size > MAX_LOG_BYTES) {
-      renameSync(LOG_FILE, LOG_FILE + ".1");
+      renameSync2(LOG_FILE, LOG_FILE + ".1");
     }
   } catch {
   }
 }
 function logRouting(event) {
   try {
-    ensureDir();
+    ensureDir2();
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     const flag = event.mismatch ? " \u26A0\uFE0F MISMATCH" : "";
     const taskRef = event.taskId ? ` task=${event.taskId.slice(0, 8)}` : "";
@@ -206,7 +649,7 @@ function logRouting(event) {
     const line = `[${ts}] ${event.event} | ${event.caller}${taskRef}${assignee} | result=${event.result ?? "null"}${flag} | ${details}
 `;
     rotateIfNeeded();
-    appendFileSync(LOG_FILE, line);
+    appendFileSync2(LOG_FILE, line);
   } catch {
   }
 }
@@ -275,16 +718,104 @@ function logTaskDispatch(opts) {
 }
 
 // src/lib/tasks-review.ts
-import path5 from "path";
-import { existsSync as existsSync5, readdirSync as readdirSync2, unlinkSync as unlinkSync2 } from "fs";
+import path6 from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, statSync as statSync3, unlinkSync as unlinkSync3 } from "fs";
+import { homedir as homedir2 } from "os";
 
 // src/lib/tasks-crud.ts
-import crypto from "crypto";
-import path3 from "path";
-import os3 from "os";
+import crypto2 from "crypto";
+import path5 from "path";
+import os5 from "os";
 import { execSync as execSync2 } from "child_process";
 import { mkdir, writeFile, appendFile } from "fs/promises";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
+
+// src/lib/completion-nudge-dedup.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+var COMPLETION_NUDGE_COOLDOWN_MS = Number(process.env.EXE_COMPLETION_NUDGE_COOLDOWN_MS) || 6 * 60 * 60 * 1e3;
+var STALE_REVIEW_ESCALATION_COOLDOWN_MS = Number(process.env.EXE_STALE_REVIEW_ESCALATION_COOLDOWN_MS) || 7 * 24 * 60 * 60 * 1e3;
+var completionLedger = {
+  path: join(homedir(), ".exe-os", "completion-nudge-state.json"),
+  cooldownMs: () => COMPLETION_NUDGE_COOLDOWN_MS,
+  state: null
+};
+var escalationLedger = {
+  path: join(homedir(), ".exe-os", "stale-review-escalation-state.json"),
+  cooldownMs: () => STALE_REVIEW_ESCALATION_COOLDOWN_MS,
+  state: null
+};
+function load(ledger) {
+  if (ledger.state) return ledger.state;
+  ledger.state = {};
+  try {
+    if (existsSync5(ledger.path)) {
+      const raw = JSON.parse(readFileSync4(ledger.path, "utf8"));
+      if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        for (const [k, v] of Object.entries(raw)) {
+          if (typeof v === "number") ledger.state[k] = v;
+        }
+      }
+    }
+  } catch {
+  }
+  return ledger.state;
+}
+function persist(ledger, state) {
+  try {
+    mkdirSync4(dirname(ledger.path), { recursive: true });
+    writeFileSync3(ledger.path, JSON.stringify(state), "utf8");
+  } catch {
+  }
+}
+function prune(ledger, state, now) {
+  const cutoff = now - 2 * ledger.cooldownMs();
+  for (const [k, ts] of Object.entries(state)) {
+    if (ts < cutoff) delete state[k];
+  }
+}
+function claim(ledger, taskId, now) {
+  const state = load(ledger);
+  const last = state[taskId] ?? 0;
+  if (now - last < ledger.cooldownMs()) return false;
+  state[taskId] = now;
+  prune(ledger, state, now);
+  persist(ledger, state);
+  return true;
+}
+function clear(ledger, taskId) {
+  const state = load(ledger);
+  if (state[taskId] !== void 0) {
+    delete state[taskId];
+    persist(ledger, state);
+  }
+}
+function claimCompletionNudge(taskId, now = Date.now()) {
+  if (!taskId) return true;
+  return claim(completionLedger, taskId, now);
+}
+function recordCompletionNudge(taskId, now = Date.now()) {
+  if (!taskId) return;
+  const state = load(completionLedger);
+  state[taskId] = now;
+  prune(completionLedger, state, now);
+  persist(completionLedger, state);
+}
+function clearCompletionNudge(taskId) {
+  if (!taskId) return;
+  clear(completionLedger, taskId);
+}
+function claimStaleReviewEscalation(taskId, now = Date.now()) {
+  if (!taskId) return false;
+  return claim(escalationLedger, taskId, now);
+}
+function clearStaleReviewEscalation(taskId) {
+  if (!taskId) return;
+  clear(escalationLedger, taskId);
+}
+
+// src/lib/tasks-crud.ts
 var DEFAULT_TASK_PRIORITY = "p1";
 function normalizeTaskPriority(value) {
   const v = typeof value === "string" ? value.trim().toLowerCase() : "";
@@ -452,8 +983,18 @@ function buildKeywordIndex() {
   return idx;
 }
 var KEYWORD_INDEX = buildKeywordIndex();
-function checkLaneAffinity(title, context, assigneeName) {
-  const employees = loadEmployeesSync();
+var LANE_MANAGER_ROLES = {
+  COO: ["CTO", "CMO", "GM", "Principal Engineer", "Content Production Specialist", "Staff Code Reviewer", "AI Product Lead", "Specialist"],
+  CTO: ["Principal Engineer", "Staff Code Reviewer", "Specialist"],
+  CMO: ["Content Production Specialist", "Specialist"],
+  GM: ["Specialist"]
+};
+function roleCanManageLane(assigneeRole, matchedRoles) {
+  const managedRoles = LANE_MANAGER_ROLES[assigneeRole];
+  if (!managedRoles) return false;
+  return managedRoles.some((role) => matchedRoles.has(role));
+}
+function checkLaneAffinity(title, context, assigneeName, employees = loadEmployeesSync()) {
   const employee = employees.find((e) => e.name === assigneeName);
   if (!employee) return void 0;
   const assigneeRole = employee.role;
@@ -466,7 +1007,7 @@ function checkLaneAffinity(title, context, assigneeName) {
   }
   if (matchedRoles.size === 0) return void 0;
   if (matchedRoles.has(assigneeRole)) return void 0;
-  if (assigneeRole === "COO") return void 0;
+  if (roleCanManageLane(assigneeRole, matchedRoles)) return void 0;
   const expectedRoles = Array.from(matchedRoles).join(" or ");
   return `\u26A0\uFE0F Lane mismatch: task content suggests ${expectedRoles}, but assigned to ${assigneeName} (${assigneeRole}).`;
 }
@@ -479,7 +1020,9 @@ async function resolveTask(client, identifier, scopeSession) {
     for (const row of rows) unique.set(String(row.id), row);
     const crossSessionRows = [...unique.values()].filter((row) => {
       const rowScope = row.session_scope === null || row.session_scope === void 0 ? null : String(row.session_scope);
-      return rowScope !== null && rowScope !== currentScope;
+      if (rowScope === null || rowScope === currentScope) return false;
+      if (allowDeadScopeRescue(String(row.id), rowScope, currentScope)) return false;
+      return true;
     });
     if (crossSessionRows.length === 0) return null;
     const matches = crossSessionRows.slice(0, 5).map((row) => `${String(row.id).slice(0, 8)} "${String(row.title)}" [session:${String(row.session_scope)}]`).join(", ");
@@ -616,9 +1159,9 @@ ${f.context}
 `;
 }
 async function writeTaskMarkdownAtomic(finalPath, content) {
-  const dir = path3.dirname(finalPath);
-  if (!existsSync3(dir)) await mkdir(dir, { recursive: true });
-  const tmpPath = `${finalPath}.${crypto.randomBytes(6).toString("hex")}.tmp`;
+  const dir = path5.dirname(finalPath);
+  if (!existsSync6(dir)) await mkdir(dir, { recursive: true });
+  const tmpPath = `${finalPath}.${crypto2.randomBytes(6).toString("hex")}.tmp`;
   try {
     await writeFile(tmpPath, content, "utf-8");
     const { rename } = await import("fs/promises");
@@ -634,7 +1177,7 @@ async function writeTaskMarkdownAtomic(finalPath, content) {
 }
 async function createTaskCore(input) {
   const client = getClient();
-  const id = crypto.randomUUID();
+  const id = crypto2.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const slug = slugify(input.title);
   let earlySessionScope = null;
@@ -676,7 +1219,7 @@ async function createTaskCore(input) {
         if (isCoordinatorSession) {
           earlySessionScope = resolved;
         } else {
-          const { getSessionProject } = await import("./session-scope-5FWZ4AYR.js");
+          const { getSessionProject } = await import("./session-scope-RBKAC75W.js");
           const sessionProject = getSessionProject(resolved);
           if (sessionProject && sessionProject !== input.projectName) {
             scopeMismatchWarning = `session/project mismatch: session "${resolved}" owns "${sessionProject}" but task targets "${input.projectName}". Routed to default scope.`;
@@ -747,8 +1290,8 @@ ${scopeMismatchWarning}` : scopeMismatchWarning;
   }
   if (input.baseDir) {
     try {
-      await mkdir(path3.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir(path3.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir(path5.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir(path5.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
@@ -828,8 +1371,8 @@ ${scopeMismatchWarning}` : scopeMismatchWarning;
   });
   if (input.baseDir) {
     try {
-      const EXE_OS_DIR = path3.join(os3.homedir(), ".exe-os");
-      const mdPath = path3.join(EXE_OS_DIR, taskFile);
+      const EXE_OS_DIR = path5.join(os5.homedir(), ".exe-os");
+      const mdPath = path5.join(EXE_OS_DIR, taskFile);
       const reviewer = input.reviewer ?? input.assignedBy;
       const mdContent = renderTaskMarkdown({
         id,
@@ -925,7 +1468,7 @@ async function queryTaskRows(opts) {
   }
   if (opts.founderId !== null) {
     try {
-      const { founderScopeFilter } = await import("./founder-context-J362DNU4.js");
+      const { founderScopeFilter } = await import("./founder-context-FYTF4IMD.js");
       const founderFilter = founderScopeFilter(opts.founderId);
       const cleaned = founderFilter.sql.replace(/^\s*AND\s+/, "");
       conditions.push(cleaned);
@@ -1072,6 +1615,25 @@ function isTmuxSessionAlive(identifier) {
 }
 var DELEGATION_KEYWORDS = /parallel|delegate|wave|worktree|multi-instance/i;
 var TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
+var VALID_TASK_STATUSES = [
+  "open",
+  "in_progress",
+  "needs_review",
+  "closed",
+  "blocked",
+  "cancelled"
+];
+var VALID_TRANSITIONS = {
+  open: ["in_progress", "needs_review", "cancelled", "blocked"],
+  in_progress: ["in_progress", "open", "needs_review", "blocked", "cancelled"],
+  blocked: ["open", "in_progress", "cancelled"],
+  needs_review: ["closed", "in_progress", "open"],
+  closed: [],
+  // terminal — no transitions out
+  cancelled: ["open"]
+  // allow re-opening cancelled tasks
+};
+var STALE_FLIP_SUPPRESSION_MS = 48 * 60 * 60 * 1e3;
 function checkStaleCompletion(taskContext, taskCreatedAt) {
   if (!taskContext) return null;
   if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
@@ -1109,130 +1671,30 @@ async function updateTaskStatus(input) {
   if (input.status === "done") {
     input.status = "needs_review";
   }
-  if (previousStatus === "needs_review" && input.status !== "needs_review") {
-    try {
-      const { clearCompletionNudge } = await import("./completion-nudge-dedup-DBZF24MM.js");
-      clearCompletionNudge(String(row.id));
-    } catch {
-    }
-  }
-  const isReviewTransition = input.status === "needs_review" && previousStatus !== "needs_review" && (previousStatus === "open" || previousStatus === "in_progress");
-  const effectiveReviewer = row.reviewer ? String(row.reviewer) : row.assigned_by ? String(row.assigned_by) : "";
-  if (isReviewTransition && effectiveReviewer) {
-    const reviewer = effectiveReviewer;
-    try {
-      const { sendIntercom: sendIntercom2, employeeSessionName: employeeSessionName2, resolveExeSession: resolveExeSession2, isExeSession: isExeSession2 } = await import("./lib/tmux-routing.js");
-      const exeSession = row.session_scope ? String(row.session_scope) : resolveExeSession2();
-      if (exeSession) {
-        if (isCoordinatorName(reviewer)) {
-          if (isExeSession2(exeSession)) {
-            sendIntercom2(exeSession, { force: true, reason: "completion" });
-            process.stderr.write(
-              `[tasks-crud] Review intercom sent to ${exeSession}: "${String(row.title)}" by ${String(row.assigned_to)}
-`
-            );
-          }
-        } else {
-          const reviewerSession = employeeSessionName2(reviewer, exeSession);
-          sendIntercom2(reviewerSession, { force: true, reason: "completion" });
-          process.stderr.write(
-            `[tasks-crud] Review intercom sent to ${reviewerSession}: "${String(row.title)}" by ${String(row.assigned_to)}
-`
-          );
-        }
-      }
-    } catch (err) {
-      process.stderr.write(
-        `[tasks-crud] Review intercom failed for ${reviewer}: ${err instanceof Error ? err.message : String(err)}
+  if (!VALID_TASK_STATUSES.includes(input.status)) {
+    process.stderr.write(
+      `[tasks-crud] REJECTED invalid status literal "${input.status}" for task ${taskId} (valid: ${VALID_TASK_STATUSES.join(", ")})
 `
-      );
-    }
-    try {
-      const { recordCompletionNudge } = await import("./completion-nudge-dedup-DBZF24MM.js");
-      recordCompletionNudge(String(row.id));
-    } catch {
-    }
-    try {
-      const { reviewSignalPath, taskSignalDir } = await import("./signal-paths-4GOIRLGH.js");
-      const scope = row.session_scope ? String(row.session_scope) : "default";
-      const dir = taskSignalDir(scope);
-      const { mkdirSync: mkdirSync4, writeFileSync: writeFileSync3 } = await import("fs");
-      mkdirSync4(dir, { recursive: true });
-      writeFileSync3(
-        reviewSignalPath(scope, reviewer, String(row.id)),
-        JSON.stringify({
-          task_id: String(row.id),
-          title: String(row.title),
-          assigned_to: String(row.assigned_to),
-          reviewer,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }),
-        "utf-8"
-      );
-    } catch {
-    }
-    try {
-      const { writeNotification: writeNotification2 } = await import("./notifications-BBQ23ORD.js");
-      await writeNotification2({
-        agentId: reviewer,
-        agentRole: isCoordinatorName(reviewer) ? "COO" : "manager",
-        event: "task_complete",
-        project: String(row.project_name ?? ""),
-        summary: `${String(row.assigned_to)} completed "${String(row.title)}" \u2014 needs your review.`,
-        taskFile,
-        sessionScope: row.session_scope ? String(row.session_scope) : void 0
-      });
-    } catch {
-    }
+    );
+    throw new Error(
+      `Invalid task status "${input.status}". Valid statuses: ${VALID_TASK_STATUSES.join(", ")} ("done" is accepted as an alias for "needs_review").`
+    );
   }
-  const isBlockedTransition = input.status === "blocked" && previousStatus !== "blocked";
-  if (isBlockedTransition && row.assigned_by) {
-    const dispatcher = String(row.assigned_by);
-    try {
-      const { sendIntercom: sendIntercom2, employeeSessionName: employeeSessionName2, resolveExeSession: resolveExeSession2, isExeSession: isExeSession2 } = await import("./lib/tmux-routing.js");
-      const exeSession = row.session_scope ? String(row.session_scope) : resolveExeSession2();
-      if (exeSession) {
-        if (isCoordinatorName(dispatcher)) {
-          if (isExeSession2(exeSession)) {
-            sendIntercom2(exeSession, { force: true, reason: "completion" });
-            process.stderr.write(
-              `[tasks-crud] Blocked intercom sent to ${exeSession}: "${String(row.title)}" blocked by ${String(row.assigned_to)}
-`
-            );
-          }
-        } else {
-          const dispatcherSession = employeeSessionName2(dispatcher, exeSession);
-          sendIntercom2(dispatcherSession, { force: true, reason: "completion" });
-          process.stderr.write(
-            `[tasks-crud] Blocked intercom sent to ${dispatcherSession}: "${String(row.title)}" blocked by ${String(row.assigned_to)}
-`
-          );
-        }
-      }
-    } catch (err) {
-      process.stderr.write(
-        `[tasks-crud] Blocked intercom failed for ${dispatcher}: ${err instanceof Error ? err.message : String(err)}
+  if (!VALID_TASK_STATUSES.includes(previousStatus)) {
+    process.stderr.write(
+      `[tasks-crud] WARNING: task ${taskId} has unknown stored status "${previousStatus}" (not in the 6-status model) \u2014 allowing transition to "${input.status}" to heal the row
 `
-      );
-    }
+    );
   }
-  const VALID_TRANSITIONS = {
-    open: ["in_progress", "needs_review", "cancelled", "blocked"],
-    in_progress: ["in_progress", "open", "needs_review", "blocked", "cancelled"],
-    blocked: ["open", "in_progress", "cancelled"],
-    needs_review: ["closed", "in_progress", "open"],
-    closed: [],
-    // terminal — no transitions out
-    cancelled: ["open"]
-    // allow re-opening cancelled tasks
-  };
-  const currentStatus = String(row.status);
-  const validNext = VALID_TRANSITIONS[currentStatus];
+  const validNext = VALID_TRANSITIONS[previousStatus];
   if (validNext && !validNext.includes(input.status)) {
     throw new Error(
-      `Invalid task transition: ${currentStatus} \u2192 ${input.status}. Valid transitions from "${currentStatus}": [${validNext.join(", ")}]`
+      `Invalid task transition: ${previousStatus} \u2192 ${input.status}. Valid transitions from "${previousStatus}": [${validNext.join(", ")}]`
     );
   }
+  const isReviewTransition = input.status === "needs_review" && previousStatus !== "needs_review" && (previousStatus === "open" || previousStatus === "in_progress");
+  const effectiveReviewer = row.reviewer ? String(row.reviewer) : row.assigned_by ? String(row.assigned_by) : "";
+  const isBlockedTransition = input.status === "blocked" && previousStatus !== "blocked";
   if (input.status === "done" && String(row.assigned_by) === "system" && taskFile.includes("review-")) {
     process.stderr.write(
       `[updateTask] Review task "${String(row.title)}" being marked done (assigned to ${String(row.assigned_to)})
@@ -1257,6 +1719,7 @@ ${input.result}` : `\u26A0\uFE0F ${warning}`;
     }
   }
   const hasStructuredFields = input.filesChanged || input.decisions || input.commits || input.testsStatus || input.buildStatus || input.prNumber || input.openQuestions;
+  let structuredSerialized = null;
   if (hasStructuredFields && (requestedStatus === "done" || input.status === "needs_review")) {
     const agentId = String(row.assigned_to ?? "unknown");
     const typedResult = buildTaskResult({
@@ -1271,20 +1734,7 @@ ${input.result}` : `\u26A0\uFE0F ${warning}`;
       pr_number: input.prNumber,
       open_questions: input.openQuestions
     });
-    const serialized = serializeMessage(typedResult);
-    try {
-      await client.execute({
-        sql: "UPDATE tasks SET structured_result = ?, updated_at = ? WHERE id = ?",
-        args: [serialized, now, taskId]
-      });
-    } catch {
-      process.stderr.write(
-        `[tasks-crud] structured_result column unavailable \u2014 embedding in result text
-`
-      );
-      input.result = `<!-- STRUCTURED_RESULT:${serialized} -->
-${input.result ?? ""}`;
-    }
+    structuredSerialized = serializeMessage(typedResult);
   }
   const shouldWriteCompletionMemory = shouldNormalizeTaskResult(requestedStatus, input.status) && previousStatus !== input.status && (requestedStatus === "done" || input.status === "needs_review");
   if (shouldNormalizeTaskResult(requestedStatus, input.status)) {
@@ -1312,7 +1762,7 @@ ${input.result ?? ""}`;
     const leaseExpiry = leaseExpiryIso(now, leaseMinutes);
     const estMin = input.estimatedMinutes != null ? Math.max(1, Math.round(input.estimatedMinutes)) : null;
     const estConf = input.estimateConfidence != null ? Math.max(0, Math.min(1, input.estimateConfidence)) : null;
-    const claim = await client.execute({
+    const claim2 = await client.execute({
       sql: `UPDATE tasks
             SET status = 'in_progress', assigned_tmux = ?, updated_at = ?,
                 claimed_by = ?, claimed_at = ?, last_heartbeat_at = ?,
@@ -1324,7 +1774,7 @@ ${input.result ?? ""}`;
             WHERE id = ? AND status = 'open'${claimGuardSql}`,
       args: [tmuxSession, now, claimAgent, now, now, leaseExpiry, now, estMin, estConf, taskId, ...claimGuardArgs]
     });
-    if (claim.rowsAffected === 0) {
+    if (claim2.rowsAffected === 0) {
       const current = await client.execute({
         sql: "SELECT status, assigned_tmux, assigned_by FROM tasks WHERE id = ?",
         args: [taskId]
@@ -1338,10 +1788,7 @@ ${input.result ?? ""}`;
           `[tasks] Auto-releasing dead claim on ${taskId} (was ${claimedBySession})
 `
         );
-        await client.execute({
-          sql: "UPDATE tasks SET status = 'open', assigned_tmux = NULL, claimed_by = NULL, claimed_at = NULL, last_heartbeat_at = NULL, lease_expires_at = NULL, updated_at = ? WHERE id = ?",
-          args: [now, taskId]
-        });
+        await reopenTask(taskId, `dead claim auto-release (was ${claimedBySession})`);
         const retried = await client.execute({
           sql: `UPDATE tasks SET status = 'in_progress', assigned_tmux = ?, updated_at = ?,
                     claimed_by = ?, claimed_at = ?, last_heartbeat_at = ?,
@@ -1558,17 +2005,165 @@ ${input.result ?? ""}`;
       }
     }
   }
-  if (input.result) {
-    await client.execute({
-      sql: `UPDATE tasks SET status = ?, result = ?, updated_at = ?${actualMinutesClause} WHERE id = ?`,
-      args: [input.status, input.result, now, ...actualMinutesArgs, taskId]
-    });
-  } else {
-    await client.execute({
-      sql: `UPDATE tasks SET status = ?, updated_at = ?${actualMinutesClause} WHERE id = ?`,
-      args: [input.status, now, ...actualMinutesArgs, taskId]
-    });
-  }
+  const buildStatusStatement = () => input.result ? {
+    sql: `UPDATE tasks SET status = ?, result = ?, updated_at = ?${actualMinutesClause} WHERE id = ?`,
+    args: [input.status, input.result, now, ...actualMinutesArgs, taskId]
+  } : {
+    sql: `UPDATE tasks SET status = ?, updated_at = ?${actualMinutesClause} WHERE id = ?`,
+    args: [input.status, now, ...actualMinutesArgs, taskId]
+  };
+  const writeStatements = [];
+  if (structuredSerialized) {
+    writeStatements.push({
+      sql: "UPDATE tasks SET structured_result = ?, updated_at = ? WHERE id = ?",
+      args: [structuredSerialized, now, taskId]
+    });
+  }
+  writeStatements.push(buildStatusStatement());
+  try {
+    await client.batch(writeStatements, "write");
+  } catch (err) {
+    const errMsg2 = err instanceof Error ? err.message : String(err);
+    if (structuredSerialized && /structured_result/i.test(errMsg2)) {
+      process.stderr.write(
+        `[tasks-crud] structured_result column unavailable \u2014 embedding in result text
+`
+      );
+      input.result = `<!-- STRUCTURED_RESULT:${structuredSerialized} -->
+${input.result ?? ""}`;
+      await client.batch([buildStatusStatement()], "write");
+    } else {
+      throw err;
+    }
+  }
+  if (previousStatus === "needs_review" && input.status !== "needs_review") {
+    try {
+      clearCompletionNudge(taskId);
+    } catch (err) {
+      process.stderr.write(
+        `[tasks-crud] clearCompletionNudge failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  if (isReviewTransition && effectiveReviewer) {
+    const reviewer = effectiveReviewer;
+    const lastTouchedRaw = row.updated_at ?? row.created_at;
+    const lastTouchedMs = lastTouchedRaw ? Date.parse(String(lastTouchedRaw)) : NaN;
+    const isStaleFlip = Number.isFinite(lastTouchedMs) && Date.parse(now) - lastTouchedMs > STALE_FLIP_SUPPRESSION_MS;
+    const isSelfReview = reviewer === String(row.assigned_to);
+    const suppressNudgeStorm = isStaleFlip || isSelfReview;
+    if (suppressNudgeStorm) {
+      process.stderr.write(
+        `[tasks-crud] Nudge storm suppressed for ${taskId} (${isSelfReview ? "self-review: assigned_to === reviewer" : "stale flip: last touched >48h ago"}) \u2014 notification row only
+`
+      );
+    }
+    if (!suppressNudgeStorm) {
+      try {
+        const exeSession = row.session_scope ? String(row.session_scope) : resolveExeSession();
+        if (exeSession) {
+          if (isCoordinatorName(reviewer)) {
+            if (isExeSession(exeSession)) {
+              sendIntercom(exeSession, { force: true, reason: "completion" });
+              process.stderr.write(
+                `[tasks-crud] Review intercom sent to ${exeSession}: "${String(row.title)}" by ${String(row.assigned_to)}
+`
+              );
+            }
+          } else {
+            const reviewerSession = employeeSessionName(reviewer, exeSession);
+            sendIntercom(reviewerSession, { force: true, reason: "completion" });
+            process.stderr.write(
+              `[tasks-crud] Review intercom sent to ${reviewerSession}: "${String(row.title)}" by ${String(row.assigned_to)}
+`
+            );
+          }
+        }
+      } catch (err) {
+        process.stderr.write(
+          `[tasks-crud] Review intercom failed for ${reviewer}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+    try {
+      recordCompletionNudge(taskId);
+    } catch (err) {
+      process.stderr.write(
+        `[tasks-crud] recordCompletionNudge failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+    if (!suppressNudgeStorm) {
+      try {
+        const scope = row.session_scope ? String(row.session_scope) : "default";
+        const dir = taskSignalDir(scope);
+        mkdirSync5(dir, { recursive: true });
+        writeFileSync4(
+          reviewSignalPath(scope, reviewer, taskId),
+          JSON.stringify({
+            task_id: taskId,
+            title: String(row.title),
+            assigned_to: String(row.assigned_to),
+            reviewer,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }),
+          "utf-8"
+        );
+      } catch (err) {
+        process.stderr.write(
+          `[tasks-crud] Review signal file write failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+    try {
+      await writeNotification({
+        agentId: reviewer,
+        agentRole: isCoordinatorName(reviewer) ? "COO" : "manager",
+        event: "task_complete",
+        project: String(row.project_name ?? ""),
+        summary: `${String(row.assigned_to)} completed "${String(row.title)}" \u2014 needs your review.`,
+        taskFile,
+        sessionScope: row.session_scope ? String(row.session_scope) : void 0
+      });
+    } catch (err) {
+      process.stderr.write(
+        `[tasks-crud] Completion notification write failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  if (isBlockedTransition && row.assigned_by) {
+    const dispatcher = String(row.assigned_by);
+    try {
+      const exeSession = row.session_scope ? String(row.session_scope) : resolveExeSession();
+      if (exeSession) {
+        if (isCoordinatorName(dispatcher)) {
+          if (isExeSession(exeSession)) {
+            sendIntercom(exeSession, { force: true, reason: "completion" });
+            process.stderr.write(
+              `[tasks-crud] Blocked intercom sent to ${exeSession}: "${String(row.title)}" blocked by ${String(row.assigned_to)}
+`
+            );
+          }
+        } else {
+          const dispatcherSession = employeeSessionName(dispatcher, exeSession);
+          sendIntercom(dispatcherSession, { force: true, reason: "completion" });
+          process.stderr.write(
+            `[tasks-crud] Blocked intercom sent to ${dispatcherSession}: "${String(row.title)}" blocked by ${String(row.assigned_to)}
+`
+          );
+        }
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[tasks-crud] Blocked intercom failed for ${dispatcher}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
   if (input.status === "cancelled" || input.status === "closed") {
     try {
       await client.execute({
@@ -1592,7 +2187,6 @@ ${input.result ?? ""}`;
   }
   if (shouldWriteCompletionMemory && input.result) {
     try {
-      const { writeMemoryViaDaemon } = await import("./memory-queue-client-BZD6MXA5.js");
       await writeMemoryViaDaemon({
         raw_text: input.result,
         agent_id: String(row.assigned_to),
@@ -1695,19 +2289,25 @@ ${input.result ?? ""}`;
   }
   if (input.status === "done" || input.status === "needs_review") {
     try {
-      const { incrementSkillSuccess } = await import("./skill-refinement-YLIAY7V4.js");
       await incrementSkillSuccess(
         String(row.assigned_to),
         row.project_name ? String(row.project_name) : null
       );
-    } catch {
+    } catch (err) {
+      process.stderr.write(
+        `[tasks-crud] incrementSkillSuccess failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
     }
   }
   if (input.status === "done" || input.status === "needs_review" || input.status === "cancelled" || input.status === "closed") {
     try {
-      const { clearQueueForAgent } = await import("./intercom-queue-6M5IRX3Y.js");
       clearQueueForAgent(String(row.assigned_to));
-    } catch {
+    } catch (err) {
+      process.stderr.write(
+        `[tasks-crud] clearQueueForAgent failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
     }
   }
   try {
@@ -1720,6 +2320,55 @@ ${input.result ?? ""}`;
   }
   return { row, taskFile, now, taskId, previousStatus, requestedStatus };
 }
+async function reopenTask(taskId, reason) {
+  const client = getClient();
+  const row = await resolveTask(client, taskId);
+  const id = String(row.id);
+  const previousStatus = String(row.status);
+  if (previousStatus === "open") {
+    return { taskId: id, previousStatus, reopened: false };
+  }
+  const validNext = VALID_TRANSITIONS[previousStatus];
+  if (validNext && !validNext.includes("open")) {
+    throw new Error(
+      `Cannot reopen task ${id}: ${previousStatus} \u2192 open is not a valid transition. Valid transitions from "${previousStatus}": [${validNext.join(", ")}]`
+    );
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const stalePrefix = `STALE (auto-reopened: ${reason})
+
+`;
+  await client.execute({
+    sql: `UPDATE tasks
+          SET status = 'open',
+              result = CASE
+                WHEN result IS NOT NULL AND result != '' AND result NOT LIKE 'STALE (auto-reopened%'
+                  THEN ? || result
+                ELSE result
+              END,
+              assigned_tmux = NULL, claimed_by = NULL, claimed_at = NULL,
+              last_heartbeat_at = NULL, lease_expires_at = NULL,
+              updated_at = ?
+          WHERE id = ?`,
+    args: [stalePrefix, now, id]
+  });
+  process.stderr.write(
+    `[tasks-crud] Reopened task ${id} (${previousStatus} \u2192 open): ${reason}
+`
+  );
+  recordOrchestrationEventBestEffort({
+    eventType: "task.reopened",
+    source: "tasks-crud.reopenTask",
+    severity: "warn",
+    taskId: id,
+    agentId: row.assigned_to ? String(row.assigned_to) : null,
+    sessionScope: row.session_scope ? String(row.session_scope) : null,
+    projectName: row.project_name ? String(row.project_name) : null,
+    result: previousStatus,
+    payload: { reason }
+  });
+  return { taskId: id, previousStatus, reopened: true };
+}
 async function deleteTaskCore(taskId, _baseDir) {
   const client = getClient();
   const row = await resolveTask(client, taskId);
@@ -1732,9 +2381,9 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path3.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path5.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync3(archPath)) return;
+    if (existsSync6(archPath)) return;
     const template = [
       `# ${projectName} \u2014 System Architecture`,
       "",
@@ -1767,10 +2416,10 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path3.join(baseDir, ".gitignore");
+  const gitignorePath = path5.join(baseDir, ".gitignore");
   try {
-    if (existsSync3(gitignorePath)) {
-      const content = readFileSync2(gitignorePath, "utf-8");
+    if (existsSync6(gitignorePath)) {
+      const content = readFileSync5(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
     } else {
@@ -1781,8 +2430,8 @@ async function ensureGitignoreExe(baseDir) {
 }
 async function cleanOrphanedTaskFiles() {
   const { readdir, unlink, stat } = await import("fs/promises");
-  const EXE_TASKS_DIR = path3.join(os3.homedir(), ".exe-os", "tasks");
-  if (!existsSync3(EXE_TASKS_DIR)) return 0;
+  const EXE_TASKS_DIR = path5.join(os5.homedir(), ".exe-os", "tasks");
+  if (!existsSync6(EXE_TASKS_DIR)) return 0;
   const client = getClient();
   let cleaned = 0;
   async function walkDir(dir) {
@@ -1793,11 +2442,11 @@ async function cleanOrphanedTaskFiles() {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path3.join(dir, entry.name);
+      const fullPath = path5.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walkDir(fullPath);
       } else if (entry.name.endsWith(".md")) {
-        const relativePath = path3.relative(path3.join(os3.homedir(), ".exe-os"), fullPath);
+        const relativePath = path5.relative(path5.join(os5.homedir(), ".exe-os"), fullPath);
         try {
           const result = await client.execute({
             sql: "SELECT id FROM tasks WHERE task_file = ? LIMIT 1",
@@ -1860,7 +2509,7 @@ async function readLatestCheckpoint(agentId) {
 }
 async function createTaskGroup(input) {
   const client = getClient();
-  const id = crypto.randomUUID();
+  const id = crypto2.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await client.execute({
     sql: `INSERT INTO task_groups (id, title, coordinator, session_scope, project_name, timeout_minutes, on_partial_failure, created_at, updated_at)
@@ -2155,8 +2804,8 @@ async function checkTaskFileConsistency() {
     for (const row of result.rows) {
       const taskFile = String(row.task_file ?? "");
       if (!taskFile) continue;
-      const fullPath = taskFile.startsWith("/") ? taskFile : path3.join(os3.homedir(), ".exe-os", taskFile);
-      if (existsSync3(fullPath)) continue;
+      const fullPath = taskFile.startsWith("/") ? taskFile : path5.join(os5.homedir(), ".exe-os", taskFile);
+      if (existsSync6(fullPath)) continue;
       let repaired = false;
       try {
         const mdContent = renderTaskMarkdown({
@@ -2169,271 +2818,41 @@ async function checkTaskFileConsistency() {
           projectName: String(row.project_name ?? ""),
           created: String(row.created_at ?? "").split("T")[0] || "",
           reviewer: row.reviewer ? String(row.reviewer) : row.assigned_by ? String(row.assigned_by) : "",
-          context: String(row.context ?? ""),
-          parentTaskId: row.parent_task_id ? String(row.parent_task_id) : null
-        });
-        await writeTaskMarkdownAtomic(fullPath, mdContent);
-        repaired = true;
-      } catch {
-      }
-      if (repaired) {
-        recordOrchestrationEventBestEffort({
-          eventType: "consistency.repaired",
-          source: "tasks-crud.checkTaskFileConsistency",
-          severity: "info",
-          taskId: String(row.id),
-          agentId: row.assigned_to ? String(row.assigned_to) : null,
-          sessionScope: row.session_scope ? String(row.session_scope) : null,
-          projectName: row.project_name ? String(row.project_name) : null,
-          payload: { taskFile, status: String(row.status), type: "db_row_missing_file_regenerated" }
-        });
-      } else {
-        mismatches++;
-        recordOrchestrationEventBestEffort({
-          eventType: "consistency.mismatch",
-          source: "tasks-crud.checkTaskFileConsistency",
-          severity: "warn",
-          taskId: String(row.id),
-          agentId: row.assigned_to ? String(row.assigned_to) : null,
-          sessionScope: row.session_scope ? String(row.session_scope) : null,
-          projectName: row.project_name ? String(row.project_name) : null,
-          payload: { taskFile, status: String(row.status), type: "db_row_missing_file" }
-        });
-      }
-    }
-  } catch {
-  }
-  return mismatches;
-}
-
-// src/lib/notifications.ts
-import crypto2 from "crypto";
-import path4 from "path";
-import os4 from "os";
-import {
-  readFileSync as readFileSync3,
-  readdirSync,
-  unlinkSync,
-  existsSync as existsSync4,
-  rmdirSync
-} from "fs";
-var CLEANUP_DAYS = 7;
-async function writeNotification(notification) {
-  try {
-    const client = getClient();
-    const id = crypto2.randomUUID();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sessionScope = notification.sessionScope === void 0 ? getCurrentSessionScope() : notification.sessionScope;
-    await client.execute({
-      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, session_scope, read, created_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?)`,
-      args: [
-        id,
-        notification.agentId,
-        notification.agentRole,
-        notification.event,
-        notification.project,
-        notification.summary,
-        notification.taskFile ?? null,
-        sessionScope,
-        now
-      ]
-    });
-  } catch (err) {
-    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
-  }
-}
-async function readUnreadNotifications(agentFilter, sessionScope) {
-  try {
-    const client = getClient();
-    const conditions = ["read = 0"];
-    const args = [];
-    const scope = strictSessionScopeFilter(sessionScope ?? void 0);
-    if (agentFilter) {
-      conditions.push("agent_id = ?");
-      args.push(agentFilter);
-    }
-    const result = 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 result.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 ?? void 0);
-    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();
-    const scope = strictSessionScopeFilter(sessionScope);
-    await client.execute({
-      sql: `UPDATE notifications SET read = 1
-            WHERE task_file = ? AND read = 0${scope.sql}`,
-      args: [taskFile, ...scope.args]
-    });
-  } 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 ?? void 0);
-    const result = await client.execute({
-      sql: `DELETE FROM notifications WHERE created_at < ?${scope.sql}`,
-      args: [cutoff, ...scope.args]
-    });
-    return result.rowsAffected;
-  } catch {
-    return 0;
-  }
-}
-async function markDoneTaskNotificationsAsRead(sessionScope) {
-  try {
-    const client = getClient();
-    const scope = strictSessionScopeFilter(sessionScope ?? void 0);
-    const result = 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 IN ('done', 'closed', 'cancelled')
-              )`,
-      args: [...scope.args]
-    });
-    return result.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 || path4.join(os4.homedir(), ".exe-os");
-  const notifDir = path4.join(base, "notifications");
-  if (!existsSync4(notifDir)) return 0;
-  let migrated = 0;
-  try {
-    const files = readdirSync(notifDir).filter((f) => f.endsWith(".json"));
-    if (files.length === 0) return 0;
-    const client = getClient();
-    for (const file of files) {
-      try {
-        const filePath = path4.join(notifDir, file);
-        const data = JSON.parse(readFileSync3(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: [
-            crypto2.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()
-          ]
+          context: String(row.context ?? ""),
+          parentTaskId: row.parent_task_id ? String(row.parent_task_id) : null
         });
-        unlinkSync(filePath);
-        migrated++;
+        await writeTaskMarkdownAtomic(fullPath, mdContent);
+        repaired = true;
       } catch {
       }
-    }
-    try {
-      const remaining = readdirSync(notifDir);
-      if (remaining.length === 0) {
-        rmdirSync(notifDir);
+      if (repaired) {
+        recordOrchestrationEventBestEffort({
+          eventType: "consistency.repaired",
+          source: "tasks-crud.checkTaskFileConsistency",
+          severity: "info",
+          taskId: String(row.id),
+          agentId: row.assigned_to ? String(row.assigned_to) : null,
+          sessionScope: row.session_scope ? String(row.session_scope) : null,
+          projectName: row.project_name ? String(row.project_name) : null,
+          payload: { taskFile, status: String(row.status), type: "db_row_missing_file_regenerated" }
+        });
+      } else {
+        mismatches++;
+        recordOrchestrationEventBestEffort({
+          eventType: "consistency.mismatch",
+          source: "tasks-crud.checkTaskFileConsistency",
+          severity: "warn",
+          taskId: String(row.id),
+          agentId: row.assigned_to ? String(row.assigned_to) : null,
+          sessionScope: row.session_scope ? String(row.session_scope) : null,
+          projectName: row.project_name ? String(row.project_name) : null,
+          payload: { taskFile, status: String(row.status), type: "db_row_missing_file" }
+        });
       }
-    } 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 "task_group_barrier":
-      return "Task group:";
-    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`;
+  return mismatches;
 }
 
 // src/lib/tasks-review.ts
@@ -2448,9 +2867,11 @@ function formatAge(isoTimestamp) {
   const days = Math.floor(hours / 24);
   return `${days}d ago`;
 }
+var STALE_REVIEW_AGE_MS = 24 * 60 * 60 * 1e3;
+var SIGNAL_FILE_TTL_MS = 48 * 60 * 60 * 1e3;
 function isStale(isoTimestamp) {
   if (!isoTimestamp) return false;
-  return Date.now() - new Date(isoTimestamp).getTime() > 24 * 60 * 60 * 1e3;
+  return Date.now() - new Date(isoTimestamp).getTime() > STALE_REVIEW_AGE_MS;
 }
 async function countPendingReviews(sessionScope, reviewer) {
   const extraConditions = reviewer ? ["reviewer = ?"] : void 0;
@@ -2505,43 +2926,197 @@ async function listPendingReviews(limit, sessionScope, projectName, reviewer) {
   });
   return rows;
 }
+var ORPHAN_REVIEW_COLUMNS = "id, task_file, session_scope, reviewer, assigned_by, assigned_to, title, project_name";
+function toOrphanedReviewRow(r) {
+  const str = (v) => v == null ? null : String(v);
+  return {
+    id: String(r.id),
+    task_file: str(r.task_file),
+    session_scope: str(r.session_scope),
+    reviewer: str(r.reviewer),
+    assigned_by: str(r.assigned_by),
+    assigned_to: str(r.assigned_to),
+    title: str(r.title),
+    project_name: str(r.project_name)
+  };
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function invalidateReviewArtifacts(row) {
+  if (row.task_file) {
+    try {
+      await markAsReadByTaskFile(row.task_file, row.session_scope ?? null);
+    } catch (err) {
+      process.stderr.write(`[cleanup] notification invalidation failed for task ${row.id}: ${errMsg(err)}
+`);
+    }
+  }
+  try {
+    const dir = taskSignalDir(row.session_scope || "default");
+    if (existsSync7(dir)) {
+      for (const f of readdirSync2(dir)) {
+        if (f.endsWith(`.review-${row.id}.pending`)) {
+          unlinkSync3(path6.join(dir, f));
+        }
+      }
+    }
+  } catch (err) {
+    process.stderr.write(`[cleanup] signal-file invalidation failed for task ${row.id}: ${errMsg(err)}
+`);
+  }
+  try {
+    clearCompletionNudge(row.id);
+    clearStaleReviewEscalation(row.id);
+  } catch (err) {
+    process.stderr.write(`[cleanup] dedup invalidation failed for task ${row.id}: ${errMsg(err)}
+`);
+  }
+  try {
+    const scope = row.session_scope;
+    if (scope) {
+      const targets = [scope];
+      const reviewer = row.reviewer || row.assigned_by;
+      if (reviewer && !isCoordinatorName(reviewer)) {
+        try {
+          targets.push(employeeSessionName(reviewer, scope));
+        } catch {
+        }
+      }
+      for (const target of targets) {
+        drainForSession(target, (_session, item) => item.intercomReason === "completion");
+      }
+    }
+  } catch (err) {
+    process.stderr.write(`[cleanup] intercom-queue invalidation failed for task ${row.id}: ${errMsg(err)}
+`);
+  }
+}
+async function closeReviewRows(client, rows, status, now) {
+  if (rows.length === 0) return 0;
+  const placeholders = rows.map(() => "?").join(", ");
+  const result = await client.execute({
+    sql: `UPDATE tasks SET status = ?, updated_at = ? WHERE id IN (${placeholders})`,
+    args: [status, now, ...rows.map((r) => r.id)]
+  });
+  for (const row of rows) {
+    await invalidateReviewArtifacts(row);
+  }
+  return result.rowsAffected;
+}
+function sweepExpiredSignalFiles(now = Date.now()) {
+  let deleted = 0;
+  try {
+    const base = path6.join(homedir2(), ".exe-os", "task-signals");
+    if (!existsSync7(base)) return 0;
+    for (const scopeName of readdirSync2(base)) {
+      const scopeDir = path6.join(base, scopeName);
+      let entries;
+      try {
+        entries = readdirSync2(scopeDir);
+      } catch {
+        continue;
+      }
+      for (const f of entries) {
+        if (!f.endsWith(".pending")) continue;
+        const filePath = path6.join(scopeDir, f);
+        try {
+          if (now - statSync3(filePath).mtimeMs > SIGNAL_FILE_TTL_MS) {
+            unlinkSync3(filePath);
+            deleted++;
+          }
+        } catch {
+        }
+      }
+    }
+  } catch (err) {
+    process.stderr.write(`[cleanup] signal-file TTL sweep failed: ${errMsg(err)}
+`);
+  }
+  if (deleted > 0) {
+    process.stderr.write(`[cleanup] Deleted ${deleted} expired signal file(s) (>48h old)
+`);
+  }
+  return deleted;
+}
 async function cleanupOrphanedReviews(sessionScope) {
   const client = getClient();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const scope = sessionScopeFilter(sessionScope);
-  const r1 = await client.execute({
-    sql: `UPDATE tasks SET status = 'cancelled', updated_at = ?
+  const p1 = await client.execute({
+    sql: `SELECT ${ORPHAN_REVIEW_COLUMNS} FROM tasks
           WHERE status IN ('open', 'needs_review', 'in_progress')
           AND assigned_by = 'system'
           AND title LIKE 'Review:%'
           AND parent_task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'cancelled', 'closed'))
           ${scope.sql}`,
-    args: [now, ...scope.args]
+    args: [...scope.args]
   });
-  const r1b = await client.execute({
-    sql: `UPDATE tasks SET status = 'cancelled', updated_at = ?
+  const cascadeRows = p1.rows.map((r) => toOrphanedReviewRow(r));
+  const cascadeClosed = await closeReviewRows(client, cascadeRows, "cancelled", now);
+  const p2 = await client.execute({
+    sql: `SELECT ${ORPHAN_REVIEW_COLUMNS} FROM tasks
           WHERE status IN ('open', 'needs_review')
           AND title LIKE 'Review:%completed%'
           AND (parent_task_id IS NULL OR parent_task_id NOT IN (SELECT id FROM tasks WHERE status IN ('open', 'in_progress', 'needs_review', 'blocked')))
           ${scope.sql}`,
-    args: [now, ...scope.args]
+    args: [...scope.args]
+  });
+  const orphanRows = p2.rows.map((r) => toOrphanedReviewRow(r));
+  const orphanClosed = await closeReviewRows(client, orphanRows, "cancelled", now);
+  const p3 = await client.execute({
+    sql: `SELECT ${ORPHAN_REVIEW_COLUMNS} FROM tasks
+          WHERE status = 'needs_review'
+          AND result IS NOT NULL
+          AND parent_task_id IS NOT NULL
+          AND parent_task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'cancelled', 'closed'))
+          ${scope.sql}`,
+    args: [...scope.args]
   });
-  const staleThreshold = new Date(Date.now() - 60 * 60 * 1e3).toISOString();
-  const r2 = await client.execute({
-    sql: `UPDATE tasks SET status = 'closed', updated_at = ?
+  const staleOrphanRows = p3.rows.map((r) => toOrphanedReviewRow(r));
+  const staleClosed = await closeReviewRows(client, staleOrphanRows, "closed", now);
+  const staleThreshold = new Date(Date.now() - STALE_REVIEW_AGE_MS).toISOString();
+  const p4 = await client.execute({
+    sql: `SELECT ${ORPHAN_REVIEW_COLUMNS} FROM tasks
           WHERE status = 'needs_review'
           AND result IS NOT NULL
           AND updated_at < ?
           ${scope.sql}`,
-    args: [now, staleThreshold, ...scope.args]
+    args: [staleThreshold, ...scope.args]
   });
-  const total = r1.rowsAffected + (r1b?.rowsAffected ?? 0) + r2.rowsAffected;
+  let escalated = 0;
+  if (p4.rows.length > 0) {
+    const employees = await loadEmployees();
+    for (const r of p4.rows) {
+      const row = toOrphanedReviewRow(r);
+      if (!claimStaleReviewEscalation(row.id)) continue;
+      const reviewer = row.reviewer || row.assigned_by || getCoordinatorName(employees);
+      await writeNotification({
+        agentId: reviewer,
+        agentRole: isCoordinatorName(reviewer, employees) ? "COO" : "manager",
+        event: "orphan_task",
+        project: row.project_name ?? "",
+        summary: `STALE REVIEW: "${row.title ?? row.id}" by ${row.assigned_to ?? "unknown"} has been awaiting review for over 24h \u2014 review and close it (auto-close is disabled).`,
+        taskFile: row.task_file ?? void 0,
+        sessionScope: row.session_scope
+      });
+      escalated++;
+    }
+  }
+  if (escalated > 0) {
+    process.stderr.write(
+      `[cleanup] Escalated ${escalated} stale review(s) (>24h in needs_review, awaiting reviewer)
+`
+    );
+  }
+  const total = cascadeClosed + orphanClosed + staleClosed;
   if (total > 0) {
     process.stderr.write(
-      `[cleanup] Closed ${total} orphaned review(s): ${r1.rowsAffected} cascade + ${r1b?.rowsAffected ?? 0} orphan + ${r2.rowsAffected} stale
+      `[cleanup] Closed ${total} orphaned review(s): ${cascadeClosed} cascade + ${orphanClosed} orphan + ${staleClosed} stale
 `
     );
   }
+  sweepExpiredSignalFiles();
   return total;
 }
 function getReviewChecklist(role, agent, taskSlug) {
@@ -2671,19 +3246,21 @@ async function createReviewForCompletedTask(row, result, _baseDir, now) {
   const autoApprove = false;
   if (!autoApprove) {
     try {
-      const { claimCompletionNudge } = await import("./completion-nudge-dedup-DBZF24MM.js");
       if (claimCompletionNudge(originalTaskId)) {
         const taskScope = row.session_scope ? String(row.session_scope) : null;
         const exeSession = taskScope || getParentExe(getSessionKey());
         if (exeSession && isCoordinatorName(reviewer, employees)) {
           sendIntercom(exeSession, { force: true, reason: "completion" });
         } else if (exeSession && reviewer) {
-          const { employeeSessionName: employeeSessionName2 } = await import("./lib/tmux-routing.js");
-          const reviewerSession = employeeSessionName2(reviewer, exeSession);
+          const reviewerSession = employeeSessionName(reviewer, exeSession);
           sendIntercom(reviewerSession, { force: true, reason: "completion" });
         }
       }
-    } catch {
+    } catch (err) {
+      process.stderr.write(
+        `[review] completion intercom failed for "${taskTitle}": ${err instanceof Error ? err.message : String(err)}
+`
+      );
     }
   }
   if (autoApprove) {
@@ -2753,11 +3330,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path5.join(EXE_AI_DIR, "session-cache");
-    if (existsSync5(cacheDir)) {
+    const cacheDir = path6.join(EXE_AI_DIR, "session-cache");
+    if (existsSync7(cacheDir)) {
       for (const f of readdirSync2(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync2(path5.join(cacheDir, f));
+          unlinkSync3(path6.join(cacheDir, f));
         }
       }
     }
@@ -2767,8 +3344,8 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
 
 // src/lib/worktree-guard.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync6 } from "fs";
-import path6 from "path";
+import { existsSync as existsSync8 } from "fs";
+import path7 from "path";
 var GIT_TIMEOUT_MS = 1e4;
 function listWorktreesPorcelain(repoRoot) {
   try {
@@ -2795,7 +3372,7 @@ function listWorktreesPorcelain(repoRoot) {
   }
 }
 function inferSessionOwner(wtPath, branch) {
-  const dirName = path6.basename(wtPath);
+  const dirName = path7.basename(wtPath);
   if (dirName && dirName !== ".worktrees") {
     return dirName;
   }
@@ -2826,7 +3403,7 @@ function checkWorktreeCollisions(repoPath) {
   const worktrees = listWorktreesPorcelain(repoRoot);
   for (const wt of worktrees) {
     if (!wt.path.includes("/.worktrees/")) continue;
-    if (!existsSync6(wt.path)) continue;
+    if (!existsSync8(wt.path)) continue;
     const owner = inferSessionOwner(wt.path, wt.branch);
     const dirty = isWorktreeDirty(wt.path);
     const hasCommits = hasUnpushedCommits(wt.path, wt.branch);
@@ -2871,13 +3448,13 @@ function formatIntercomPrompt(reason = "nudge") {
 var _cachedExeBinDir;
 function resolveExeBinDir() {
   if (_cachedExeBinDir !== void 0) return _cachedExeBinDir;
-  const nodeBinDir = path7.dirname(process.execPath);
-  if (existsSync7(path7.join(nodeBinDir, "exe-launch-agent"))) {
+  const nodeBinDir = path8.dirname(process.execPath);
+  if (existsSync9(path8.join(nodeBinDir, "exe-launch-agent"))) {
     _cachedExeBinDir = nodeBinDir;
     return _cachedExeBinDir;
   }
-  const localBin = path7.join(os5.homedir(), ".local", "bin");
-  if (existsSync7(path7.join(localBin, "exe-launch-agent"))) {
+  const localBin = path8.join(os6.homedir(), ".local", "bin");
+  if (existsSync9(path8.join(localBin, "exe-launch-agent"))) {
     _cachedExeBinDir = localBin;
     return _cachedExeBinDir;
   }
@@ -2888,9 +3465,9 @@ function _resetExeBinDirCache() {
   _cachedExeBinDir = void 0;
 }
 function buildSpawnPath(inheritedPath = process.env.PATH, execPath = process.execPath) {
-  const sep = path7.delimiter;
-  const nodeBinDir = path7.dirname(execPath);
-  const localBin = path7.join(os5.homedir(), ".local", "bin");
+  const sep = path8.delimiter;
+  const nodeBinDir = path8.dirname(execPath);
+  const localBin = path8.join(os6.homedir(), ".local", "bin");
   const exeBinDir = resolveExeBinDir();
   const prefixDirs = [nodeBinDir, exeBinDir, localBin].filter(
     (d) => Boolean(d)
@@ -2907,9 +3484,9 @@ function buildSpawnPath(inheritedPath = process.env.PATH, execPath = process.exe
   }
   return ordered.join(sep);
 }
-var SPAWN_LOCK_DIR = path7.join(os5.homedir(), ".exe-os", "spawn-locks");
+var SPAWN_LOCK_DIR = path8.join(os6.homedir(), ".exe-os", "spawn-locks");
 function spawnLockPath(sessionName) {
-  return path7.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path8.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -2920,15 +3497,15 @@ function isProcessAlive(pid) {
   }
 }
 function acquireSpawnLock(sessionName) {
-  if (!existsSync7(SPAWN_LOCK_DIR)) {
-    mkdirSync3(SPAWN_LOCK_DIR, { recursive: true });
+  if (!existsSync9(SPAWN_LOCK_DIR)) {
+    mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
   const lockData = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
   try {
-    const fd = openSync(lockFile, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 420);
-    writeSync(fd, lockData);
-    closeSync(fd);
+    const fd = openSync2(lockFile, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL, 420);
+    writeSync2(fd, lockData);
+    closeSync2(fd);
     return true;
   } catch (err) {
     if (err?.code !== "EEXIST") {
@@ -2936,19 +3513,19 @@ function acquireSpawnLock(sessionName) {
     }
   }
   try {
-    const lock = JSON.parse(readFileSync4(lockFile, "utf8"));
+    const lock = JSON.parse(readFileSync6(lockFile, "utf8"));
     const age = Date.now() - lock.timestamp;
     if (isProcessAlive(lock.pid) && age < 6e4) {
       return false;
     }
     const tmpName = `${lockFile}.stale-${process.pid}-${Date.now()}`;
     try {
-      renameSync2(lockFile, tmpName);
+      renameSync3(lockFile, tmpName);
       try {
-        unlinkSync3(tmpName);
+        unlinkSync4(tmpName);
       } catch {
       }
-      writeFileSync2(lockFile, lockData);
+      writeFileSync5(lockFile, lockData);
       return true;
     } catch {
       return false;
@@ -2956,12 +3533,12 @@ function acquireSpawnLock(sessionName) {
   } catch {
     const tmpName = `${lockFile}.stale-${process.pid}-${Date.now()}`;
     try {
-      renameSync2(lockFile, tmpName);
+      renameSync3(lockFile, tmpName);
       try {
-        unlinkSync3(tmpName);
+        unlinkSync4(tmpName);
       } catch {
       }
-      writeFileSync2(lockFile, lockData);
+      writeFileSync5(lockFile, lockData);
       return true;
     } catch {
       return false;
@@ -2970,7 +3547,7 @@ function acquireSpawnLock(sessionName) {
 }
 function releaseSpawnLock(sessionName) {
   try {
-    unlinkSync3(spawnLockPath(sessionName));
+    unlinkSync4(spawnLockPath(sessionName));
   } catch {
   }
 }
@@ -2994,18 +3571,18 @@ function reconcileStaleSpawnLock(sessionName, isAlive = isEmployeeAlive) {
   });
   return { skip: false, brokeStaleLock: true };
 }
-var SESSION_CACHE = path7.join(os5.homedir(), ".exe-os", "session-cache");
+var SESSION_CACHE = path8.join(os6.homedir(), ".exe-os", "session-cache");
 var BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath(import.meta.url);
-    const scriptPath = path7.join(
-      path7.dirname(thisFile),
+    const scriptPath = path8.join(
+      path8.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync7(scriptPath) ? scriptPath : null;
+    return existsSync9(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -3109,11 +3686,11 @@ function extractRootExe(name) {
   return tail.length > 0 ? tail : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync7(SESSION_CACHE)) {
-    mkdirSync3(SESSION_CACHE, { recursive: true });
+  if (!existsSync9(SESSION_CACHE)) {
+    mkdirSync6(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path7.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  const filePath = path8.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
   atomicWriteJsonSync(filePath, {
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
@@ -3123,7 +3700,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 var PARENT_EXE_CACHE_TTL_MS = 4 * 60 * 60 * 1e3;
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync4(path7.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync6(path8.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;
@@ -3135,8 +3712,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync4(
-      path7.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync6(
+      path8.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -3357,7 +3934,7 @@ async function verifyPaneAtCapacity(sessionName) {
       reason: `capture-pane failed: ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  const { isAtCapacity } = await import("./capacity-monitor-WAEHVBL7.js");
+  const { isAtCapacity } = await import("./capacity-monitor-6O3PWYNM.js");
   if (!isAtCapacity(pane)) {
     return {
       atCapacity: false,
@@ -3371,15 +3948,15 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 var INTERCOM_DEBOUNCE_MS = 3e5;
 var CODEX_DEBOUNCE_MS = 3e5;
-var INTERCOM_LOG = path7.join(os5.homedir(), ".exe-os", "intercom.log");
-var INTERCOM_LOG_MAX_BYTES = 1024 * 1024;
+var INTERCOM_LOG2 = path8.join(os6.homedir(), ".exe-os", "intercom.log");
+var INTERCOM_LOG_MAX_BYTES2 = 1024 * 1024;
 var execFileAsync = promisify(execFile);
-var DEBOUNCE_FILE = path7.join(SESSION_CACHE, "intercom-debounce.json");
+var DEBOUNCE_FILE = path8.join(SESSION_CACHE, "intercom-debounce.json");
 var DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
 function readDebounceState() {
   try {
-    if (!existsSync7(DEBOUNCE_FILE)) return {};
-    const raw = JSON.parse(readFileSync4(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync9(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync6(DEBOUNCE_FILE, "utf8"));
     const state = {};
     for (const [key, val] of Object.entries(raw)) {
       if (typeof val === "number") {
@@ -3395,7 +3972,7 @@ function readDebounceState() {
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync7(SESSION_CACHE)) mkdirSync3(SESSION_CACHE, { recursive: true });
+    if (!existsSync9(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
     atomicWriteJsonSync(DEBOUNCE_FILE, state);
   } catch {
   }
@@ -3403,9 +3980,9 @@ function writeDebounceState(state) {
 function resolveSessionRuntime(targetSession) {
   const agentName = baseAgentName(targetSession.split("-")[0] ?? "");
   try {
-    const diPath = path7.join(SESSION_CACHE, `dispatch-info-${targetSession}.json`);
-    if (existsSync7(diPath)) {
-      const di = JSON.parse(readFileSync4(diPath, "utf-8"));
+    const diPath = path8.join(SESSION_CACHE, `dispatch-info-${targetSession}.json`);
+    if (existsSync9(diPath)) {
+      const di = JSON.parse(readFileSync6(diPath, "utf-8"));
       if (di.runtime) return di.runtime;
     }
     return getAgentRuntime(agentName).runtime;
@@ -3445,10 +4022,10 @@ function logIntercom(msg, meta) {
   process.stderr.write(`[intercom] ${msg}${metaStr}
 `);
   try {
-    if (existsSync7(INTERCOM_LOG) && statSync2(INTERCOM_LOG).size > INTERCOM_LOG_MAX_BYTES) {
-      renameSync2(INTERCOM_LOG, `${INTERCOM_LOG}.1`);
+    if (existsSync9(INTERCOM_LOG2) && statSync4(INTERCOM_LOG2).size > INTERCOM_LOG_MAX_BYTES2) {
+      renameSync3(INTERCOM_LOG2, `${INTERCOM_LOG2}.1`);
     }
-    appendFileSync2(INTERCOM_LOG, line);
+    appendFileSync3(INTERCOM_LOG2, line);
   } catch {
   }
 }
@@ -3479,6 +4056,59 @@ function isExeSession(sessionName) {
   const coordinatorName = getCoordinatorName();
   return matchesBaseWithInstance(coordinatorName);
 }
+var PROMPT_INPUT_LINE = /(?:^|\s|│)\s*[❯›>]\s?(.*)$/u;
+var PROMPT_PLACEHOLDER = /^Try\s+["'“]/u;
+function paneHasPendingInput(pane) {
+  const lines = pane.split("\n");
+  const tail = lines.slice(-12);
+  for (let i = tail.length - 1; i >= 0; i--) {
+    const line = tail[i];
+    if (!line || line.trim().length === 0) continue;
+    const m = PROMPT_INPUT_LINE.exec(line);
+    if (!m) continue;
+    const content = (m[1] ?? "").replace(/[│]\s*$/u, "").trim();
+    if (content.length === 0) return false;
+    if (PROMPT_PLACEHOLDER.test(content)) return false;
+    return true;
+  }
+  return false;
+}
+function isBlockedCodexPrompt(pane) {
+  const text = pane.toLowerCase();
+  if (!text.includes("codex")) return false;
+  const asksForChoice = /\(y\/n\)|\[y\/n\]|yes\/no|press enter|select .*model|choose .*model/.test(text);
+  const modelPrompt = /model.*(upgrade|switch|newer|recommended|select|choose)|upgrade.*model|switch.*model/.test(text);
+  return asksForChoice && modelPrompt;
+}
+function sessionHasPendingInput(sessionName) {
+  try {
+    const transport = getTransport();
+    return paneHasPendingInput(transport.capturePane(sessionName, 12));
+  } catch {
+    return false;
+  }
+}
+function decideQueuedNudgeDrain(intercomReason, state) {
+  if (state.hasInProgressTask) {
+    return { action: "drop", reason: "in_progress_task_will_auto_chain" };
+  }
+  if (intercomReason === "message" && !state.hasUnreadMessages) {
+    return { action: "drop", reason: "inbox_empty" };
+  }
+  if ((intercomReason === "completion" || intercomReason === "notification") && state.pendingReviewCount === 0) {
+    return { action: "drop", reason: "no_pending_reviews" };
+  }
+  return { action: "context", context: formatIntercomPrompt(intercomReason ?? "nudge") };
+}
+async function countScopedPendingReviews(targetSession, reviewer) {
+  try {
+    const scope = extractRootExe(targetSession);
+    const sessionScope = scope && isExeSession(scope) ? scope : void 0;
+    return await countPendingReviews(sessionScope, reviewer);
+  } catch {
+    return null;
+  }
+}
 function sendIntercom(targetSession, opts) {
   const transport = getTransport();
   const startedAt = Date.now();
@@ -3561,6 +4191,13 @@ function sendIntercom(targetSession, opts) {
       recordResult("failed", "session_not_found");
       return "failed";
     }
+    if (isExeSession(targetSession) && reason !== "message") {
+      queueIntercom(targetSession, "coordinator session \u2014 nudges deferred to prompt-submit hook", reason);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (coordinator \u2014 nudges are never keystroke-injected)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
+      recordResult("queued", "coordinator_no_inject");
+      return "queued";
+    }
     const sessionState = getSessionState(targetSession);
     if (sessionState === "no_claude") {
       queueIntercom(targetSession, "claude not running in session", reason);
@@ -3580,8 +4217,8 @@ function sendIntercom(targetSession, opts) {
       try {
         const rawAgent2 = targetSession.split("-")[0] ?? targetSession;
         const agent = baseAgentName(rawAgent2);
-        const markerPath = path7.join(SESSION_CACHE, `current-task-${agent}.json`);
-        if (existsSync7(markerPath)) {
+        const markerPath = path8.join(SESSION_CACHE, `current-task-${agent}.json`);
+        if (existsSync9(markerPath)) {
           logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker + not idle \u2014 will auto-chain)`);
           recordResult("debounced", "in_progress_marker");
           return "debounced";
@@ -3593,6 +4230,13 @@ function sendIntercom(targetSession, opts) {
       logIntercom(`COPY_MODE \u2192 ${targetSession} (exiting copy mode first)`);
       transport.sendKeys(targetSession, "q");
     }
+    if (sessionHasPendingInput(targetSession)) {
+      queueIntercom(targetSession, "non-empty input buffer at send time", reason);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (non-empty input buffer)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
+      recordResult("queued", "pending_input");
+      return "queued";
+    }
     const msg = formatIntercomPrompt(reason);
     transport.sendKeysLiteral(targetSession, msg, resolveSessionRuntime(targetSession));
     const batched = recordDebounce(targetSession);
@@ -3606,6 +4250,67 @@ function sendIntercom(targetSession, opts) {
     return "failed";
   }
 }
+var DEFERRED_SPAWN_NUDGE_ATTEMPTS = 3;
+var DEFERRED_SPAWN_NUDGE_RETRY_MS = Number(process.env.EXE_DEFERRED_SPAWN_NUDGE_RETRY_MS || 5e3);
+function scheduleDeferredSpawnNudge(input) {
+  const attemptSend = (attempt) => {
+    setTimeout(() => {
+      try {
+        if (!input.transport.isAlive(input.sessionName)) {
+          throw new Error("session not alive at deferred nudge time");
+        }
+        input.transport.sendKeysLiteral(input.sessionName, input.message, input.runtime);
+        process.stderr.write(
+          `[tmux-routing] deferred spawn nudge delivered to ${input.sessionName} (attempt ${attempt}/${DEFERRED_SPAWN_NUDGE_ATTEMPTS})
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.spawn_nudge.delivered",
+          source: "tmux-routing.scheduleDeferredSpawnNudge",
+          agentId: input.employeeName,
+          sessionScope: input.exeSession,
+          tmuxSession: input.sessionName,
+          runtime: input.runtime,
+          result: "delivered",
+          payload: { attempt }
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(
+          `[tmux-routing] deferred spawn nudge failed for ${input.sessionName} (attempt ${attempt}/${DEFERRED_SPAWN_NUDGE_ATTEMPTS}): ${msg}
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.spawn_nudge.failed",
+          source: "tmux-routing.scheduleDeferredSpawnNudge",
+          severity: "warn",
+          agentId: input.employeeName,
+          sessionScope: input.exeSession,
+          tmuxSession: input.sessionName,
+          runtime: input.runtime,
+          result: "failed",
+          errorCode: "deferred_nudge_failed",
+          payload: { attempt, error: msg }
+        });
+        if (attempt < DEFERRED_SPAWN_NUDGE_ATTEMPTS) {
+          attemptSend(attempt + 1);
+          return;
+        }
+        queueIntercom(input.sessionName, `spawn nudge failed after ${attempt} attempts: ${msg}`, "signal");
+        void import("./notifications-N5NKUYAU.js").then(({ writeNotification: writeNotification2 }) => writeNotification2({
+          agentId: getCoordinatorName(),
+          agentRole: "COO",
+          event: "error_spike",
+          project: "",
+          summary: `Spawned ${input.sessionName}, but the initial task nudge failed after ${attempt} attempts (${msg}). Worker may be idle with open task; check session and re-dispatch if needed.`,
+          sessionScope: input.exeSession
+        })).catch(() => {
+        });
+      }
+    }, attempt === 1 ? 1e4 : DEFERRED_SPAWN_NUDGE_RETRY_MS);
+  };
+  attemptSend(1);
+}
 var CODEX_SUBMIT_DELAY_MS = Number(process.env.EXE_CODEX_SUBMIT_DELAY_MS || 250);
 var SUBMIT_DELAY_MS = Number(process.env.EXE_SUBMIT_DELAY_MS || 60);
 async function sendKeysLiteralAsync(targetSession, text, runtime) {
@@ -3615,17 +4320,17 @@ async function sendKeysLiteralAsync(targetSession, text, runtime) {
     await execFileAsync("tmux", ["send-keys", "-t", targetSession, isCodex ? "C-m" : "Enter"], { timeout: 1e3 });
   };
   if (text.length >= 500) {
-    const tmpDir = path7.join(os5.tmpdir(), "exe-os-intercom");
-    mkdirSync3(tmpDir, { recursive: true });
-    const tmpFile = path7.join(tmpDir, `msg-${process.pid}-${Date.now()}.txt`);
+    const tmpDir = path8.join(os6.tmpdir(), "exe-os-intercom");
+    mkdirSync6(tmpDir, { recursive: true });
+    const tmpFile = path8.join(tmpDir, `msg-${process.pid}-${Date.now()}.txt`);
     try {
-      writeFileSync2(tmpFile, text, "utf-8");
+      writeFileSync5(tmpFile, text, "utf-8");
       await execFileAsync("tmux", ["load-buffer", tmpFile], { timeout: 3e3 });
       await execFileAsync("tmux", ["paste-buffer", "-p", "-t", targetSession], { timeout: 3e3 });
       await submit();
     } finally {
       try {
-        unlinkSync3(tmpFile);
+        unlinkSync4(tmpFile);
       } catch {
       }
     }
@@ -3695,6 +4400,13 @@ async function sendIntercomAsync(targetSession, opts) {
       recordResult("failed", "session_not_found");
       return "failed";
     }
+    if (isExeSession(targetSession) && reason !== "message") {
+      queueIntercom(targetSession, "coordinator session \u2014 nudges deferred to prompt-submit hook", reason);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (coordinator \u2014 nudges are never keystroke-injected)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
+      recordResult("queued", "coordinator_no_inject");
+      return "queued";
+    }
     const sessionState = getSessionState(targetSession);
     if (sessionState === "no_claude") {
       queueIntercom(targetSession, "claude not running in session", reason);
@@ -3718,6 +4430,13 @@ async function sendIntercomAsync(targetSession, opts) {
       }
     } catch {
     }
+    if (sessionHasPendingInput(targetSession)) {
+      queueIntercom(targetSession, "non-empty input buffer at send time", reason);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (non-empty input buffer)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
+      recordResult("queued", "pending_input");
+      return "queued";
+    }
     await sendKeysLiteralAsync(targetSession, formatIntercomPrompt(reason), resolveSessionRuntime(targetSession));
     const batched = recordDebounce(targetSession);
     logIntercom(`DELIVERED \u2192 ${targetSession}${batched > 0 ? ` [${batched} nudges batched during debounce]` : ""} (async fire-and-forget)`);
@@ -3788,10 +4507,10 @@ async function ensureWorktreeAsync(projectDir, employeeName, instance) {
     const repoRoot = rootOut.trim();
     if (!repoRoot) return null;
     const label = instance != null && instance > 0 ? `${employeeName}${instance}` : employeeName;
-    const wtPath = path7.join(repoRoot, ".worktrees", label);
+    const wtPath = path8.join(repoRoot, ".worktrees", label);
     const branch = `${label}-work`;
-    if (existsSync7(path7.join(wtPath, ".git"))) return wtPath;
-    mkdirSync3(path7.join(repoRoot, ".worktrees"), { recursive: true });
+    if (existsSync9(path8.join(wtPath, ".git"))) return wtPath;
+    mkdirSync6(path8.join(repoRoot, ".worktrees"), { recursive: true });
     try {
       await execFileAsync("git", ["worktree", "prune"], { cwd: repoRoot, timeout: 1e4 });
     } catch {
@@ -3854,6 +4573,21 @@ function ensureEmployee(employeeName, exeSession, projectDir, opts) {
       error: `Error: pass employee name ('${bare}'), not session name ('${employeeName}')`
     };
   }
+  {
+    const roster = loadEmployeesSync();
+    if (roster.length > 0) {
+      const base = baseAgentName(employeeName, roster);
+      const known = roster.some((e) => e.name.toLowerCase() === base.toLowerCase());
+      if (!known) {
+        const names = roster.map((e) => e.name).sort().join(", ");
+        return {
+          status: "failed",
+          sessionName: "",
+          error: `Unknown employee "${employeeName}" \u2014 not in the roster. Refusing to spawn a non-roster agent (task ids, typos, and stale names are rejected here). Known employees: ${names}. (bug 98476a80)`
+        };
+      }
+    }
+  }
   if (!isRootSession(exeSession)) {
     const root = extractRootExe(exeSession);
     if (root) {
@@ -4075,7 +4809,7 @@ async function ensureEmployeeAsync(employeeName, exeSession, projectDir, opts) {
   }
   try {
     const sessionName = employeeSessionName(employeeName, exeSession, asyncOpts.instance);
-    await exportBehaviorsAsync(employeeName, path7.basename(asyncOpts.cwd ?? projectDir), sessionName);
+    await exportBehaviorsAsync(employeeName, path8.basename(asyncOpts.cwd ?? projectDir), sessionName);
   } catch (err) {
     process.stderr.write(
       `[ensureEmployeeAsync] behavior export failed for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
@@ -4093,8 +4827,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
   const spawnStartedAt = Date.now();
   const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path7.join(os5.homedir(), ".exe-os", "session-logs");
-  const logFile = path7.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  const logDir = path8.join(os6.homedir(), ".exe-os", "session-logs");
+  const logFile = path8.join(logDir, `${instanceLabel}-${Date.now()}.log`);
   {
     const earlyRt = resolveSpawnRuntimeConfig(
       employeeName,
@@ -4130,24 +4864,24 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     runtime: opts?.runtimeOverride ?? null,
     payload: { hasCwdOverride: Boolean(opts?.cwd), autoInstance: Boolean(opts?.autoInstance) }
   });
-  if (!existsSync7(logDir)) {
-    mkdirSync3(logDir, { recursive: true });
+  if (!existsSync9(logDir)) {
+    mkdirSync6(logDir, { recursive: true });
   }
   transport.kill(sessionName, exeSession);
   let cleanupSuffix = "";
   try {
     const thisFile = fileURLToPath(import.meta.url);
-    const cleanupScript = path7.join(path7.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync7(cleanupScript)) {
+    const cleanupScript = path8.join(path8.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync9(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path7.join(os5.homedir(), ".claude.json");
+    const claudeJsonPath = path8.join(os6.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync4(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync6(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -4159,13 +4893,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   } catch {
   }
   try {
-    const settingsDir = path7.join(os5.homedir(), ".claude", "projects");
+    const settingsDir = path8.join(os6.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path7.join(settingsDir, normalizedKey);
-    const settingsPath = path7.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path8.join(settingsDir, normalizedKey);
+    const settingsPath = path8.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync4(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync6(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -4193,7 +4927,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync3(projSettingsDir, { recursive: true });
+      mkdirSync6(projSettingsDir, { recursive: true });
       atomicWriteSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   } catch {
@@ -4251,8 +4985,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const useBinSymlink = ccProvider !== DEFAULT_PROVIDER;
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath = path7.join(
-      os5.homedir(),
+    const identityPath = path8.join(
+      os6.homedir(),
       ".exe-os",
       "identity",
       `${employeeName}.md`
@@ -4267,13 +5001,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
 `
         );
       }
-    } else if (existsSync7(identityPath)) {
+    } else if (existsSync9(identityPath)) {
       legacyFallbackWarned = true;
     }
     if (!opts?.behaviorsExported) {
       const behaviorsFile = exportBehaviorsSync(
         employeeName,
-        path7.basename(spawnCwd),
+        path8.basename(spawnCwd),
         sessionName
       );
       void behaviorsFile;
@@ -4286,9 +5020,9 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     );
   }
   try {
-    const ctxDir = path7.join(os5.homedir(), ".exe-os", "session-cache");
-    mkdirSync3(ctxDir, { recursive: true });
-    const ctxFile = path7.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxDir = path8.join(os6.homedir(), ".exe-os", "session-cache");
+    mkdirSync6(ctxDir, { recursive: true });
+    const ctxFile = path8.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
@@ -4379,8 +5113,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   } else {
     let launcherAbs = "";
     try {
-      const launcherJs = path7.join(path7.dirname(fileURLToPath(import.meta.url)), "..", "bin", "exe-launch-agent.js");
-      if (existsSync7(launcherJs)) launcherAbs = launcherJs;
+      const launcherJs = path8.join(path8.dirname(fileURLToPath(import.meta.url)), "..", "bin", "exe-launch-agent.js");
+      if (existsSync9(launcherJs)) launcherAbs = launcherJs;
     } catch {
     }
     spawnCommand = launcherAbs ? `"${process.execPath}" "${launcherAbs}" --agent ${employeeName}${cleanupSuffix}` : `exe-launch-agent --agent ${employeeName}${cleanupSuffix}`;
@@ -4426,7 +5160,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path7.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    const dispatchInfo = path8.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
     atomicWriteJsonSync(dispatchInfo, {
       dispatchedBy: mySession,
       rootExe: exeSession,
@@ -4468,8 +5202,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     } else {
       spawnFailureCause = "timeout";
     }
-    const errMsg = `spawn did not start: tmux session "${sessionName}" never came alive within ${LIVENESS_CAP_MS / 1e3}s (${runtimeLabel} process failed to launch or exited immediately; cause=${spawnFailureCause}). Check ~/.exe-os/session-logs/${instanceLabel}-*.log \u2014 common cause: installed Claude Code does not support a launch flag, or the daemon PATH excludes the node/launcher bin dir (cause=path_not_found).`;
-    process.stderr.write(`[tmux-routing] SPAWN FAILED ${sessionName} (${spawnFailureCause}): ${errMsg}
+    const errMsg2 = `spawn did not start: tmux session "${sessionName}" never came alive within ${LIVENESS_CAP_MS / 1e3}s (${runtimeLabel} process failed to launch or exited immediately; cause=${spawnFailureCause}). Check ~/.exe-os/session-logs/${instanceLabel}-*.log \u2014 common cause: installed Claude Code does not support a launch flag, or the daemon PATH excludes the node/launcher bin dir (cause=path_not_found).`;
+    process.stderr.write(`[tmux-routing] SPAWN FAILED ${sessionName} (${spawnFailureCause}): ${errMsg2}
 `);
     recordOrchestrationEventBestEffort({
       eventType: "tmux.spawn.completed",
@@ -4487,7 +5221,39 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       errorCode: spawnFailureCause,
       payload: { spawnFailureCause, detail: "spawn_session_not_live", spawnCommand }
     });
-    return { sessionName, error: errMsg };
+    return { sessionName, error: errMsg2 };
+  }
+  if (useCodex) {
+    let pane = "";
+    try {
+      pane = transport.capturePane(sessionName, 80);
+    } catch {
+    }
+    if (isBlockedCodexPrompt(pane)) {
+      try {
+        execFileSync2("tmux", ["kill-session", "-t", sessionName], { timeout: 3e3 });
+      } catch {
+      }
+      releaseSpawnLock(sessionName);
+      const errMsg2 = `codex spawn blocked by an interactive model prompt in ${sessionName}; killed session so it can respawn non-interactively`;
+      process.stderr.write(`[tmux-routing] SPAWN FAILED ${sessionName} (codex_blocked_prompt): ${errMsg2}
+`);
+      recordOrchestrationEventBestEffort({
+        eventType: "tmux.spawn.completed",
+        source: "tmux-routing.spawnEmployee",
+        severity: "warn",
+        agentId: employeeName,
+        sessionScope: exeSession,
+        instanceId: opts?.instance != null ? String(opts.instance) : null,
+        tmuxSession: sessionName,
+        runtime: "codex",
+        durationMs: Date.now() - spawnStartedAt,
+        result: "failed",
+        errorCode: "codex_blocked_prompt",
+        payload: { detail: "interactive_model_prompt" }
+      });
+      return { sessionName, error: errMsg2 };
+    }
   }
   const POLL_CAP_MS = callerIsDaemon ? 0 : 45e3;
   const pollIterations = Math.ceil(POLL_CAP_MS / POLL_INTERVAL_MS);
@@ -4533,21 +5299,18 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
           exeSession,
           dispatchedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        const cachePath = path7.join(os5.homedir(), ".exe-os", "session-cache", `boot-cache-${sessionName}.json`);
-        writeFileSync2(cachePath, JSON.stringify(bootCache));
+        const cachePath = path8.join(os6.homedir(), ".exe-os", "session-cache", `boot-cache-${sessionName}.json`);
+        writeFileSync5(cachePath, JSON.stringify(bootCache));
       } catch {
       }
-      const _transport = transport;
-      const _session = sessionName;
-      const _emp = employeeName;
-      setTimeout(() => {
-        try {
-          _transport.sendKeysLiteral(_session, `You have pending tasks. Run list_tasks and start your highest priority task immediately.`);
-        } catch (e) {
-          process.stderr.write(`[tmux-routing] deferred nudge ${_emp}: ${e.message}
-`);
-        }
-      }, 1e4);
+      scheduleDeferredSpawnNudge({
+        sessionName,
+        employeeName,
+        exeSession,
+        runtime: useOpencode ? "opencode" : "claude",
+        transport,
+        message: `You have pending tasks. Run list_tasks and start your highest priority task immediately.`
+      });
     } else {
       try {
         transport.sendKeysLiteral(sessionName, `You have pending tasks. Run list_tasks and start immediately.`);
@@ -4598,6 +5361,105 @@ function isAmbiguousMultiCoordinatorContext() {
     return false;
   }
 }
+var MULTI_COORDINATOR_CACHE_TTL_MS = 5e3;
+var _multiCoordinatorCache = null;
+function normalizeProjectDir(dir) {
+  if (!dir || typeof dir !== "string") return "";
+  return dir.replace(/\/+$/, "");
+}
+function isMultiCoordinatorSharedProject(opts) {
+  if (process.env.EXE_STRICT_SESSION_SCOPE === "1") return true;
+  if (process.env.EXE_STRICT_SESSION_SCOPE === "0") return false;
+  const injected = opts?.sessions !== void 0;
+  if (!injected) {
+    if (process.env.VITEST === "true" || process.env.NODE_ENV === "test") return false;
+    const now = Date.now();
+    if (_multiCoordinatorCache && now - _multiCoordinatorCache.at < MULTI_COORDINATOR_CACHE_TTL_MS) {
+      return _multiCoordinatorCache.value;
+    }
+  }
+  let value = false;
+  try {
+    const sessions = opts?.sessions ?? listSessions();
+    let liveTmuxSet = null;
+    if (opts && "liveTmux" in opts) {
+      liveTmuxSet = opts.liveTmux ? new Set(opts.liveTmux) : null;
+    } else if (!injected) {
+      try {
+        liveTmuxSet = new Set(getTransport().listSessions());
+      } catch {
+        liveTmuxSet = null;
+      }
+    }
+    const roots = sessions.filter(
+      (s) => s.windowName && !s.windowName.includes("-") && (!liveTmuxSet || liveTmuxSet.has(s.windowName))
+    );
+    outer: for (let i = 0; i < roots.length; i++) {
+      const a = normalizeProjectDir(roots[i].projectDir);
+      if (!a) continue;
+      for (let j = i + 1; j < roots.length; j++) {
+        if (roots[i].windowName === roots[j].windowName) continue;
+        const b = normalizeProjectDir(roots[j].projectDir);
+        if (!b) continue;
+        if (a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`)) {
+          value = true;
+          break outer;
+        }
+      }
+    }
+  } catch {
+    value = false;
+  }
+  if (!injected) _multiCoordinatorCache = { at: Date.now(), value };
+  return value;
+}
+function isScopeCoordinatorDead(scope, opts) {
+  if (!isValidSessionScope(scope)) return false;
+  const injected = opts?.sessions !== void 0 || opts !== void 0 && "liveTmux" in opts;
+  if (!injected && (process.env.VITEST === "true" || process.env.NODE_ENV === "test")) {
+    return false;
+  }
+  let registryReadable = false;
+  try {
+    const sessions = opts?.sessions ?? listSessions();
+    registryReadable = true;
+    if (sessions.some((s) => s.windowName === scope)) return false;
+  } catch {
+    registryReadable = false;
+  }
+  let tmuxReadable = false;
+  try {
+    const live = opts && "liveTmux" in opts ? opts.liveTmux ?? [] : getTransport().listSessions();
+    tmuxReadable = opts && "liveTmux" in opts ? opts.liveTmux !== null : true;
+    if (live.includes(scope)) return false;
+  } catch {
+    tmuxReadable = false;
+  }
+  return registryReadable || tmuxReadable;
+}
+function allowDeadScopeRescue(taskId, rowScope, currentScope, opts) {
+  if (!isScopeCoordinatorDead(rowScope, opts)) return false;
+  process.stderr.write(
+    `[dead-scope rescue] task ${taskId} (scope ${rowScope}, dead) mutated by ${currentScope}
+`
+  );
+  void (async () => {
+    try {
+      const { getClient: getClient2 } = await import("./lib/database.js");
+      const note = `
+
+[dead-scope rescue ${(/* @__PURE__ */ new Date()).toISOString()}] Owning coordinator "${rowScope}" is dead; mutation allowed from "${currentScope}".`;
+      await getClient2().execute({
+        sql: `UPDATE tasks
+              SET context = COALESCE(context, '') || ?, updated_at = ?
+              WHERE id = ? AND (context IS NULL OR context NOT LIKE '%[dead-scope rescue%')`,
+        args: [note, (/* @__PURE__ */ new Date()).toISOString(), taskId]
+      });
+    } catch {
+    }
+  })();
+  return true;
+}
 function getCurrentSessionScope() {
   if (process.env.VITEST === "true" || process.env.NODE_ENV === "test") {
     return null;
@@ -4618,7 +5480,7 @@ function getCurrentSessionScope() {
   }
 }
 var _scopeWarningEmitted = false;
-function sessionScopeFilter(sessionScope, tableAlias) {
+function sessionScopeFilter(sessionScope, tableAlias, opts) {
   const autoDetect = sessionScope === void 0;
   const scope = autoDetect ? getCurrentSessionScope() : sessionScope;
   if (!scope) {
@@ -4628,6 +5490,10 @@ function sessionScopeFilter(sessionScope, tableAlias) {
     return { sql: "", args: [] };
   }
   const col = tableAlias ? `${tableAlias}.session_scope` : "session_scope";
+  const strict = opts?.strictSession ?? isMultiCoordinatorSharedProject();
+  if (strict) {
+    return { sql: ` AND ${col} = ?`, args: [scope] };
+  }
   return {
     sql: ` AND (${col} IS NULL OR ${col} = ?)`,
     args: [scope]
@@ -4656,10 +5522,12 @@ export {
   claudeSupportsAgentFlag,
   PROVIDER_TABLE,
   DEFAULT_PROVIDER,
-  logTaskDispatch,
   isValidSessionScope,
   sanitizeSessionScope,
   isAmbiguousMultiCoordinatorContext,
+  isMultiCoordinatorSharedProject,
+  isScopeCoordinatorDead,
+  allowDeadScopeRescue,
   getCurrentSessionScope,
   sessionScopeFilter,
   strictSessionScopeFilter,
@@ -4671,6 +5539,13 @@ export {
   markDoneTaskNotificationsAsRead,
   formatNotifications,
   migrateJsonNotifications,
+  readQueue,
+  queueIntercom,
+  drainQueue,
+  drainForSession,
+  clearQueueForAgent,
+  _resetDrainGuard,
+  logTaskDispatch,
   DEFAULT_TASK_PRIORITY,
   normalizeTaskPriority,
   isStructuredTaskCompletionReport,
@@ -4678,14 +5553,17 @@ export {
   writeCheckpoint,
   extractParentFromContext,
   slugify,
+  checkLaneAffinity,
   resolveTask,
   createTaskCore,
   queryTaskRows,
   listTasks,
   isTmuxSessionAlive,
   TASK_ALREADY_CLAIMED_PREFIX,
+  VALID_TASK_STATUSES,
   checkStaleCompletion,
   updateTaskStatus,
+  reopenTask,
   deleteTaskCore,
   ensureArchitectureDoc,
   ensureGitignoreExe,
@@ -4698,15 +5576,17 @@ export {
   checkAndFireBarriers,
   checkTaskFileConsistency,
   formatAge,
+  STALE_REVIEW_AGE_MS,
+  SIGNAL_FILE_TTL_MS,
   isStale,
   countPendingReviews,
   countNewPendingReviewsSince,
   listPendingReviews,
+  sweepExpiredSignalFiles,
   cleanupOrphanedReviews,
   getReviewChecklist,
   createReviewForCompletedTask,
   cleanupReviewFile,
-  formatIntercomPrompt,
   _resetExeBinDirCache,
   buildSpawnPath,
   acquireSpawnLock,
@@ -4727,6 +5607,11 @@ export {
   getSessionState,
   isSessionBusy,
   isExeSession,
+  paneHasPendingInput,
+  isBlockedCodexPrompt,
+  sessionHasPendingInput,
+  decideQueuedNudgeDrain,
+  countScopedPendingReviews,
   sendIntercom,
   sendIntercomAsync,
   notifyParentExe,