@askexenow/exe-os 0.8.41 → 0.8.43

package/dist/hooks/prompt-submit.js

@@ -575,6 +575,13 @@ async function ensureSchema() {
     });
   } catch {
   }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN session_scope TEXT`,
+      args: []
+    });
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
@@ -1021,6 +1028,18 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_session_kills_agent
       ON session_kills(agent_id);
   `);
+  await client.execute(`
+    CREATE TABLE IF NOT EXISTS global_procedures (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      priority TEXT NOT NULL DEFAULT 'p0',
+      domain TEXT,
+      active INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS conversations (
       id              TEXT PRIMARY KEY,
@@ -1228,6 +1247,61 @@ var init_keychain = __esm({
   }
 });
 
+// src/lib/state-bus.ts
+var StateBus, orgBus;
+var init_state_bus = __esm({
+  "src/lib/state-bus.ts"() {
+    "use strict";
+    StateBus = class {
+      handlers = /* @__PURE__ */ new Map();
+      globalHandlers = /* @__PURE__ */ new Set();
+      /** Emit an event to all subscribers */
+      emit(event) {
+        const typeHandlers = this.handlers.get(event.type);
+        if (typeHandlers) {
+          for (const handler of typeHandlers) {
+            try {
+              handler(event);
+            } catch {
+            }
+          }
+        }
+        for (const handler of this.globalHandlers) {
+          try {
+            handler(event);
+          } catch {
+          }
+        }
+      }
+      /** Subscribe to a specific event type */
+      on(type, handler) {
+        if (!this.handlers.has(type)) {
+          this.handlers.set(type, /* @__PURE__ */ new Set());
+        }
+        this.handlers.get(type).add(handler);
+      }
+      /** Subscribe to ALL events */
+      onAny(handler) {
+        this.globalHandlers.add(handler);
+      }
+      /** Unsubscribe from a specific event type */
+      off(type, handler) {
+        this.handlers.get(type)?.delete(handler);
+      }
+      /** Unsubscribe from ALL events */
+      offAny(handler) {
+        this.globalHandlers.delete(handler);
+      }
+      /** Remove all listeners */
+      clear() {
+        this.handlers.clear();
+        this.globalHandlers.clear();
+      }
+    };
+    orgBus = new StateBus();
+  }
+});
+
 // src/lib/shard-manager.ts
 var shard_manager_exports = {};
 __export(shard_manager_exports, {
@@ -1469,6 +1543,71 @@ var init_shard_manager = __esm({
   }
 });
 
+// src/lib/global-procedures.ts
+var global_procedures_exports = {};
+__export(global_procedures_exports, {
+  deactivateGlobalProcedure: () => deactivateGlobalProcedure,
+  getGlobalProceduresBlock: () => getGlobalProceduresBlock,
+  loadGlobalProcedures: () => loadGlobalProcedures,
+  storeGlobalProcedure: () => storeGlobalProcedure
+});
+import { randomUUID } from "crypto";
+async function loadGlobalProcedures() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM global_procedures WHERE active = 1 ORDER BY priority ASC, created_at ASC",
+    args: []
+  });
+  const procedures = result.rows;
+  if (procedures.length > 0) {
+    _cache = procedures.map((p) => `### ${p.title}
+${p.content}`).join("\n\n");
+  } else {
+    _cache = "";
+  }
+  _cacheLoaded = true;
+  return procedures;
+}
+function getGlobalProceduresBlock() {
+  if (!_cacheLoaded) return "";
+  if (!_cache) return "";
+  return `## Organization-Wide Procedures (MANDATORY \u2014 supersedes all other rules)
+
+${_cache}
+`;
+}
+async function storeGlobalProcedure(input2) {
+  const id = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  await client.execute({
+    sql: `INSERT INTO global_procedures (id, title, content, priority, domain, active, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
+    args: [id, input2.title, input2.content, input2.priority ?? "p0", input2.domain ?? null, now, now]
+  });
+  await loadGlobalProcedures();
+  return id;
+}
+async function deactivateGlobalProcedure(id) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  const result = await client.execute({
+    sql: "UPDATE global_procedures SET active = 0, updated_at = ? WHERE id = ?",
+    args: [now, id]
+  });
+  await loadGlobalProcedures();
+  return result.rowsAffected > 0;
+}
+var _cache, _cacheLoaded;
+var init_global_procedures = __esm({
+  "src/lib/global-procedures.ts"() {
+    "use strict";
+    init_database();
+    _cache = "";
+    _cacheLoaded = false;
+  }
+});
+
 // src/lib/store.ts
 var store_exports = {};
 __export(store_exports, {
@@ -1548,6 +1687,11 @@ async function initStore(options) {
     "version-query"
   );
   _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
+  try {
+    const { loadGlobalProcedures: loadGlobalProcedures2 } = await Promise.resolve().then(() => (init_global_procedures(), global_procedures_exports));
+    await loadGlobalProcedures2();
+  } catch {
+  }
 }
 function classifyTier(record) {
   if (record.tool_name === "commit_to_long_term_memory" && (record.importance ?? 0) >= 8) return 1;
@@ -1589,6 +1733,12 @@ async function writeMemory(record) {
     supersedes_id: record.supersedes_id ?? null
   };
   _pendingRecords.push(dbRow);
+  orgBus.emit({
+    type: "memory_stored",
+    agentId: record.agent_id,
+    project: record.project_name,
+    timestamp: record.timestamp
+  });
   const MAX_PENDING = 1e3;
   if (_pendingRecords.length > MAX_PENDING) {
     const dropped = _pendingRecords.length - MAX_PENDING;
@@ -1934,6 +2084,7 @@ var init_store = __esm({
     init_database();
     init_keychain();
     init_config();
+    init_state_bus();
     INIT_MAX_RETRIES = 3;
     INIT_RETRY_DELAY_MS = 1e3;
     _pendingRecords = [];
@@ -2037,7 +2188,7 @@ var init_self_query_router = __esm({
 // src/lib/exe-daemon-client.ts
 import net from "net";
 import { spawn } from "child_process";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { existsSync as existsSync4, unlinkSync, readFileSync as readFileSync2, openSync, closeSync, statSync } from "fs";
 import path4 from "path";
 import { fileURLToPath } from "url";
@@ -2229,7 +2380,7 @@ function sendRequest(texts, priority) {
       resolve({ error: "Not connected" });
       return;
     }
-    const id = randomUUID();
+    const id = randomUUID2();
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve({ error: "Request timeout" });
@@ -2247,7 +2398,7 @@ function sendRequest(texts, priority) {
 async function pingDaemon() {
   if (!_socket || !_connected) return null;
   return new Promise((resolve) => {
-    const id = randomUUID();
+    const id = randomUUID2();
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve(null);
@@ -2413,8 +2564,8 @@ async function embedDirect(text) {
   const llamaCpp = await import("node-llama-cpp");
   const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
   const { existsSync: existsSync17 } = await import("fs");
-  const path19 = await import("path");
-  const modelPath = path19.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  const path21 = await import("path");
+  const modelPath = path21.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
   if (!existsSync17(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
@@ -3128,7 +3279,7 @@ function queueIntercom(targetSession, reason) {
   }
   writeQueue(queue);
 }
-function drainQueue(isSessionBusy, sendKeys) {
+function drainQueue(isSessionBusy2, sendKeys) {
   const queue = readQueue();
   if (queue.length === 0) return { drained: 0, failed: 0 };
   const remaining = [];
@@ -3142,7 +3293,7 @@ function drainQueue(isSessionBusy, sendKeys) {
       continue;
     }
     try {
-      if (!isSessionBusy(item.targetSession)) {
+      if (!isSessionBusy2(item.targetSession)) {
         const success = sendKeys(item.targetSession);
         if (success) {
           logQueue(`DRAINED \u2192 ${item.targetSession} (after ${item.attempts} retries)`);
@@ -3214,21 +3365,36 @@ async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
     return [];
   }
 }
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync9(employeesPath)) return [];
+  try {
+    return JSON.parse(readFileSync7(employeesPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
 function getEmployee(employees, name) {
   return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
 }
-var EMPLOYEES_PATH;
+function isMultiInstance(agentName, employees) {
+  const roster = employees ?? loadEmployeesSync();
+  const emp = getEmployee(roster, agentName);
+  if (!emp) return false;
+  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
+}
+var EMPLOYEES_PATH, MULTI_INSTANCE_ROLES;
 var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
     init_config();
     EMPLOYEES_PATH = path11.join(EXE_AI_DIR, "exe-employees.json");
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
   }
 });
 
 // src/lib/license.ts
 import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, existsSync as existsSync10, mkdirSync as mkdirSync5 } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import path12 from "path";
 import { jwtVerify, importSPKI } from "jose";
 var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, PLAN_LIMITS;
@@ -3327,1287 +3493,2666 @@ var init_plan_limits = __esm({
   }
 });
 
-// src/lib/tmux-routing.ts
-import { execFileSync as execFileSync2, execSync as execSync7 } from "child_process";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, existsSync as existsSync12, appendFileSync } from "fs";
+// src/lib/notifications.ts
+import crypto3 from "crypto";
 import path14 from "path";
 import os5 from "os";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { unlinkSync as unlinkSync3 } from "fs";
-function spawnLockPath(sessionName) {
-  return path14.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
-}
-function isProcessAlive(pid) {
+import {
+  readFileSync as readFileSync10,
+  readdirSync as readdirSync4,
+  unlinkSync as unlinkSync3,
+  existsSync as existsSync12,
+  rmdirSync
+} from "fs";
+async function writeNotification(notification) {
   try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function acquireSpawnLock2(sessionName) {
-  if (!existsSync12(SPAWN_LOCK_DIR)) {
-    mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
-  }
-  const lockFile = spawnLockPath(sessionName);
-  if (existsSync12(lockFile)) {
-    try {
-      const lock = JSON.parse(readFileSync10(lockFile, "utf8"));
-      const age = Date.now() - lock.timestamp;
-      if (isProcessAlive(lock.pid) && age < 6e4) {
-        return false;
-      }
-    } catch {
-    }
+    const client = getClient();
+    const id = crypto3.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await client.execute({
+      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?)`,
+      args: [
+        id,
+        notification.agentId,
+        notification.agentRole,
+        notification.event,
+        notification.project,
+        notification.summary,
+        notification.taskFile ?? null,
+        now
+      ]
+    });
+  } catch (err) {
+    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
+`);
   }
-  writeFileSync5(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
-  return true;
 }
-function releaseSpawnLock2(sessionName) {
+async function markAsReadByTaskFile(taskFile) {
   try {
-    unlinkSync3(spawnLockPath(sessionName));
+    const client = getClient();
+    await client.execute({
+      sql: "UPDATE notifications SET read = 1 WHERE task_file = ? AND read = 0",
+      args: [taskFile]
+    });
   } catch {
   }
 }
-function resolveBehaviorsExporterScript() {
-  try {
-    const thisFile = fileURLToPath2(import.meta.url);
-    const scriptPath = path14.join(
-      path14.dirname(thisFile),
-      "..",
-      "bin",
-      "exe-export-behaviors.js"
-    );
-    return existsSync12(scriptPath) ? scriptPath : null;
-  } catch {
-    return null;
+var init_notifications = __esm({
+  "src/lib/notifications.ts"() {
+    "use strict";
+    init_database();
   }
-}
-function exportBehaviorsSync(agentId, projectName, sessionKey) {
-  const script = resolveBehaviorsExporterScript();
-  if (!script) return null;
+});
+
+// src/lib/session-kill-telemetry.ts
+import crypto4 from "crypto";
+async function recordSessionKill(input2) {
   try {
-    const output = execFileSync2(
-      process.execPath,
-      [script, agentId, projectName, sessionKey],
-      { encoding: "utf-8", timeout: BEHAVIORS_EXPORT_TIMEOUT_MS }
-    ).trim();
-    return output.length > 0 ? output : null;
+    const client = getClient();
+    await client.execute({
+      sql: `INSERT INTO session_kills
+              (id, session_name, agent_id, killed_at, reason,
+               ticks_idle, estimated_tokens_saved)
+            VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        crypto4.randomUUID(),
+        input2.sessionName,
+        input2.agentId,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        input2.reason,
+        input2.ticksIdle ?? null,
+        input2.estimatedTokensSaved ?? null
+      ]
+    });
   } catch (err) {
     process.stderr.write(
-      `[tmux-routing] behaviors export failed for ${agentId}: ${err instanceof Error ? err.message : String(err)}
+      `[session-kill-telemetry] write failed: ${err instanceof Error ? err.message : String(err)}
 `
     );
-    return null;
   }
 }
-function getMySession() {
-  return getTransport().getMySession();
-}
-function employeeSessionName(employee, exeSession, instance) {
-  const suffix = instance != null && instance > 0 ? String(instance) : "";
-  return `${employee}${suffix}-${exeSession}`;
-}
-function extractRootExe(name) {
-  const match = name.match(/(exe\d+)$/);
-  return match?.[1] ?? null;
-}
-function getParentExe(sessionKey) {
-  try {
-    const data = JSON.parse(readFileSync10(path14.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
-    return data.parentExe || null;
-  } catch {
-    return null;
+var init_session_kill_telemetry = __esm({
+  "src/lib/session-kill-telemetry.ts"() {
+    "use strict";
+    init_database();
   }
-}
-function resolveExeSession() {
-  const mySession = getMySession();
-  if (!mySession) return null;
-  try {
-    const key = getSessionKey();
-    const parentExe = getParentExe(key);
-    if (parentExe) {
-      return extractRootExe(parentExe) ?? parentExe;
-    }
-  } catch {
+});
+
+// src/lib/tasks-crud.ts
+import crypto5 from "crypto";
+import path15 from "path";
+import { execSync as execSync7 } from "child_process";
+import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
+async function writeCheckpoint(input2) {
+  const client = getClient();
+  const row = await resolveTask(client, input2.taskId);
+  const taskId = String(row.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const blockedByIds = [];
+  if (row.blocked_by) {
+    blockedByIds.push(String(row.blocked_by));
+  }
+  const checkpoint = {
+    step: input2.step,
+    context_summary: input2.contextSummary,
+    files_touched: input2.filesTouched ?? [],
+    blocked_by_ids: blockedByIds,
+    last_checkpoint_at: now
+  };
+  const result = await client.execute({
+    sql: `UPDATE tasks SET checkpoint = ?, checkpoint_count = checkpoint_count + 1, updated_at = ? WHERE id = ?`,
+    args: [JSON.stringify(checkpoint), now, taskId]
+  });
+  if (result.rowsAffected === 0) {
+    throw new Error(`Checkpoint write failed: task ${taskId} not found`);
   }
-  return extractRootExe(mySession) ?? mySession;
-}
-function isEmployeeAlive(sessionName) {
-  return getTransport().isAlive(sessionName);
+  const countResult = await client.execute({
+    sql: "SELECT checkpoint_count FROM tasks WHERE id = ?",
+    args: [taskId]
+  });
+  const checkpointCount = Number(countResult.rows[0]?.checkpoint_count ?? 1);
+  return { checkpointCount };
 }
-function findFreeInstance(employeeName, exeSession, maxInstances = 10, isAlive = isEmployeeAlive) {
-  const base = employeeSessionName(employeeName, exeSession);
-  if (!isAlive(base) && acquireSpawnLock2(base)) return 0;
-  for (let i = 2; i <= maxInstances; i++) {
-    const candidate = employeeSessionName(employeeName, exeSession, i);
-    if (!isAlive(candidate) && acquireSpawnLock2(candidate)) return i;
-  }
-  return null;
+function extractParentFromContext(contextBody) {
+  if (!contextBody) return null;
+  const match = contextBody.match(
+    /Parent task:\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i
+  );
+  return match ? match[1].toLowerCase() : null;
 }
-function readDebounceState() {
-  try {
-    if (!existsSync12(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync10(DEBOUNCE_FILE, "utf8"));
-  } catch {
-    return {};
-  }
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
-function writeDebounceState(state) {
-  try {
-    if (!existsSync12(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
-    writeFileSync5(DEBOUNCE_FILE, JSON.stringify(state));
-  } catch {
+async function resolveTask(client, identifier) {
+  let result = await client.execute({
+    sql: "SELECT * FROM tasks WHERE id = ?",
+    args: [identifier]
+  });
+  if (result.rows.length === 1) return result.rows[0];
+  result = await client.execute({
+    sql: "SELECT * FROM tasks WHERE task_file LIKE ?",
+    args: [`%${identifier}%`]
+  });
+  if (result.rows.length === 1) return result.rows[0];
+  if (result.rows.length > 1) {
+    const exact = result.rows.filter(
+      (r) => String(r.task_file).endsWith(`/${identifier}.md`)
+    );
+    if (exact.length === 1) return exact[0];
+    const candidates = exact.length > 1 ? exact : result.rows;
+    const active = candidates.filter(
+      (r) => !["done", "cancelled"].includes(String(r.status))
+    );
+    if (active.length === 1) return active[0];
+    const matches = (active.length > 1 ? active : candidates).map((r) => `${String(r.task_file)} (${String(r.status)}, ${String(r.id)})`).join(", ");
+    throw new Error(
+      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
+    );
   }
-}
-function isDebounced(targetSession) {
-  const state = readDebounceState();
-  const lastSent = state[targetSession] ?? 0;
-  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
-}
-function recordDebounce(targetSession) {
-  const state = readDebounceState();
-  state[targetSession] = Date.now();
-  const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
-  for (const key of Object.keys(state)) {
-    if ((state[key] ?? 0) < cutoff) delete state[key];
+  result = await client.execute({
+    sql: "SELECT * FROM tasks WHERE title LIKE ?",
+    args: [`%${identifier}%`]
+  });
+  if (result.rows.length === 1) return result.rows[0];
+  if (result.rows.length > 1) {
+    const active = result.rows.filter(
+      (r) => !["done", "cancelled"].includes(String(r.status))
+    );
+    if (active.length === 1) return active[0];
+    const matches = (active.length > 1 ? active : result.rows).map((r) => `"${String(r.title)}" (${String(r.status)}, ${String(r.id)})`).join(", ");
+    throw new Error(
+      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
+    );
   }
-  writeDebounceState(state);
+  throw new Error(`Task not found: ${identifier}`);
 }
-function logIntercom(msg) {
-  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
-`;
-  process.stderr.write(`[intercom] ${msg}
-`);
-  try {
-    appendFileSync(INTERCOM_LOG2, line);
-  } catch {
+async function createTaskCore(input2) {
+  const client = getClient();
+  const id = crypto5.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const slug = slugify(input2.title);
+  const taskFile = input2.taskFile ?? `exe/${input2.assignedTo}/${slug}.md`;
+  let blockedById = null;
+  const initialStatus = input2.blockedBy ? "blocked" : "open";
+  if (input2.blockedBy) {
+    const blocker = await resolveTask(client, input2.blockedBy);
+    blockedById = String(blocker.id);
   }
-}
-function getSessionState(sessionName) {
-  const transport = getTransport();
-  if (!transport.isAlive(sessionName)) return "offline";
-  try {
-    const pane = transport.capturePane(sessionName, 5);
-    if (!pane.includes("\u276F") && !pane.includes("Claude Code") && !BUSY_PATTERN.test(pane) && !/Running…/.test(pane)) {
-      if (/\$\s*$/.test(pane) || /% $/.test(pane.trimEnd())) {
-        return "no_claude";
+  let parentTaskId = null;
+  let parentRef = input2.parentTaskId;
+  if (!parentRef) {
+    const extracted = extractParentFromContext(input2.context);
+    if (extracted) {
+      parentRef = extracted;
+      process.stderr.write(
+        "[create_task] auto-populated parent_task_id from context body \u2014 dispatchers should pass parent_task_id explicitly\n"
+      );
+    }
+  }
+  if (parentRef) {
+    try {
+      const parent = await resolveTask(client, parentRef);
+      parentTaskId = String(parent.id);
+    } catch (err) {
+      if (!input2.parentTaskId) {
+        throw new Error(
+          `create_task: parent reference "${parentRef}" in context body does not resolve to an existing task`
+        );
       }
+      throw err;
     }
-    if (/Running…/.test(pane)) return "tool";
-    if (BUSY_PATTERN.test(pane)) return "thinking";
-    return "idle";
+  }
+  let warning;
+  const dupCheck = await client.execute({
+    sql: "SELECT id FROM tasks WHERE title = ? AND assigned_to = ? AND status IN ('open', 'in_progress', 'blocked')",
+    args: [input2.title, input2.assignedTo]
+  });
+  if (dupCheck.rows.length > 0) {
+    warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
+  }
+  if (input2.baseDir) {
+    try {
+      await mkdir4(path15.join(input2.baseDir, "exe", "output"), { recursive: true });
+      await mkdir4(path15.join(input2.baseDir, "exe", "research"), { recursive: true });
+      await ensureArchitectureDoc(input2.baseDir, input2.projectName);
+      await ensureGitignoreExe(input2.baseDir);
+    } catch {
+    }
+  }
+  const complexity = input2.complexity ?? "standard";
+  let sessionScope = null;
+  try {
+    const { resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
+    sessionScope = resolveExeSession2();
   } catch {
-    return "offline";
   }
+  await client.execute({
+    sql: `INSERT INTO tasks (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, blocked_by, parent_task_id, reviewer, context, complexity, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at, session_scope, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      id,
+      input2.title,
+      input2.assignedTo,
+      input2.assignedBy,
+      input2.projectName,
+      input2.priority,
+      initialStatus,
+      taskFile,
+      blockedById,
+      parentTaskId,
+      input2.reviewer ?? null,
+      input2.context,
+      complexity,
+      input2.budgetTokens ?? null,
+      input2.budgetFallbackModel ?? null,
+      0,
+      null,
+      sessionScope,
+      now,
+      now
+    ]
+  });
+  return {
+    id,
+    title: input2.title,
+    assignedTo: input2.assignedTo,
+    assignedBy: input2.assignedBy,
+    projectName: input2.projectName,
+    priority: input2.priority,
+    status: initialStatus,
+    taskFile,
+    createdAt: now,
+    updatedAt: now,
+    warning,
+    budgetTokens: input2.budgetTokens ?? null,
+    budgetFallbackModel: input2.budgetFallbackModel ?? null,
+    tokensUsed: 0,
+    tokensWarnedAt: null
+  };
 }
-function isExeSession(sessionName) {
-  return /^exe\d*$/.test(sessionName);
-}
-function sendIntercom(targetSession) {
-  const transport = getTransport();
-  if (isExeSession(targetSession)) {
-    logIntercom(`SKIP_EXE \u2192 ${targetSession} (exe sessions use prompt-submit hook)`);
-    return "skipped_exe";
+async function listTasks(input2) {
+  const client = getClient();
+  const conditions = [];
+  const args = [];
+  if (input2.assignedTo) {
+    conditions.push("assigned_to = ?");
+    args.push(input2.assignedTo);
   }
-  if (isDebounced(targetSession)) {
-    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
-    return "debounced";
+  if (input2.status) {
+    conditions.push("status = ?");
+    args.push(input2.status);
+  } else {
+    conditions.push("status IN ('open', 'in_progress', 'blocked')");
+  }
+  if (input2.projectName) {
+    conditions.push("project_name = ?");
+    args.push(input2.projectName);
+  }
+  if (input2.priority) {
+    conditions.push("priority = ?");
+    args.push(input2.priority);
   }
   try {
-    const sessions = transport.listSessions();
-    if (!sessions.includes(targetSession)) {
-      logIntercom(`SKIP \u2192 ${targetSession} (session not found)`);
-      return "failed";
-    }
-    const sessionState = getSessionState(targetSession);
-    if (sessionState === "no_claude") {
-      queueIntercom(targetSession, "claude not running in session");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process \u2014 raw shell detected)`);
-      return "queued";
-    }
-    if (sessionState === "thinking" || sessionState === "tool") {
-      queueIntercom(targetSession, "session busy at send time");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (session busy, will retry from queue)`);
-      return "queued";
-    }
-    if (transport.isPaneInCopyMode(targetSession)) {
-      logIntercom(`COPY_MODE \u2192 ${targetSession} (exiting copy mode first)`);
-      transport.sendKeys(targetSession, "q");
+    const { resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
+    const session = resolveExeSession2();
+    if (session) {
+      conditions.push("(session_scope IS NULL OR session_scope = ?)");
+      args.push(session);
     }
-    transport.sendKeys(targetSession, "/exe-intercom");
-    recordDebounce(targetSession);
-    logIntercom(`DELIVERED \u2192 ${targetSession} (fire-and-forget)`);
-    return "delivered";
   } catch {
-    logIntercom(`FAIL \u2192 ${targetSession}`);
-    return "failed";
   }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const result = await client.execute({
+    sql: `SELECT * FROM tasks ${where} ORDER BY CASE status WHEN 'blocked' THEN 0 WHEN 'in_progress' THEN 1 WHEN 'open' THEN 2 ELSE 3 END, priority ASC, created_at DESC LIMIT 1000`,
+    args
+  });
+  return result.rows.map((r) => ({
+    id: String(r.id),
+    title: String(r.title),
+    assignedTo: String(r.assigned_to),
+    assignedBy: String(r.assigned_by),
+    projectName: String(r.project_name),
+    priority: String(r.priority),
+    status: String(r.status),
+    taskFile: String(r.task_file),
+    createdAt: String(r.created_at),
+    updatedAt: String(r.updated_at),
+    checkpointCount: Number(r.checkpoint_count ?? 0),
+    budgetTokens: r.budget_tokens !== null ? Number(r.budget_tokens) : null,
+    budgetFallbackModel: r.budget_fallback_model !== null ? String(r.budget_fallback_model) : null,
+    tokensUsed: Number(r.tokens_used ?? 0),
+    tokensWarnedAt: r.tokens_warned_at !== null ? Number(r.tokens_warned_at) : null
+  }));
 }
-function ensureEmployee(employeeName, exeSession, projectDir, opts) {
-  if (employeeName === "exe") {
-    return { status: "failed", sessionName: "", error: "exe is the COO, not a dispatchable employee" };
-  }
+function checkStaleCompletion(taskContext, taskCreatedAt) {
+  if (!taskContext) return null;
+  if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
   try {
-    assertEmployeeLimitSync();
-  } catch (err) {
-    if (err instanceof PlanLimitError) {
-      return { status: "failed", sessionName: "", error: err.message };
+    const since = new Date(taskCreatedAt).toISOString();
+    const branch = execSync7(
+      "git rev-parse --abbrev-ref HEAD 2>/dev/null",
+      { encoding: "utf8", timeout: 3e3 }
+    ).trim();
+    const branchArg = branch && branch !== "HEAD" ? branch : "";
+    const commitCount = execSync7(
+      `git log --oneline --since="${since}" ${branchArg} 2>/dev/null | wc -l`,
+      { encoding: "utf8", timeout: 5e3 }
+    ).trim();
+    const count = parseInt(commitCount, 10);
+    if (count === 0) {
+      return "WARNING: task closed with no new commits since creation. Verify work was actually produced.";
     }
+    return null;
+  } catch {
+    return null;
   }
-  if (/-exe\d*$/.test(employeeName)) {
-    const bare = employeeName.replace(/-exe\d*$/, "").replace(/\d+$/, "");
-    return {
-      status: "failed",
-      sessionName: "",
-      error: `Error: pass employee name ('${bare}'), not session name ('${employeeName}')`
-    };
-  }
-  let effectiveInstance = opts?.instance;
-  if (effectiveInstance === void 0 && opts?.autoInstance) {
-    const free = findFreeInstance(
-      employeeName,
-      exeSession,
-      opts.maxAutoInstances ?? 10
+}
+async function updateTaskStatus(input2) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const row = await resolveTask(client, input2.taskId);
+  const taskId = String(row.id);
+  const taskFile = String(row.task_file);
+  if (input2.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)})
+`
     );
-    if (free === null) {
-      return {
-        status: "failed",
-        sessionName: employeeSessionName(employeeName, exeSession),
-        error: `All ${opts.maxAutoInstances ?? 10} instances of ${employeeName} are alive \u2014 cap reached`
-      };
+  }
+  if (input2.status === "done") {
+    const existingRow = await client.execute({
+      sql: "SELECT context, created_at FROM tasks WHERE id = ?",
+      args: [taskId]
+    });
+    if (existingRow.rows.length > 0) {
+      const ctx = existingRow.rows[0];
+      const warning = checkStaleCompletion(ctx.context, ctx.created_at);
+      if (warning) {
+        input2.result = input2.result ? `\u26A0\uFE0F ${warning}
+
+${input2.result}` : `\u26A0\uFE0F ${warning}`;
+        process.stderr.write(`[tasks] ${warning} (task: ${taskId})
+`);
+      }
     }
-    effectiveInstance = free === 0 ? void 0 : free;
   }
-  const sessionName = employeeSessionName(employeeName, exeSession, effectiveInstance);
-  if (isEmployeeAlive(sessionName)) {
-    const result2 = sendIntercom(sessionName);
-    if (result2 === "acknowledged" || result2 === "skipped_exe" || result2 === "debounced" || result2 === "queued") {
-      return { status: "intercom_sent", sessionName };
+  if (input2.status === "in_progress") {
+    const tmuxSession = process.env.TMUX_PANE ?? process.env.MY_TMUX_SESSION ?? "unknown";
+    const claim = await client.execute({
+      sql: `UPDATE tasks
+            SET status = 'in_progress', assigned_tmux = ?, updated_at = ?
+            WHERE id = ? AND status = 'open'`,
+      args: [tmuxSession, now, taskId]
+    });
+    if (claim.rowsAffected === 0) {
+      const current = await client.execute({
+        sql: "SELECT status, assigned_tmux FROM tasks WHERE id = ?",
+        args: [taskId]
+      });
+      const cur = current.rows[0];
+      const status = cur?.status ?? "unknown";
+      const claimedBy = cur?.assigned_tmux ? ` (claimed by ${cur.assigned_tmux})` : "";
+      throw new Error(`${TASK_ALREADY_CLAIMED_PREFIX}: task ${taskId} is ${status}${claimedBy}`);
     }
-    if (result2 === "delivered") {
-      return { status: "intercom_unprocessed", sessionName };
+    try {
+      await writeCheckpoint({
+        taskId,
+        step: "claimed",
+        contextSummary: `Task claimed by session. Transitioning open \u2192 in_progress.`
+      });
+    } catch {
     }
-    return { status: "failed", sessionName, error: "intercom delivery failed" };
-  }
-  const spawnOpts = { ...opts, instance: effectiveInstance };
-  const result = spawnEmployee(employeeName, exeSession, projectDir, spawnOpts);
-  if (result.error) {
-    return { status: "failed", sessionName, error: result.error };
+    return { row, taskFile, now, taskId };
   }
-  return { status: "spawned", sessionName };
-}
-function spawnEmployee(employeeName, exeSession, projectDir, opts) {
-  const transport = getTransport();
-  const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
-  const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path14.join(os5.homedir(), ".exe-os", "session-logs");
-  const logFile = path14.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync12(logDir)) {
-    mkdirSync6(logDir, { recursive: true });
+  if (input2.result) {
+    await client.execute({
+      sql: "UPDATE tasks SET status = ?, result = ?, updated_at = ? WHERE id = ?",
+      args: [input2.status, input2.result, now, taskId]
+    });
+  } else {
+    await client.execute({
+      sql: "UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?",
+      args: [input2.status, now, taskId]
+    });
   }
-  transport.kill(sessionName);
-  let cleanupSuffix = "";
   try {
-    const thisFile = fileURLToPath2(import.meta.url);
-    const cleanupScript = path14.join(path14.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync12(cleanupScript)) {
-      cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
-    }
+    await writeCheckpoint({
+      taskId,
+      step: `status_transition:${input2.status}`,
+      contextSummary: input2.result ? `Transitioned to ${input2.status}. Result: ${input2.result.slice(0, 500)}` : `Transitioned to ${input2.status}.`
+    });
   } catch {
   }
-  try {
-    const claudeJsonPath = path14.join(os5.homedir(), ".claude.json");
-    let claudeJson = {};
-    try {
-      claudeJson = JSON.parse(readFileSync10(claudeJsonPath, "utf8"));
-    } catch {
-    }
-    if (!claudeJson.projects) claudeJson.projects = {};
-    const projects = claudeJson.projects;
-    const trustDir = opts?.cwd ?? projectDir;
-    if (!projects[trustDir]) projects[trustDir] = {};
-    projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync5(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+  return { row, taskFile, now, taskId };
+}
+async function deleteTaskCore(taskId, _baseDir) {
+  const client = getClient();
+  const row = await resolveTask(client, taskId);
+  const id = String(row.id);
+  const taskFile = String(row.task_file);
+  const assignedTo = String(row.assigned_to);
+  const assignedBy = String(row.assigned_by);
+  await client.execute({ sql: "DELETE FROM tasks WHERE id = ?", args: [id] });
+  const taskSlug = taskFile.split("/").pop()?.replace(".md", "") ?? "";
+  return { taskFile, assignedTo, assignedBy, taskSlug };
+}
+async function ensureArchitectureDoc(baseDir, projectName) {
+  const archPath = path15.join(baseDir, "exe", "ARCHITECTURE.md");
+  try {
+    if (existsSync13(archPath)) return;
+    const template = [
+      `# ${projectName} \u2014 System Architecture`,
+      "",
+      "> Employees: read this before every task. Update it when you change system structure.",
+      `> Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+      "",
+      "## Overview",
+      "",
+      "<!-- Describe what this system does, its main components, and how they connect. -->",
+      "",
+      "## Key Components",
+      "",
+      "<!-- List the major modules, services, or subsystems. -->",
+      "",
+      "## Data Flow",
+      "",
+      "<!-- How does data move through the system? What writes where? -->",
+      "",
+      "## Invariants",
+      "",
+      "<!-- Rules that must never be violated. What breaks if these are wrong? -->",
+      "",
+      "## Dependencies",
+      "",
+      "<!-- What depends on what? If I change X, what else is affected? -->",
+      ""
+    ].join("\n");
+    await writeFile4(archPath, template, "utf-8");
   } catch {
   }
+}
+async function ensureGitignoreExe(baseDir) {
+  const gitignorePath = path15.join(baseDir, ".gitignore");
   try {
-    const settingsDir = path14.join(os5.homedir(), ".claude", "projects");
-    const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path14.join(settingsDir, normalizedKey);
-    const settingsPath = path14.join(projSettingsDir, "settings.json");
-    let settings = {};
-    try {
-      settings = JSON.parse(readFileSync10(settingsPath, "utf8"));
-    } catch {
-    }
-    const perms = settings.permissions ?? {};
-    const allow = perms.allow ?? [];
-    const toolNames = [
-      "recall_my_memory",
-      "store_memory",
-      "create_task",
-      "update_task",
-      "list_tasks",
-      "get_task",
-      "ask_team_memory",
-      "store_behavior",
-      "get_identity",
-      "send_message"
-    ];
-    const requiredTools = expandDualPrefixTools(toolNames);
-    let changed = false;
-    for (const tool of requiredTools) {
-      if (!allow.includes(tool)) {
-        allow.push(tool);
-        changed = true;
-      }
-    }
-    if (changed) {
-      perms.allow = allow;
-      settings.permissions = perms;
-      mkdirSync6(projSettingsDir, { recursive: true });
-      writeFileSync5(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    if (existsSync13(gitignorePath)) {
+      const content = readFileSync11(gitignorePath, "utf-8");
+      if (/^\/?exe\/?$/m.test(content)) return;
+      await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
+    } else {
+      await writeFile4(gitignorePath, "# Employee task assignments (private)\n/exe/\n", "utf-8");
     }
   } catch {
   }
-  const spawnCwd = opts?.cwd ?? projectDir;
-  const useExeAgent = !!(opts?.model && opts?.provider);
-  const ccProvider = useExeAgent ? DEFAULT_PROVIDER : detectActiveProvider();
-  const useBinSymlink = ccProvider !== DEFAULT_PROVIDER;
-  let identityFlag = "";
-  let behaviorsFlag = "";
-  let legacyFallbackWarned = false;
-  if (!useExeAgent && !useBinSymlink) {
-    const identityPath = path14.join(
-      os5.homedir(),
-      ".exe-os",
-      "identity",
-      `${employeeName}.md`
-    );
-    _resetCcAgentSupportCache();
-    const hasAgentFlag = claudeSupportsAgentFlag();
-    if (hasAgentFlag) {
-      identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync12(identityPath)) {
-      identityFlag = ` --append-system-prompt-file ${identityPath}`;
-      legacyFallbackWarned = true;
-    }
-    const behaviorsFile = exportBehaviorsSync(
-      employeeName,
-      path14.basename(spawnCwd),
-      sessionName
-    );
-    if (behaviorsFile) {
-      behaviorsFlag = ` --append-system-prompt-file ${behaviorsFile}`;
-    }
+}
+var DELEGATION_KEYWORDS, TASK_ALREADY_CLAIMED_PREFIX;
+var init_tasks_crud = __esm({
+  "src/lib/tasks-crud.ts"() {
+    "use strict";
+    init_database();
+    DELEGATION_KEYWORDS = /parallel|delegate|wave|tom\d*-exe/i;
+    TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
   }
-  if (legacyFallbackWarned) {
+});
+
+// src/lib/tasks-review.ts
+var tasks_review_exports = {};
+__export(tasks_review_exports, {
+  cleanupOrphanedReviews: () => cleanupOrphanedReviews,
+  cleanupReviewFile: () => cleanupReviewFile,
+  countNewPendingReviewsSince: () => countNewPendingReviewsSince,
+  countPendingReviews: () => countPendingReviews,
+  createReviewForCompletedTask: () => createReviewForCompletedTask,
+  getReviewChecklist: () => getReviewChecklist,
+  listPendingReviews: () => listPendingReviews
+});
+import path16 from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync5, unlinkSync as unlinkSync4 } from "fs";
+async function countPendingReviews() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review'",
+    args: []
+  });
+  return Number(result.rows[0]?.cnt) || 0;
+}
+async function countNewPendingReviewsSince(sinceIso) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM tasks
+          WHERE status = 'needs_review' AND updated_at > ?`,
+    args: [sinceIso]
+  });
+  return Number(result.rows[0]?.cnt) || 0;
+}
+async function listPendingReviews(limit) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT title, assigned_to, project_name FROM tasks
+          WHERE status = 'needs_review'
+          ORDER BY priority ASC, created_at DESC LIMIT ?`,
+    args: [limit]
+  });
+  return result.rows;
+}
+async function cleanupOrphanedReviews() {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const r1 = await client.execute({
+    sql: `UPDATE tasks SET status = 'done', updated_at = ?
+          WHERE status = 'needs_review'
+          AND assigned_by = 'system'
+          AND title LIKE 'Review:%'
+          AND parent_task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'cancelled'))`,
+    args: [now]
+  });
+  const staleThreshold = new Date(Date.now() - 60 * 60 * 1e3).toISOString();
+  const r2 = await client.execute({
+    sql: `UPDATE tasks SET status = 'done', updated_at = ?
+          WHERE status = 'needs_review'
+          AND result IS NOT NULL
+          AND updated_at < ?`,
+    args: [now, staleThreshold]
+  });
+  const total = r1.rowsAffected + r2.rowsAffected;
+  if (total > 0) {
     process.stderr.write(
-      `[tmux-routing] claude --agent not supported by installed CC. Falling back to --append-system-prompt-file for ${employeeName}. Upgrade Claude Code to enable native --agent launch.
+      `[cleanup] Closed ${total} orphaned review(s): ${r1.rowsAffected} cascade + ${r2.rowsAffected} stale
 `
     );
   }
-  let sessionContextFlag = "";
-  try {
-    const ctxDir = path14.join(os5.homedir(), ".exe-os", "session-cache");
-    mkdirSync6(ctxDir, { recursive: true });
-    const ctxFile = path14.join(ctxDir, `session-context-${sessionName}.md`);
-    const ctxContent = [
-      `## Session Context`,
-      `You are running in tmux session: ${sessionName}.`,
-      `Your parent exe session is ${exeSession}.`,
-      `Your employees (if any) use the -${exeSession} suffix (e.g., tom-${exeSession}).`
-    ].join("\n");
-    writeFileSync5(ctxFile, ctxContent);
-    sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
-  } catch {
-  }
-  let envPrefix = `EXE_SESSION=${exeSession} EXE_SESSION_NAME=${sessionName}`;
-  if (ccProvider !== DEFAULT_PROVIDER) {
-    const cfg = PROVIDER_TABLE[ccProvider];
-    if (cfg?.apiKeyEnv) {
-      const keyVal = process.env[cfg.apiKeyEnv];
-      if (keyVal) {
-        envPrefix = `${envPrefix} ${cfg.apiKeyEnv}=${keyVal}`;
-      }
-    }
+  return total;
+}
+function getReviewChecklist(role, agent, taskSlug) {
+  const roleLower = role.toLowerCase();
+  if (roleLower.includes("engineer") || roleLower === "principal engineer") {
+    return {
+      lens: "Code Quality (Engineer)",
+      checklist: [
+        "1. Do all tests pass? Any new tests needed?",
+        "2. Is the code clean \u2014 no dead code, no TODOs left?",
+        "3. Does it follow existing patterns and conventions in the codebase?",
+        "4. Any regressions in the test suite?"
+      ]
+    };
   }
-  let spawnCommand;
-  if (useExeAgent) {
-    spawnCommand = `${envPrefix} exe-agent --employee ${employeeName} --model ${opts.model} --provider ${opts.provider}${cleanupSuffix}`;
-  } else if (useBinSymlink) {
-    const binName = `${employeeName}-${ccProvider}`;
-    process.stderr.write(
-      `[tmux-routing] provider cascade: ${ccProvider} \u2192 spawning ${binName}
-`
-    );
-    spawnCommand = `${envPrefix} ${binName}${cleanupSuffix}`;
-  } else {
-    spawnCommand = `${envPrefix} claude --dangerously-skip-permissions${identityFlag}${behaviorsFlag}${sessionContextFlag}${cleanupSuffix}`;
+  if (roleLower === "cto" || roleLower.includes("architect")) {
+    return {
+      lens: "Architecture (CTO)",
+      checklist: [
+        "1. Does this fit the existing architecture? Consistent with ARCHITECTURE.md?",
+        "2. Is it backward compatible? Any breaking changes?",
+        "3. Does it introduce technical debt? Is that debt justified?",
+        "4. Security implications? Any new attack surface?",
+        "5. Does it scale? Performance considerations?",
+        "6. Coordination: does this affect other employees' work or other projects?"
+      ]
+    };
   }
-  const spawnResult = transport.spawn(sessionName, {
-    cwd: spawnCwd,
-    command: spawnCommand
-  });
-  if (spawnResult.error) {
-    releaseSpawnLock2(sessionName);
-    return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
+  if (roleLower === "coo" || roleLower.includes("operations")) {
+    return {
+      lens: "Strategic (COO)",
+      checklist: [
+        "1. Does this serve the project mission?",
+        "2. Is this the right work at the right time?",
+        "3. Does the architectural assessment make sense for the business?",
+        "4. Any cross-project implications?"
+      ]
+    };
   }
-  transport.pipeLog(sessionName, logFile);
-  try {
-    const mySession = getMySession();
-    const dispatchInfo = path14.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync5(dispatchInfo, JSON.stringify({
-      dispatchedBy: mySession,
-      rootExe: exeSession,
-      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    }));
+  return {
+    lens: "General",
+    checklist: [
+      "1. Read the original task's acceptance criteria",
+      `2. Check git log for related commits: \`git log --oneline --author-date-order -10\``,
+      "3. Verify code changes match requirements",
+      "4. Check if tests were added/updated",
+      `5. Look for output files in exe/output/${agent}-${taskSlug}*`
+    ]
+  };
+}
+async function createReviewForCompletedTask(row, result, _baseDir, now) {
+  const taskFile = String(row.task_file);
+  if (String(row.assigned_to) === "exe") return;
+  if (String(row.title).startsWith("Review:")) return;
+  const fileName = taskFile.split("/").pop() ?? "";
+  if (fileName.startsWith("review-") && String(row.assigned_by) === "system") return;
+  if (fileName.startsWith("review-") && String(row.assigned_to) === "system") return;
+  const client = getClient();
+  const agent = String(row.assigned_to);
+  const reviewer = String(row.reviewer || row.assigned_by) || "exe";
+  let reviewerRole = "unknown";
+  try {
+    const employees = await loadEmployees();
+    const emp = getEmployee(employees, reviewer);
+    if (emp) reviewerRole = emp.role;
   } catch {
   }
-  let booted = false;
-  for (let i = 0; i < 30; i++) {
+  const taskTitle = String(row.title);
+  const taskSlug = taskFile.split("/").pop()?.replace(".md", "") ?? "unknown";
+  const { lens, checklist } = getReviewChecklist(reviewerRole, agent, taskSlug);
+  const reviewSlug = `review-${agent}-${taskSlug}`;
+  const reviewFile = `exe/${reviewer}/${reviewSlug}.md`;
+  await client.execute({
+    sql: "DELETE FROM tasks WHERE task_file = ?",
+    args: [reviewFile]
+  });
+  process.stderr.write(
+    `[review] Creating review for "${taskTitle}" \u2192 assigned to ${reviewer} (${reviewerRole})
+`
+  );
+  const reviewContext = [
+    `${agent} marked this task as done:`,
+    `- Original task: ${taskFile}`,
+    `- Result: ${result ?? "No result summary provided"}`,
+    "",
+    `## Review lens: ${lens}`,
+    `You are reviewing as **${reviewer}** (${reviewerRole}).`,
+    "",
+    "## Review checklist",
+    ...checklist,
+    "",
+    "## Verdict",
+    "After review, update this task:",
+    "- **Approved:** mark this review task as done",
+    "- **Needs work:** re-open the original task with notes, mark this review as done"
+  ].join("\n");
+  const originalTaskId = String(row.id);
+  const reviewTask = await createTaskCore({
+    title: `Review: ${agent} completed "${taskTitle}"`,
+    assignedTo: reviewer,
+    assignedBy: "system",
+    projectName: String(row.project_name),
+    priority: "p1",
+    context: reviewContext,
+    taskFile: reviewFile,
+    parentTaskId: originalTaskId,
+    skipDispatch: true
+  });
+  const reviewId = reviewTask.id;
+  orgBus.emit({
+    type: "review_created",
+    reviewId,
+    employee: agent,
+    reviewer,
+    timestamp: now
+  });
+  await writeNotification({
+    agentId: agent,
+    agentRole: String(row.assigned_to),
+    event: "task_complete",
+    project: String(row.project_name),
+    summary: `completed "${taskTitle}" \u2014 review task created`,
+    taskFile: reviewFile
+  });
+  const originalPriority = String(row.priority).toLowerCase();
+  const autoApprove = originalPriority === "p2" && result?.toLowerCase().includes("tests pass");
+  if (!autoApprove) {
     try {
-      execSync7("sleep 0.5");
+      const key = getSessionKey();
+      const exeSession = getParentExe(key);
+      if (exeSession) {
+        sendIntercom(exeSession);
+      }
     } catch {
     }
-    try {
-      const pane = transport.capturePane(sessionName);
-      if (useExeAgent) {
-        if (pane.includes("[exe-agent]") || pane.includes("online")) {
-          booted = true;
-          break;
+  }
+  if (autoApprove) {
+    process.stderr.write(
+      `[review] Auto-approving review for "${taskTitle}" (P2 + tests pass)
+`
+    );
+    await client.execute({
+      sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE id = ?",
+      args: [now, reviewId]
+    });
+  }
+}
+async function cleanupReviewFile(row, taskFile, _baseDir) {
+  if (String(row.assigned_by) !== "system" || !taskFile.includes("review-")) return;
+  try {
+    const client = getClient();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const parentId = row.parent_task_id ? String(row.parent_task_id) : null;
+    if (parentId) {
+      const result = await client.execute({
+        sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE id = ? AND status = 'needs_review'",
+        args: [now, parentId]
+      });
+      if (result.rowsAffected > 0) {
+        process.stderr.write(
+          `[review-cleanup] Cascaded original task to done via parent_task_id: ${parentId}
+`
+        );
+      }
+    } else {
+      const fileName = taskFile.split("/").pop() ?? "";
+      const reviewPrefix = fileName.replace(".md", "");
+      const parts = reviewPrefix.split("-");
+      if (parts.length >= 3 && parts[0] === "review") {
+        const agent = parts[1];
+        const slug = parts.slice(2).join("-");
+        const originalTaskFile = `exe/${agent}/${slug}.md`;
+        const result = await client.execute({
+          sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE task_file = ? AND status = 'needs_review'",
+          args: [now, originalTaskFile]
+        });
+        if (result.rowsAffected > 0) {
+          process.stderr.write(
+            `[review-cleanup] Cascaded original task to done (legacy path): ${originalTaskFile}
+`
+          );
         }
-      } else {
-        if (pane.includes("Claude Code") || pane.includes("\u276F")) {
-          booted = true;
-          break;
+      }
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[review-cleanup] Failed to cascade original task: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  try {
+    const cacheDir = path16.join(EXE_AI_DIR, "session-cache");
+    if (existsSync14(cacheDir)) {
+      for (const f of readdirSync5(cacheDir)) {
+        if (f.startsWith("review-notified-")) {
+          unlinkSync4(path16.join(cacheDir, f));
         }
       }
-    } catch {
     }
+  } catch {
   }
-  if (!booted) {
-    releaseSpawnLock2(sessionName);
-    return { sessionName, error: `${useExeAgent ? "exe-agent" : "claude"} did not boot within 15s` };
+}
+var init_tasks_review = __esm({
+  "src/lib/tasks-review.ts"() {
+    "use strict";
+    init_database();
+    init_config();
+    init_employees();
+    init_notifications();
+    init_tasks_crud();
+    init_tmux_routing();
+    init_session_key();
+    init_state_bus();
   }
-  if (!useExeAgent) {
-    try {
-      transport.sendKeys(sessionName, `/exe-call ${employeeName}`);
-    } catch {
+});
+
+// src/lib/tasks-chain.ts
+import path17 from "path";
+import { readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+async function cascadeUnblock(taskId, baseDir, now) {
+  const client = getClient();
+  const unblocked = await client.execute({
+    sql: `UPDATE tasks SET status = 'open', blocked_by = NULL, updated_at = ?
+          WHERE blocked_by = ? AND status = 'blocked'`,
+    args: [now, taskId]
+  });
+  if (baseDir && unblocked.rowsAffected > 0) {
+    const unblockedRows = await client.execute({
+      sql: `SELECT task_file FROM tasks WHERE blocked_by IS NULL AND updated_at = ?`,
+      args: [now]
+    });
+    for (const ur of unblockedRows.rows) {
+      try {
+        const ubFile = path17.join(baseDir, String(ur.task_file));
+        let ubContent = await readFile4(ubFile, "utf-8");
+        ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
+        ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
+        await writeFile5(ubFile, ubContent, "utf-8");
+      } catch {
+      }
     }
   }
-  registerSession({
-    windowName: sessionName,
-    agentId: employeeName,
-    projectDir: spawnCwd,
-    parentExe: exeSession,
-    pid: 0,
-    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+}
+async function findNextTask(assignedTo) {
+  const client = getClient();
+  const nextResult = await client.execute({
+    sql: `SELECT title, task_file, priority FROM tasks
+          WHERE assigned_to = ? AND status = 'open'
+          ORDER BY priority ASC, created_at ASC
+          LIMIT 1`,
+    args: [assignedTo]
   });
-  releaseSpawnLock2(sessionName);
-  return { sessionName };
+  if (nextResult.rows.length === 1) {
+    const nr = nextResult.rows[0];
+    return {
+      title: String(nr.title),
+      priority: String(nr.priority),
+      taskFile: String(nr.task_file)
+    };
+  }
+  return void 0;
 }
-var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
-var init_tmux_routing = __esm({
-  "src/lib/tmux-routing.ts"() {
+async function checkSubtaskCompletion(parentTaskId, projectName) {
+  const client = getClient();
+  const remaining = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM tasks
+          WHERE parent_task_id = ? AND status NOT IN ('done', 'cancelled')`,
+    args: [parentTaskId]
+  });
+  const cnt = Number(remaining.rows[0]?.cnt ?? 1);
+  if (cnt === 0) {
+    const parentRow = await client.execute({
+      sql: `SELECT assigned_to, title, task_file, project_name FROM tasks WHERE id = ?`,
+      args: [parentTaskId]
+    });
+    if (parentRow.rows.length === 1) {
+      const pr = parentRow.rows[0];
+      const parentProject = pr.project_name == null ? projectName : String(pr.project_name);
+      await writeNotification({
+        agentId: String(pr.assigned_to),
+        agentRole: "system",
+        event: "subtasks_complete",
+        project: parentProject,
+        summary: `All subtasks complete for "${String(pr.title)}" \u2014 ready for rollup review`,
+        taskFile: String(pr.task_file)
+      });
+    }
+  }
+}
+var init_tasks_chain = __esm({
+  "src/lib/tasks-chain.ts"() {
     "use strict";
-    init_session_registry();
-    init_session_key();
-    init_transport();
-    init_cc_agent_support();
-    init_mcp_prefix();
-    init_provider_table();
-    init_intercom_queue();
-    init_plan_limits();
-    SPAWN_LOCK_DIR = path14.join(os5.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path14.join(os5.homedir(), ".exe-os", "session-cache");
-    BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
-    INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path14.join(os5.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path14.join(SESSION_CACHE, "intercom-debounce.json");
-    DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
-    BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
+    init_database();
+    init_notifications();
   }
 });
 
-// src/lib/messaging.ts
-var messaging_exports = {};
-__export(messaging_exports, {
-  deliverLocalMessage: () => deliverLocalMessage,
-  getFailedMessages: () => getFailedMessages,
-  getMessageStatus: () => getMessageStatus,
-  getPendingMessages: () => getPendingMessages,
-  getReadMessages: () => getReadMessages,
-  getUnacknowledgedMessages: () => getUnacknowledgedMessages,
-  markAcknowledged: () => markAcknowledged,
-  markFailed: () => markFailed,
-  markProcessed: () => markProcessed,
-  markRead: () => markRead,
-  retryPendingMessages: () => retryPendingMessages,
-  sendMessage: () => sendMessage,
-  setWsClientSend: () => setWsClientSend
+// src/lib/session-scope.ts
+var session_scope_exports = {};
+__export(session_scope_exports, {
+  assertSessionScope: () => assertSessionScope,
+  findSessionForProject: () => findSessionForProject,
+  getSessionProject: () => getSessionProject
 });
-import crypto3 from "crypto";
-function generateUlid() {
-  const timestamp = Date.now().toString(36).padStart(10, "0");
-  const random = crypto3.randomBytes(10).toString("hex").slice(0, 16);
-  return (timestamp + random).toUpperCase();
+function getSessionProject(sessionName) {
+  const sessions = listSessions();
+  const entry = sessions.find((s) => s.windowName === sessionName);
+  if (!entry) return null;
+  const parts = entry.projectDir.split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? null;
 }
-function rowToMessage(row) {
-  return {
-    id: row.id,
-    fromAgent: row.from_agent,
-    fromDevice: row.from_device,
-    targetAgent: row.target_agent,
-    targetProject: row.target_project ?? null,
-    targetDevice: row.target_device,
-    content: row.content,
-    priority: row.priority ?? "normal",
-    status: row.status ?? "pending",
-    serverSeq: row.server_seq != null ? Number(row.server_seq) : null,
-    retryCount: Number(row.retry_count ?? 0),
-    createdAt: row.created_at,
-    deliveredAt: row.delivered_at ?? null,
-    processedAt: row.processed_at ?? null,
-    failedAt: row.failed_at ?? null,
-    failureReason: row.failure_reason ?? null
-  };
+function findSessionForProject(projectName) {
+  const sessions = listSessions();
+  for (const s of sessions) {
+    const proj = s.projectDir.split("/").filter(Boolean).pop();
+    if (proj === projectName && s.agentId === "exe") return s;
+  }
+  return null;
 }
-async function sendMessage(input2) {
-  const client = getClient();
-  const id = generateUlid();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const targetDevice = input2.targetDevice ?? "local";
-  await client.execute({
-    sql: `INSERT INTO messages (id, from_agent, from_device, target_agent, target_project, target_device, content, priority, status, created_at)
-          VALUES (?, ?, 'local', ?, ?, ?, ?, ?, 'pending', ?)`,
-    args: [
-      id,
-      input2.fromAgent,
-      input2.targetAgent,
-      input2.targetProject ?? null,
-      targetDevice,
-      input2.content,
-      input2.priority ?? "normal",
-      now
-    ]
-  });
+function assertSessionScope(actionType, targetProject) {
   try {
-    if (targetDevice !== "local") {
-      await deliverCrossMachineMessage(id, targetDevice);
-    } else {
-      await deliverLocalMessage(id);
+    const currentProject = getProjectName();
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      return { allowed: true, reason: "no_session" };
+    }
+    if (currentProject === targetProject) {
+      return {
+        allowed: true,
+        reason: "same_session",
+        currentProject,
+        targetProject
+      };
     }
+    process.stderr.write(
+      `[session-scope] BLOCKED cross-project ${actionType}: session project="${currentProject}" \u2260 target project="${targetProject}"
+`
+    );
+    return {
+      allowed: false,
+      reason: "cross_session_denied",
+      currentProject,
+      targetProject,
+      targetSession: findSessionForProject(targetProject)?.windowName
+    };
   } catch {
+    return { allowed: true, reason: "no_session" };
   }
-  const result = await client.execute({
-    sql: "SELECT * FROM messages WHERE id = ?",
-    args: [id]
-  });
-  return rowToMessage(result.rows[0]);
 }
-function setWsClientSend(fn) {
-  _wsClientSend = fn;
-}
-async function deliverCrossMachineMessage(messageId, targetDevice) {
-  const client = getClient();
-  const result = await client.execute({
-    sql: "SELECT * FROM messages WHERE id = ?",
-    args: [messageId]
-  });
-  if (result.rows.length === 0) return false;
-  const msg = rowToMessage(result.rows[0]);
-  if (msg.status !== "pending") return false;
-  if (!_wsClientSend) {
-    return false;
+var init_session_scope = __esm({
+  "src/lib/session-scope.ts"() {
+    "use strict";
+    init_session_registry();
+    init_project_name();
+    init_tmux_routing();
   }
-  const payload = JSON.stringify({
-    id: msg.id,
-    fromAgent: msg.fromAgent,
-    targetAgent: msg.targetAgent,
-    targetProject: msg.targetProject,
-    content: msg.content,
-    priority: msg.priority,
-    createdAt: msg.createdAt
-  });
-  const sent = _wsClientSend(targetDevice, payload);
-  if (sent) {
-    await client.execute({
-      sql: "UPDATE messages SET status = 'synced' WHERE id = ?",
-      args: [messageId]
-    });
-    return true;
+});
+
+// src/lib/tasks-notify.ts
+async function dispatchTaskToEmployee(input2) {
+  if (input2.assignedTo === "exe") return { dispatched: "skipped" };
+  let crossProject = false;
+  if (input2.projectName) {
+    try {
+      const { assertSessionScope: assertSessionScope2 } = (init_session_scope(), __toCommonJS(session_scope_exports));
+      const check = assertSessionScope2("dispatch_task", input2.projectName);
+      if (check.reason === "cross_session_denied") {
+        crossProject = true;
+        return { dispatched: "skipped", crossProject: true };
+      }
+    } catch {
+    }
   }
-  return false;
-}
-async function deliverLocalMessage(messageId) {
-  const client = getClient();
-  const result = await client.execute({
-    sql: "SELECT * FROM messages WHERE id = ?",
-    args: [messageId]
-  });
-  if (result.rows.length === 0) return false;
-  const msg = rowToMessage(result.rows[0]);
-  if (msg.status !== "pending") return false;
-  const targetAgent = msg.targetAgent;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
   try {
+    const transport = getTransport();
     const exeSession = resolveExeSession();
-    if (!exeSession) {
-      throw new Error("No exe session found");
-    }
-    const ensureResult = ensureEmployee(targetAgent, exeSession, process.cwd());
-    if (ensureResult.status === "failed") {
-      throw new Error(ensureResult.error ?? "ensureEmployee failed");
-    }
-    await client.execute({
-      sql: "UPDATE messages SET status = 'delivered', delivered_at = ? WHERE id = ?",
-      args: [now, messageId]
-    });
-    return true;
-  } catch {
-    const newRetryCount = msg.retryCount + 1;
-    if (newRetryCount >= MAX_RETRIES3) {
-      await markFailed(messageId, "session unavailable after 10 retries");
+    if (!exeSession) return { dispatched: "session_missing" };
+    const sessionName = employeeSessionName(input2.assignedTo, exeSession);
+    if (transport.isAlive(sessionName)) {
+      const result = sendIntercom(sessionName);
+      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
+      return { dispatched, session: sessionName, crossProject };
     } else {
-      await client.execute({
-        sql: "UPDATE messages SET retry_count = ? WHERE id = ?",
-        args: [newRetryCount, messageId]
+      const projectDir = input2.projectDir ?? process.cwd();
+      const result = ensureEmployee(input2.assignedTo, exeSession, projectDir, {
+        autoInstance: isMultiInstance(input2.assignedTo)
       });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch] Failed to spawn ${input2.assignedTo}: ${result.error}
+`
+        );
+        return { dispatched: "session_missing" };
+      }
+      return { dispatched: "spawned", session: result.sessionName, crossProject };
     }
-    return false;
+  } catch {
+    return { dispatched: "session_missing" };
   }
 }
-async function getPendingMessages(targetAgent) {
-  const client = getClient();
-  const result = await client.execute({
-    sql: `SELECT * FROM messages
-          WHERE target_agent = ? AND status IN ('pending', 'delivered')
-          ORDER BY id`,
-    args: [targetAgent]
-  });
-  return result.rows.map((row) => rowToMessage(row));
+function notifyTaskDone() {
+  try {
+    const key = getSessionKey();
+    if (key && !process.env.VITEST) notifyParentExe(key);
+  } catch {
+  }
 }
-async function markRead(messageId) {
+async function markTaskNotificationsRead(taskFile) {
+  try {
+    await markAsReadByTaskFile(taskFile);
+  } catch {
+  }
+}
+var init_tasks_notify = __esm({
+  "src/lib/tasks-notify.ts"() {
+    "use strict";
+    init_tmux_routing();
+    init_session_key();
+    init_notifications();
+    init_transport();
+    init_employees();
+  }
+});
+
+// src/lib/behaviors.ts
+import crypto6 from "crypto";
+async function storeBehavior(opts) {
   const client = getClient();
+  const id = crypto6.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
   await client.execute({
-    sql: "UPDATE messages SET status = 'read' WHERE id = ? AND status IN ('pending', 'delivered')",
-    args: [messageId]
+    sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
+    args: [id, opts.agentId, opts.projectName ?? null, opts.domain ?? null, opts.priority ?? "p1", opts.content, now, now]
   });
+  return id;
 }
-async function markAcknowledged(messageId) {
+var init_behaviors = __esm({
+  "src/lib/behaviors.ts"() {
+    "use strict";
+    init_database();
+  }
+});
+
+// src/lib/skill-learning.ts
+var skill_learning_exports = {};
+__export(skill_learning_exports, {
+  captureAndLearn: () => captureAndLearn,
+  captureTrajectory: () => captureTrajectory,
+  editDistance: () => editDistance,
+  extractSkill: () => extractSkill,
+  extractTrajectory: () => extractTrajectory,
+  findSimilarTrajectories: () => findSimilarTrajectories,
+  hashSignature: () => hashSignature,
+  storeTrajectory: () => storeTrajectory,
+  sweepTrajectories: () => sweepTrajectories
+});
+import crypto7 from "crypto";
+async function extractTrajectory(taskId, agentId) {
   const client = getClient();
-  await client.execute({
-    sql: "UPDATE messages SET status = 'acknowledged', processed_at = ? WHERE id = ? AND status = 'read'",
-    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId]
+  const result = await client.execute({
+    sql: `SELECT tool_name, raw_text
+          FROM memories
+          WHERE task_id = ? AND agent_id = ?
+          ORDER BY timestamp ASC`,
+    args: [taskId, agentId]
+  });
+  if (result.rows.length === 0) return [];
+  const rawTools = result.rows.map((r) => {
+    const toolName = String(r.tool_name);
+    if (toolName === "Bash") {
+      const text = String(r.raw_text);
+      const cmdMatch = text.match(/(?:command|Command).*?[:\s]+"?(\w+)/);
+      return cmdMatch ? `Bash:${cmdMatch[1]}` : "Bash";
+    }
+    return toolName;
   });
+  const signature = [];
+  for (const tool of rawTools) {
+    if (signature.length === 0 || signature[signature.length - 1] !== tool) {
+      signature.push(tool);
+    }
+  }
+  return signature;
 }
-async function markProcessed(messageId) {
+function hashSignature(signature) {
+  return crypto7.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
+}
+async function storeTrajectory(opts) {
   const client = getClient();
+  const id = crypto7.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const signatureHash = hashSignature(opts.signature);
   await client.execute({
-    sql: "UPDATE messages SET status = 'processed', processed_at = ? WHERE id = ?",
-    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId]
+    sql: `INSERT INTO trajectories (id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      id,
+      opts.taskId,
+      opts.agentId,
+      opts.projectName,
+      opts.taskTitle,
+      JSON.stringify(opts.signature),
+      signatureHash,
+      opts.signature.length,
+      now
+    ]
   });
+  return id;
 }
-async function getMessageStatus(messageId) {
+async function findSimilarTrajectories(signature, threshold = DEFAULT_SKILL_THRESHOLD) {
   const client = getClient();
+  const hash = hashSignature(signature);
   const result = await client.execute({
-    sql: "SELECT status FROM messages WHERE id = ?",
-    args: [messageId]
+    sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, skill_id, created_at
+          FROM trajectories
+          WHERE signature_hash = ?
+          ORDER BY created_at DESC
+          LIMIT 20`,
+    args: [hash]
   });
-  return result.rows[0]?.status ?? null;
-}
-async function getUnacknowledgedMessages(targetAgent) {
-  const client = getClient();
-  const result = await client.execute({
-    sql: `SELECT * FROM messages
-          WHERE target_agent = ? AND status IN ('pending', 'delivered', 'read')
-          ORDER BY id`,
-    args: [targetAgent]
+  const mapRow = (r) => ({
+    id: String(r.id),
+    taskId: String(r.task_id),
+    agentId: String(r.agent_id),
+    projectName: String(r.project_name),
+    taskTitle: String(r.task_title),
+    signature: JSON.parse(String(r.signature)),
+    signatureHash: String(r.signature_hash),
+    toolCount: Number(r.tool_count),
+    skillId: r.skill_id ? String(r.skill_id) : null,
+    createdAt: String(r.created_at)
   });
-  return result.rows.map((row) => rowToMessage(row));
-}
-async function getReadMessages(targetAgent) {
-  const client = getClient();
-  const result = await client.execute({
-    sql: "SELECT * FROM messages WHERE target_agent = ? AND status = 'read' ORDER BY id",
-    args: [targetAgent]
+  const matches = result.rows.map(mapRow);
+  if (matches.length >= threshold) return matches;
+  const nearResult = await client.execute({
+    sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, skill_id, created_at
+          FROM trajectories
+          WHERE tool_count BETWEEN ? AND ?
+            AND signature_hash != ?
+          ORDER BY created_at DESC
+          LIMIT 50`,
+    args: [
+      Math.max(1, signature.length - 3),
+      signature.length + 3,
+      hash
+    ]
   });
-  return result.rows.map((row) => rowToMessage(row));
+  for (const r of nearResult.rows) {
+    const candidateSig = JSON.parse(String(r.signature));
+    if (editDistance(signature, candidateSig) <= 2) {
+      matches.push(mapRow(r));
+    }
+  }
+  return matches;
 }
-async function markFailed(messageId, reason) {
-  const client = getClient();
-  await client.execute({
-    sql: "UPDATE messages SET status = 'failed', failed_at = ?, failure_reason = ? WHERE id = ?",
-    args: [(/* @__PURE__ */ new Date()).toISOString(), reason, messageId]
+async function captureTrajectory(opts) {
+  const signature = await extractTrajectory(opts.taskId, opts.agentId);
+  if (signature.length < 3) {
+    return { trajectoryId: "", similarCount: 0, similar: [] };
+  }
+  const trajectoryId = await storeTrajectory({
+    taskId: opts.taskId,
+    agentId: opts.agentId,
+    projectName: opts.projectName,
+    taskTitle: opts.taskTitle,
+    signature
   });
-}
-async function getFailedMessages() {
-  const client = getClient();
-  const result = await client.execute({
-    sql: "SELECT * FROM messages WHERE status = 'failed' ORDER BY created_at DESC",
-    args: []
+  const similar = await findSimilarTrajectories(
+    signature,
+    opts.skillThreshold ?? DEFAULT_SKILL_THRESHOLD
+  );
+  return { trajectoryId, similarCount: similar.length, similar };
+}
+function buildExtractionPrompt(trajectories) {
+  const items = trajectories.map((t, i) => {
+    const sig = t.signature.join(" \u2192 ");
+    return `Task ${i + 1}: "${t.taskTitle}" (${t.agentId}, ${t.projectName}) \u2014 ${t.toolCount} tool calls
+Signature: ${sig}`;
+  }).join("\n\n");
+  return `You are analyzing ${trajectories.length} completed tasks that followed similar procedures:
+
+${items}
+
+Extract the reusable procedure. Format your response EXACTLY like this:
+
+SKILL: {name \u2014 short, descriptive}
+TRIGGER: {when to use this \u2014 one sentence}
+STEPS:
+1. ...
+2. ...
+PITFALLS: {common mistakes to avoid}
+
+Be specific and actionable. Include tool names, file patterns, and concrete commands where applicable.`;
+}
+async function extractSkill(trajectories, model) {
+  if (trajectories.length === 0) return null;
+  const config = await loadConfig();
+  const skillModel = model ?? config.skillModel;
+  const Anthropic = (await import("@anthropic-ai/sdk")).default;
+  const client = new Anthropic();
+  const prompt = buildExtractionPrompt(trajectories);
+  const response = await client.messages.create({
+    model: skillModel,
+    max_tokens: 500,
+    messages: [{ role: "user", content: prompt }]
   });
-  return result.rows.map((row) => rowToMessage(row));
+  const textBlock = response.content.find((b) => b.type === "text");
+  const skillText = textBlock?.text;
+  if (!skillText) return null;
+  const agentId = trajectories[0].agentId;
+  const projectName = trajectories[0].projectName;
+  const skillId = await storeBehavior({
+    agentId,
+    content: skillText,
+    domain: "skill",
+    projectName
+  });
+  const dbClient = getClient();
+  for (const t of trajectories) {
+    await dbClient.execute({
+      sql: "UPDATE trajectories SET skill_id = ? WHERE id = ?",
+      args: [skillId, t.id]
+    });
+  }
+  process.stderr.write(
+    `[skill-learning] Skill extracted from ${trajectories.length} trajectories \u2192 behavior ${skillId}
+`
+  );
+  return skillId;
 }
-async function retryPendingMessages() {
+async function captureAndLearn(opts) {
+  try {
+    const config = await loadConfig();
+    if (!config.skillLearning) return;
+    const { trajectoryId, similarCount, similar } = await captureTrajectory({
+      ...opts,
+      skillThreshold: config.skillThreshold
+    });
+    if (!trajectoryId) return;
+    if (similarCount >= config.skillThreshold) {
+      const unprocessed = similar.filter((t) => !t.skillId);
+      if (unprocessed.length >= config.skillThreshold) {
+        extractSkill(unprocessed, config.skillModel).catch((err) => {
+          process.stderr.write(
+            `[skill-learning] Extraction failed: ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        });
+      }
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[skill-learning] captureAndLearn failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+async function sweepTrajectories(threshold, model) {
+  const config = await loadConfig();
+  if (!config.skillLearning) return { clustersProcessed: 0, skillsExtracted: 0 };
+  const t = threshold ?? config.skillThreshold;
   const client = getClient();
   const result = await client.execute({
-    sql: `SELECT * FROM messages
-          WHERE status = 'pending' AND retry_count < ?
-          ORDER BY id`,
-    args: [MAX_RETRIES3]
+    sql: `SELECT signature_hash, COUNT(*) as cnt
+          FROM trajectories
+          WHERE skill_id IS NULL
+          GROUP BY signature_hash
+          HAVING cnt >= ?
+          ORDER BY cnt DESC
+          LIMIT 10`,
+    args: [t]
   });
-  let delivered = 0;
+  let clustersProcessed = 0;
+  let skillsExtracted = 0;
   for (const row of result.rows) {
-    const msg = rowToMessage(row);
-    try {
-      const success = await deliverLocalMessage(msg.id);
-      if (success) delivered++;
-    } catch {
+    const hash = String(row.signature_hash);
+    const trajResult = await client.execute({
+      sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, created_at
+            FROM trajectories
+            WHERE signature_hash = ? AND skill_id IS NULL
+            ORDER BY created_at DESC
+            LIMIT 10`,
+      args: [hash]
+    });
+    const trajectories = trajResult.rows.map((r) => ({
+      id: String(r.id),
+      taskId: String(r.task_id),
+      agentId: String(r.agent_id),
+      projectName: String(r.project_name),
+      taskTitle: String(r.task_title),
+      signature: JSON.parse(String(r.signature)),
+      signatureHash: String(r.signature_hash),
+      toolCount: Number(r.tool_count),
+      skillId: null,
+      createdAt: String(r.created_at)
+    }));
+    if (trajectories.length >= t) {
+      clustersProcessed++;
+      const skillId = await extractSkill(trajectories, model ?? config.skillModel);
+      if (skillId) skillsExtracted++;
+    }
+  }
+  return { clustersProcessed, skillsExtracted };
+}
+function editDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return dp[m][n];
+}
+var DEFAULT_SKILL_THRESHOLD;
+var init_skill_learning = __esm({
+  "src/lib/skill-learning.ts"() {
+    "use strict";
+    init_database();
+    init_behaviors();
+    init_config();
+    DEFAULT_SKILL_THRESHOLD = 3;
+  }
+});
+
+// src/lib/tasks.ts
+var tasks_exports = {};
+__export(tasks_exports, {
+  cleanupOrphanedReviews: () => cleanupOrphanedReviews,
+  countNewPendingReviewsSince: () => countNewPendingReviewsSince,
+  countPendingReviews: () => countPendingReviews,
+  createTask: () => createTask,
+  createTaskCore: () => createTaskCore,
+  deleteTask: () => deleteTask,
+  deleteTaskCore: () => deleteTaskCore,
+  ensureArchitectureDoc: () => ensureArchitectureDoc,
+  ensureGitignoreExe: () => ensureGitignoreExe,
+  getReviewChecklist: () => getReviewChecklist,
+  listPendingReviews: () => listPendingReviews,
+  listTasks: () => listTasks,
+  resolveTask: () => resolveTask,
+  slugify: () => slugify,
+  updateTask: () => updateTask,
+  updateTaskStatus: () => updateTaskStatus,
+  writeCheckpoint: () => writeCheckpoint
+});
+import path18 from "path";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, unlinkSync as unlinkSync5 } from "fs";
+async function createTask(input2) {
+  const result = await createTaskCore(input2);
+  if (!input2.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
+    dispatchTaskToEmployee({
+      assignedTo: input2.assignedTo,
+      title: input2.title,
+      priority: input2.priority,
+      taskFile: result.taskFile,
+      initialStatus: result.status,
+      projectName: input2.projectName
+    });
+  }
+  return result;
+}
+async function updateTask(input2) {
+  const { row, taskFile, now, taskId } = await updateTaskStatus(input2);
+  try {
+    const agent = String(row.assigned_to);
+    const cacheDir = path18.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path18.join(cacheDir, `current-task-${agent}.json`);
+    if (input2.status === "in_progress") {
+      mkdirSync6(cacheDir, { recursive: true });
+      writeFileSync5(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+    } else if (input2.status === "done" || input2.status === "blocked" || input2.status === "cancelled") {
+      try {
+        unlinkSync5(cachePath);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  if (input2.status === "done") {
+    await cleanupReviewFile(row, taskFile, input2.baseDir);
+  }
+  if (input2.status === "done" || input2.status === "cancelled") {
+    try {
+      const client = getClient();
+      const taskTitle = String(row.title);
+      const escaped = taskTitle.replace(/%/g, "\\%").replace(/_/g, "\\_");
+      await client.execute({
+        sql: `UPDATE tasks SET status = 'cancelled', updated_at = ?
+              WHERE title LIKE ? ESCAPE '\\' AND status IN ('open', 'in_progress')`,
+        args: [now, `%left '${escaped}' as in\\_progress%`]
+      });
+    } catch {
+    }
+    try {
+      const client = getClient();
+      const cascaded = await client.execute({
+        sql: `UPDATE tasks SET status = 'done', updated_at = ?
+              WHERE parent_task_id = ? AND status = 'needs_review'`,
+        args: [now, taskId]
+      });
+      if (cascaded.rowsAffected > 0) {
+        process.stderr.write(
+          `[cascade] Closed ${cascaded.rowsAffected} orphaned review task(s) for parent ${taskId}
+`
+        );
+      }
+    } catch {
+    }
+  }
+  const isTerminal = input2.status === "done" || input2.status === "needs_review";
+  if (isTerminal) {
+    const isExe = String(row.assigned_to) === "exe";
+    if (!isExe) {
+      notifyTaskDone();
+    }
+    await markTaskNotificationsRead(taskFile);
+    if (input2.status === "done") {
+      try {
+        await cascadeUnblock(taskId, input2.baseDir, now);
+      } catch {
+      }
+      orgBus.emit({
+        type: "task_completed",
+        taskId,
+        employee: String(row.assigned_to),
+        result: input2.result ?? "",
+        timestamp: now
+      });
+      if (row.parent_task_id) {
+        try {
+          await checkSubtaskCompletion(String(row.parent_task_id), String(row.project_name));
+        } catch {
+        }
+      }
+    }
+  }
+  if (input2.status === "done" && String(row.assigned_to) !== "exe" && !process.env.VITEST) {
+    Promise.resolve().then(() => (init_skill_learning(), skill_learning_exports)).then(
+      ({ captureAndLearn: captureAndLearn2 }) => captureAndLearn2({
+        taskId,
+        agentId: String(row.assigned_to),
+        projectName: String(row.project_name),
+        taskTitle: String(row.title)
+      })
+    ).catch((err) => {
+      process.stderr.write(
+        `[updateTask] skill learning failed: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    });
+  }
+  let nextTask;
+  if (isTerminal && String(row.assigned_to) !== "exe") {
+    try {
+      nextTask = await findNextTask(String(row.assigned_to));
+    } catch {
+    }
+  }
+  return {
+    id: String(row.id),
+    title: String(row.title),
+    assignedTo: String(row.assigned_to),
+    assignedBy: String(row.assigned_by),
+    projectName: String(row.project_name),
+    priority: String(row.priority),
+    status: input2.status,
+    taskFile,
+    createdAt: String(row.created_at),
+    updatedAt: now,
+    budgetTokens: row.budget_tokens !== void 0 && row.budget_tokens !== null ? Number(row.budget_tokens) : null,
+    budgetFallbackModel: row.budget_fallback_model !== void 0 && row.budget_fallback_model !== null ? String(row.budget_fallback_model) : null,
+    tokensUsed: Number(row.tokens_used ?? 0),
+    tokensWarnedAt: row.tokens_warned_at !== void 0 && row.tokens_warned_at !== null ? Number(row.tokens_warned_at) : null,
+    nextTask
+  };
+}
+async function deleteTask(taskId, baseDir) {
+  const client = getClient();
+  const { taskFile, assignedTo, assignedBy, taskSlug } = await deleteTaskCore(taskId, baseDir);
+  const reviewer = assignedBy || "exe";
+  const reviewSlug = `review-${assignedTo}-${taskSlug}`;
+  const reviewFile = `exe/${reviewer}/${reviewSlug}.md`;
+  await client.execute({
+    sql: "DELETE FROM tasks WHERE task_file = ? OR task_file = ?",
+    args: [reviewFile, `exe/exe/${reviewSlug}.md`]
+  });
+  await markAsReadByTaskFile(taskFile);
+  await markAsReadByTaskFile(reviewFile);
+}
+var init_tasks = __esm({
+  "src/lib/tasks.ts"() {
+    "use strict";
+    init_database();
+    init_config();
+    init_notifications();
+    init_state_bus();
+    init_tasks_crud();
+    init_tasks_review();
+    init_tasks_crud();
+    init_tasks_chain();
+    init_tasks_review();
+    init_tasks_notify();
+  }
+});
+
+// src/lib/capacity-monitor.ts
+var capacity_monitor_exports = {};
+__export(capacity_monitor_exports, {
+  CTX_FLOOR_PERCENT: () => CTX_FLOOR_PERCENT,
+  _resetLastRelaunchCache: () => _resetLastRelaunchCache,
+  _resetPendingCapacityKills: () => _resetPendingCapacityKills,
+  confirmCapacityKill: () => confirmCapacityKill,
+  createOrRefreshResumeTask: () => createOrRefreshResumeTask,
+  extractContextPercent: () => extractContextPercent,
+  isAtCapacity: () => isAtCapacity,
+  isWithinRelaunchCooldown: () => isWithinRelaunchCooldown,
+  pollCapacityDead: () => pollCapacityDead
+});
+function resumeTaskTitle(agentId) {
+  return `${RESUME_TITLE_PREFIX} ${agentId} hit context capacity \u2014 continue open tasks`;
+}
+function buildResumeContext(agentId, openTasks) {
+  const taskList = openTasks.map(
+    (r, i) => `${i + 1}. [${String(r.priority).toUpperCase()}] ${String(r.title)} (${String(r.task_file)})`
+  ).join("\n");
+  return [
+    "## Context",
+    "",
+    `${agentId} hit context capacity and was auto-relaunched by the capacity monitor.`,
+    "Call recall_my_memory first \u2014 search for 'CONTEXT CHECKPOINT'. Pick up where the previous session stopped.",
+    "",
+    `You have ${openTasks.length} open task(s). Work through them in priority order:`,
+    "",
+    taskList,
+    "",
+    "Read each task file and chain through them. Build and commit after each one."
+  ].join("\n");
+}
+function filterPaneContent(paneOutput) {
+  return paneOutput.split("\n").filter((line) => {
+    if (CONTENT_LINE_PREFIX.test(line)) return false;
+    for (const marker of CONTENT_LINE_MARKERS) {
+      if (line.includes(marker)) return false;
+    }
+    for (const re of SOURCE_CODE_MARKERS) {
+      if (re.test(line)) return false;
+    }
+    return true;
+  }).join("\n");
+}
+function extractContextPercent(paneOutput) {
+  const match = paneOutput.match(CC_CONTEXT_BAR_RE);
+  if (!match) return null;
+  const parsed = Number.parseInt(match[2], 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isAtCapacity(paneOutput) {
+  const filtered = filterPaneContent(paneOutput);
+  return CAPACITY_PATTERNS.some((p) => p.test(filtered));
+}
+function confirmCapacityKill(agentId, now = Date.now()) {
+  const pendingSince = _pendingCapacityKill.get(agentId);
+  if (pendingSince === void 0) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  if (now - pendingSince > CONFIRMATION_WINDOW_MS) {
+    _pendingCapacityKill.set(agentId, now);
+    return false;
+  }
+  _pendingCapacityKill.delete(agentId);
+  return true;
+}
+function _resetPendingCapacityKills() {
+  _pendingCapacityKill.clear();
+}
+function _resetLastRelaunchCache() {
+  _lastRelaunch.clear();
+}
+async function lastResumeCreatedAtMs(agentId) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT MAX(created_at) AS last_created_at
+          FROM tasks
+          WHERE assigned_to = ? AND title LIKE ?`,
+    args: [agentId, `${RESUME_TITLE_PREFIX} %`]
+  });
+  const raw = result.rows[0]?.last_created_at;
+  if (raw === null || raw === void 0) return null;
+  const parsed = Date.parse(String(raw));
+  return Number.isNaN(parsed) ? null : parsed;
+}
+async function isWithinRelaunchCooldown(agentId, now = Date.now()) {
+  const cached = _lastRelaunch.get(agentId);
+  if (cached !== void 0) return now - cached < RELAUNCH_COOLDOWN_MS;
+  const persisted = await lastResumeCreatedAtMs(agentId);
+  if (persisted === null) return false;
+  if (now - persisted >= RELAUNCH_COOLDOWN_MS) return false;
+  _lastRelaunch.set(agentId, persisted);
+  return true;
+}
+async function createOrRefreshResumeTask(agentId, projectDir, openTasks) {
+  const client = getClient();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const context = buildResumeContext(agentId, openTasks);
+  const existing = await client.execute({
+    sql: `SELECT id FROM tasks
+          WHERE assigned_to = ?
+            AND title LIKE ?
+            AND status IN (${RESUME_ACTIVE_STATUSES.map(() => "?").join(", ")})
+          ORDER BY created_at DESC
+          LIMIT 1`,
+    args: [agentId, RESUME_TITLE_LIKE_PATTERN, ...RESUME_ACTIVE_STATUSES]
+  });
+  if (existing.rows.length > 0) {
+    const taskId = String(existing.rows[0].id);
+    await client.execute({
+      sql: `UPDATE tasks SET context = ?, updated_at = ? WHERE id = ?`,
+      args: [context, now, taskId]
+    });
+    return { created: false, taskId };
+  }
+  const { createTask: createTask2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  const task = await createTask2({
+    title: resumeTaskTitle(agentId),
+    assignedTo: agentId,
+    assignedBy: "system",
+    projectName: projectDir.split("/").pop() ?? "unknown",
+    priority: "p0",
+    context,
+    baseDir: projectDir
+  });
+  return { created: true, taskId: task.id };
+}
+async function pollCapacityDead() {
+  const transport = getTransport();
+  const relaunched = [];
+  const registered = listSessions().filter(
+    (s) => s.agentId !== "exe"
+  );
+  if (registered.length === 0) return [];
+  let liveSessions;
+  try {
+    liveSessions = transport.listSessions();
+  } catch {
+    return [];
+  }
+  for (const entry of registered) {
+    const { windowName, agentId, projectDir } = entry;
+    if (!liveSessions.includes(windowName)) continue;
+    if (await isWithinRelaunchCooldown(agentId)) continue;
+    let pane;
+    try {
+      pane = transport.capturePane(windowName, 15);
+    } catch {
+      continue;
+    }
+    if (!isAtCapacity(pane)) continue;
+    const ctxPct = extractContextPercent(pane);
+    if (ctxPct !== null && ctxPct < CTX_FLOOR_PERCENT) {
+      process.stderr.write(
+        `[capacity-monitor] ctx-floor: ${agentId} at ${ctxPct}% in ${windowName} \u2014 below ${CTX_FLOOR_PERCENT}%. Skipping capacity kill (likely self-referential content or false positive).
+`
+      );
+      continue;
+    }
+    if (!confirmCapacityKill(agentId)) {
+      process.stderr.write(
+        `[capacity-monitor] ${agentId} matched capacity pattern once in ${windowName}. Awaiting confirmation on next tick.
+`
+      );
+      continue;
+    }
+    const verify = await verifyPaneAtCapacity(windowName);
+    if (!verify.atCapacity) {
+      process.stderr.write(
+        `[capacity-monitor] verifyPaneAtCapacity rejected kill for ${agentId} in ${windowName} (reason: ${verify.reason}). Skipping.
+`
+      );
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity_false_positive_blocked"
+      });
+      continue;
+    }
+    process.stderr.write(
+      `[capacity-monitor] Detected ${agentId} at capacity in session ${windowName} (confirmed). Auto-relaunching.
+`
+    );
+    try {
+      transport.kill(windowName);
+      void recordSessionKill({
+        sessionName: windowName,
+        agentId,
+        reason: "capacity"
+      });
+      const client = getClient();
+      const openTasks = await client.execute({
+        sql: `SELECT id, title, priority, task_file, status
+              FROM tasks
+              WHERE assigned_to = ? AND status IN ('open', 'in_progress')
+              ORDER BY
+                CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 WHEN 'p2' THEN 2 ELSE 3 END,
+                created_at ASC
+              LIMIT 10`,
+        args: [agentId]
+      });
+      if (openTasks.rows.length === 0) {
+        process.stderr.write(
+          `[capacity-monitor] ${agentId} has no open tasks \u2014 skipping relaunch.
+`
+        );
+        continue;
+      }
+      const { created } = await createOrRefreshResumeTask(
+        agentId,
+        projectDir,
+        openTasks.rows
+      );
+      if (created) {
+        await writeNotification({
+          agentId: "system",
+          agentRole: "daemon",
+          event: "capacity_relaunch",
+          project: projectDir.split("/").pop() ?? "unknown",
+          summary: `${agentId} hit context capacity. Auto-relaunched with ${openTasks.rows.length} open task(s).`
+        });
+      }
+      _lastRelaunch.set(agentId, Date.now());
+      if (created) relaunched.push(agentId);
+    } catch (err) {
+      process.stderr.write(
+        `[capacity-monitor] Failed to relaunch ${agentId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return relaunched;
+}
+var CAPACITY_PATTERNS, CONTENT_LINE_PREFIX, CONTENT_LINE_MARKERS, SOURCE_CODE_MARKERS, RELAUNCH_COOLDOWN_MS, _lastRelaunch, RESUME_TITLE_PREFIX, RESUME_TITLE_LIKE_PATTERN, RESUME_ACTIVE_STATUSES, CONFIRMATION_WINDOW_MS, _pendingCapacityKill, CC_CONTEXT_BAR_RE, CTX_FLOOR_PERCENT;
+var init_capacity_monitor = __esm({
+  "src/lib/capacity-monitor.ts"() {
+    "use strict";
+    init_session_registry();
+    init_transport();
+    init_notifications();
+    init_database();
+    init_session_kill_telemetry();
+    init_tmux_routing();
+    CAPACITY_PATTERNS = [
+      /conversation is too long/i,
+      /maximum context length/i,
+      /context window.*(?:limit|exceed|full)/i,
+      /reached.*(?:token|context).*limit/i
+    ];
+    CONTENT_LINE_PREFIX = /^[\s>#\-*[]/;
+    CONTENT_LINE_MARKERS = [
+      "RESUME:",
+      "intercom",
+      "capacity-monitor",
+      "CAPACITY_PATTERNS",
+      "isAtCapacity",
+      "CONTENT_LINE_MARKERS",
+      "pollCapacityDead",
+      "confirmCapacityKill",
+      "session_kills",
+      "capacity-monitor.test"
+    ];
+    SOURCE_CODE_MARKERS = [
+      /["'`/].*(?:maximum context length|conversation is too long)/i,
+      /(?:maximum context length|conversation is too long).*["'`/]/i
+    ];
+    RELAUNCH_COOLDOWN_MS = 5 * 60 * 1e3;
+    _lastRelaunch = /* @__PURE__ */ new Map();
+    RESUME_TITLE_PREFIX = "RESUME:";
+    RESUME_TITLE_LIKE_PATTERN = `${RESUME_TITLE_PREFIX} % hit context capacity%`;
+    RESUME_ACTIVE_STATUSES = ["open", "in_progress"];
+    CONFIRMATION_WINDOW_MS = 3 * 60 * 1e3;
+    _pendingCapacityKill = /* @__PURE__ */ new Map();
+    CC_CONTEXT_BAR_RE = /([\u2588\u2591\u2592\u2593]{10})\s+(\d+)%/;
+    CTX_FLOOR_PERCENT = 50;
+  }
+});
+
+// src/lib/tmux-routing.ts
+var tmux_routing_exports = {};
+__export(tmux_routing_exports, {
+  acquireSpawnLock: () => acquireSpawnLock2,
+  employeeSessionName: () => employeeSessionName,
+  ensureEmployee: () => ensureEmployee,
+  extractRootExe: () => extractRootExe,
+  findFreeInstance: () => findFreeInstance,
+  getDispatchedBy: () => getDispatchedBy,
+  getMySession: () => getMySession,
+  getParentExe: () => getParentExe,
+  getSessionState: () => getSessionState,
+  isEmployeeAlive: () => isEmployeeAlive,
+  isExeSession: () => isExeSession,
+  isSessionBusy: () => isSessionBusy,
+  notifyParentExe: () => notifyParentExe,
+  parseParentExe: () => parseParentExe,
+  registerParentExe: () => registerParentExe,
+  releaseSpawnLock: () => releaseSpawnLock2,
+  resolveExeSession: () => resolveExeSession,
+  sendIntercom: () => sendIntercom,
+  spawnEmployee: () => spawnEmployee,
+  verifyPaneAtCapacity: () => verifyPaneAtCapacity
+});
+import { execFileSync as execFileSync2, execSync as execSync8 } from "child_process";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync6, mkdirSync as mkdirSync7, existsSync as existsSync15, appendFileSync } from "fs";
+import path19 from "path";
+import os6 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { unlinkSync as unlinkSync6 } from "fs";
+function spawnLockPath(sessionName) {
+  return path19.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireSpawnLock2(sessionName) {
+  if (!existsSync15(SPAWN_LOCK_DIR)) {
+    mkdirSync7(SPAWN_LOCK_DIR, { recursive: true });
+  }
+  const lockFile = spawnLockPath(sessionName);
+  if (existsSync15(lockFile)) {
+    try {
+      const lock = JSON.parse(readFileSync12(lockFile, "utf8"));
+      const age = Date.now() - lock.timestamp;
+      if (isProcessAlive(lock.pid) && age < 6e4) {
+        return false;
+      }
+    } catch {
+    }
+  }
+  writeFileSync6(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  return true;
+}
+function releaseSpawnLock2(sessionName) {
+  try {
+    unlinkSync6(spawnLockPath(sessionName));
+  } catch {
+  }
+}
+function resolveBehaviorsExporterScript() {
+  try {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const scriptPath = path19.join(
+      path19.dirname(thisFile),
+      "..",
+      "bin",
+      "exe-export-behaviors.js"
+    );
+    return existsSync15(scriptPath) ? scriptPath : null;
+  } catch {
+    return null;
+  }
+}
+function exportBehaviorsSync(agentId, projectName, sessionKey) {
+  const script = resolveBehaviorsExporterScript();
+  if (!script) return null;
+  try {
+    const output = execFileSync2(
+      process.execPath,
+      [script, agentId, projectName, sessionKey],
+      { encoding: "utf-8", timeout: BEHAVIORS_EXPORT_TIMEOUT_MS }
+    ).trim();
+    return output.length > 0 ? output : null;
+  } catch (err) {
+    process.stderr.write(
+      `[tmux-routing] behaviors export failed for ${agentId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+function getMySession() {
+  return getTransport().getMySession();
+}
+function employeeSessionName(employee, exeSession, instance) {
+  if (!/^exe\d+$/.test(exeSession)) {
+    const root = extractRootExe(exeSession);
+    if (root) {
+      process.stderr.write(
+        `[tmux-routing] WARN: exeSession="${exeSession}" is not a root exe session, using "${root}" instead
+`
+      );
+      exeSession = root;
+    } else {
+      throw new Error(
+        `Invalid exeSession "${exeSession}" \u2014 must be a root exe session (e.g., "exe1"), not an agent session`
+      );
+    }
+  }
+  const suffix = instance != null && instance > 0 ? String(instance) : "";
+  const name = `${employee}${suffix}-${exeSession}`;
+  if (!VALID_SESSION_NAME.test(name)) {
+    throw new Error(
+      `Invalid session name "${name}" \u2014 must match {agent}-exe{N} or {agent}{instance}-exe{N}`
+    );
+  }
+  return name;
+}
+function parseParentExe(sessionName, agentId) {
+  const escaped = agentId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`^${escaped}\\d*-(.+)$`);
+  const match = sessionName.match(regex);
+  return match?.[1] ?? null;
+}
+function extractRootExe(name) {
+  const match = name.match(/(exe\d+)$/);
+  return match?.[1] ?? null;
+}
+function registerParentExe(sessionKey, parentExe, dispatchedBy) {
+  if (!existsSync15(SESSION_CACHE)) {
+    mkdirSync7(SESSION_CACHE, { recursive: true });
+  }
+  const rootExe = extractRootExe(parentExe) ?? parentExe;
+  const filePath = path19.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync6(filePath, JSON.stringify({
+    parentExe: rootExe,
+    dispatchedBy: dispatchedBy || rootExe,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+}
+function getParentExe(sessionKey) {
+  try {
+    const data = JSON.parse(readFileSync12(path19.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    return data.parentExe || null;
+  } catch {
+    return null;
+  }
+}
+function getDispatchedBy(sessionKey) {
+  try {
+    const data = JSON.parse(readFileSync12(
+      path19.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+      "utf8"
+    ));
+    return data.dispatchedBy ?? data.parentExe ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveExeSession() {
+  const mySession = getMySession();
+  if (!mySession) return null;
+  try {
+    const key = getSessionKey();
+    const parentExe = getParentExe(key);
+    if (parentExe) {
+      return extractRootExe(parentExe) ?? parentExe;
+    }
+  } catch {
+  }
+  return extractRootExe(mySession) ?? mySession;
+}
+function isEmployeeAlive(sessionName) {
+  return getTransport().isAlive(sessionName);
+}
+function findFreeInstance(employeeName, exeSession, maxInstances = 10, isAlive = isEmployeeAlive) {
+  const base = employeeSessionName(employeeName, exeSession);
+  if (!isAlive(base) && acquireSpawnLock2(base)) return 0;
+  for (let i = 2; i <= maxInstances; i++) {
+    const candidate = employeeSessionName(employeeName, exeSession, i);
+    if (!isAlive(candidate) && acquireSpawnLock2(candidate)) return i;
+  }
+  return null;
+}
+async function verifyPaneAtCapacity(sessionName) {
+  const transport = getTransport();
+  if (!transport.isAlive(sessionName)) {
+    return { atCapacity: false, reason: `session ${sessionName} is not alive` };
+  }
+  let pane;
+  try {
+    pane = transport.capturePane(sessionName, VERIFY_PANE_LINES);
+  } catch (err) {
+    return {
+      atCapacity: false,
+      reason: `capture-pane failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const { isAtCapacity: isAtCapacity2 } = await Promise.resolve().then(() => (init_capacity_monitor(), capacity_monitor_exports));
+  if (!isAtCapacity2(pane)) {
+    return {
+      atCapacity: false,
+      reason: `last ${VERIFY_PANE_LINES} lines show normal work, no capacity banner`
+    };
+  }
+  return {
+    atCapacity: true,
+    reason: "capacity banner matched in recent pane output"
+  };
+}
+function readDebounceState() {
+  try {
+    if (!existsSync15(DEBOUNCE_FILE)) return {};
+    return JSON.parse(readFileSync12(DEBOUNCE_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeDebounceState(state) {
+  try {
+    if (!existsSync15(SESSION_CACHE)) mkdirSync7(SESSION_CACHE, { recursive: true });
+    writeFileSync6(DEBOUNCE_FILE, JSON.stringify(state));
+  } catch {
+  }
+}
+function isDebounced(targetSession) {
+  const state = readDebounceState();
+  const lastSent = state[targetSession] ?? 0;
+  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
+}
+function recordDebounce(targetSession) {
+  const state = readDebounceState();
+  state[targetSession] = Date.now();
+  const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
+  for (const key of Object.keys(state)) {
+    if ((state[key] ?? 0) < cutoff) delete state[key];
+  }
+  writeDebounceState(state);
+}
+function logIntercom(msg) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`;
+  process.stderr.write(`[intercom] ${msg}
+`);
+  try {
+    appendFileSync(INTERCOM_LOG2, line);
+  } catch {
+  }
+}
+function getSessionState(sessionName) {
+  const transport = getTransport();
+  if (!transport.isAlive(sessionName)) return "offline";
+  try {
+    const pane = transport.capturePane(sessionName, 5);
+    if (!pane.includes("\u276F") && !pane.includes("Claude Code") && !BUSY_PATTERN.test(pane) && !/Running…/.test(pane)) {
+      if (/\$\s*$/.test(pane) || /% $/.test(pane.trimEnd())) {
+        return "no_claude";
+      }
+    }
+    if (/Running…/.test(pane)) return "tool";
+    if (BUSY_PATTERN.test(pane)) return "thinking";
+    return "idle";
+  } catch {
+    return "offline";
+  }
+}
+function isSessionBusy(sessionName) {
+  const state = getSessionState(sessionName);
+  return state === "thinking" || state === "tool";
+}
+function isExeSession(sessionName) {
+  return /^exe\d*$/.test(sessionName);
+}
+function sendIntercom(targetSession) {
+  const transport = getTransport();
+  if (isExeSession(targetSession)) {
+    logIntercom(`SKIP_EXE \u2192 ${targetSession} (exe sessions use prompt-submit hook)`);
+    return "skipped_exe";
+  }
+  if (isDebounced(targetSession)) {
+    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
+    return "debounced";
+  }
+  try {
+    const sessions = transport.listSessions();
+    if (!sessions.includes(targetSession)) {
+      logIntercom(`SKIP \u2192 ${targetSession} (session not found)`);
+      return "failed";
+    }
+    const sessionState = getSessionState(targetSession);
+    if (sessionState === "no_claude") {
+      queueIntercom(targetSession, "claude not running in session");
+      recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process \u2014 raw shell detected)`);
+      return "queued";
+    }
+    if (sessionState === "thinking" || sessionState === "tool") {
+      queueIntercom(targetSession, "session busy at send time");
+      recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (session busy, will retry from queue)`);
+      return "queued";
+    }
+    if (transport.isPaneInCopyMode(targetSession)) {
+      logIntercom(`COPY_MODE \u2192 ${targetSession} (exiting copy mode first)`);
+      transport.sendKeys(targetSession, "q");
+    }
+    transport.sendKeys(targetSession, "/exe-intercom");
+    recordDebounce(targetSession);
+    logIntercom(`DELIVERED \u2192 ${targetSession} (fire-and-forget)`);
+    return "delivered";
+  } catch {
+    logIntercom(`FAIL \u2192 ${targetSession}`);
+    return "failed";
+  }
+}
+function notifyParentExe(sessionKey) {
+  const target = getDispatchedBy(sessionKey);
+  if (!target) {
+    process.stderr.write(`[intercom] notifyParentExe: no dispatcher found for key ${sessionKey}
+`);
+    return false;
+  }
+  process.stderr.write(`[intercom] notifyParentExe \u2192 ${target}
+`);
+  const result = sendIntercom(target);
+  if (result === "failed") {
+    const rootExe = resolveExeSession();
+    if (rootExe && rootExe !== target) {
+      process.stderr.write(`[intercom] notifyParentExe: dispatcher ${target} dead, falling back to root exe ${rootExe}
+`);
+      const fallback = sendIntercom(rootExe);
+      return fallback !== "failed";
+    }
+    return false;
+  }
+  return true;
+}
+function ensureEmployee(employeeName, exeSession, projectDir, opts) {
+  if (employeeName === "exe") {
+    return { status: "failed", sessionName: "", error: "exe is the COO, not a dispatchable employee" };
+  }
+  try {
+    assertEmployeeLimitSync();
+  } catch (err) {
+    if (err instanceof PlanLimitError) {
+      return { status: "failed", sessionName: "", error: err.message };
+    }
+  }
+  if (/-exe\d*$/.test(employeeName)) {
+    const bare = employeeName.replace(/-exe\d*$/, "").replace(/\d+$/, "");
+    return {
+      status: "failed",
+      sessionName: "",
+      error: `Error: pass employee name ('${bare}'), not session name ('${employeeName}')`
+    };
+  }
+  if (!/^exe\d+$/.test(exeSession)) {
+    const root = extractRootExe(exeSession);
+    if (root) {
+      process.stderr.write(
+        `[ensureEmployee] WARN: caller passed exeSession="${exeSession}" (not a root exe). Auto-correcting to "${root}".
+`
+      );
+      exeSession = root;
+    } else {
+      return {
+        status: "failed",
+        sessionName: "",
+        error: `Invalid exeSession "${exeSession}" \u2014 must be a root exe session (e.g., "exe1")`
+      };
+    }
+  }
+  let effectiveInstance = opts?.instance;
+  if (effectiveInstance === void 0 && opts?.autoInstance) {
+    const free = findFreeInstance(
+      employeeName,
+      exeSession,
+      opts.maxAutoInstances ?? 10
+    );
+    if (free === null) {
+      return {
+        status: "failed",
+        sessionName: employeeSessionName(employeeName, exeSession),
+        error: `All ${opts.maxAutoInstances ?? 10} instances of ${employeeName} are alive \u2014 cap reached`
+      };
+    }
+    effectiveInstance = free === 0 ? void 0 : free;
+  }
+  const sessionName = employeeSessionName(employeeName, exeSession, effectiveInstance);
+  if (isEmployeeAlive(sessionName)) {
+    const result2 = sendIntercom(sessionName);
+    if (result2 === "acknowledged" || result2 === "skipped_exe" || result2 === "debounced" || result2 === "queued") {
+      return { status: "intercom_sent", sessionName };
+    }
+    if (result2 === "delivered") {
+      return { status: "intercom_unprocessed", sessionName };
+    }
+    return { status: "failed", sessionName, error: "intercom delivery failed" };
+  }
+  const spawnOpts = { ...opts, instance: effectiveInstance };
+  const result = spawnEmployee(employeeName, exeSession, projectDir, spawnOpts);
+  if (result.error) {
+    return { status: "failed", sessionName, error: result.error };
+  }
+  return { status: "spawned", sessionName };
+}
+function spawnEmployee(employeeName, exeSession, projectDir, opts) {
+  const transport = getTransport();
+  const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
+  const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
+  const logDir = path19.join(os6.homedir(), ".exe-os", "session-logs");
+  const logFile = path19.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync15(logDir)) {
+    mkdirSync7(logDir, { recursive: true });
+  }
+  transport.kill(sessionName);
+  let cleanupSuffix = "";
+  try {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const cleanupScript = path19.join(path19.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync15(cleanupScript)) {
+      cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
+    }
+  } catch {
+  }
+  try {
+    const claudeJsonPath = path19.join(os6.homedir(), ".claude.json");
+    let claudeJson = {};
+    try {
+      claudeJson = JSON.parse(readFileSync12(claudeJsonPath, "utf8"));
+    } catch {
+    }
+    if (!claudeJson.projects) claudeJson.projects = {};
+    const projects = claudeJson.projects;
+    const trustDir = opts?.cwd ?? projectDir;
+    if (!projects[trustDir]) projects[trustDir] = {};
+    projects[trustDir].hasTrustDialogAccepted = true;
+    writeFileSync6(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+  } catch {
+  }
+  try {
+    const settingsDir = path19.join(os6.homedir(), ".claude", "projects");
+    const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
+    const projSettingsDir = path19.join(settingsDir, normalizedKey);
+    const settingsPath = path19.join(projSettingsDir, "settings.json");
+    let settings = {};
+    try {
+      settings = JSON.parse(readFileSync12(settingsPath, "utf8"));
+    } catch {
+    }
+    const perms = settings.permissions ?? {};
+    const allow = perms.allow ?? [];
+    const toolNames = [
+      "recall_my_memory",
+      "store_memory",
+      "create_task",
+      "update_task",
+      "list_tasks",
+      "get_task",
+      "ask_team_memory",
+      "store_behavior",
+      "get_identity",
+      "send_message"
+    ];
+    const requiredTools = expandDualPrefixTools(toolNames);
+    let changed = false;
+    for (const tool of requiredTools) {
+      if (!allow.includes(tool)) {
+        allow.push(tool);
+        changed = true;
+      }
+    }
+    if (changed) {
+      perms.allow = allow;
+      settings.permissions = perms;
+      mkdirSync7(projSettingsDir, { recursive: true });
+      writeFileSync6(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    }
+  } catch {
+  }
+  const spawnCwd = opts?.cwd ?? projectDir;
+  const useExeAgent = !!(opts?.model && opts?.provider);
+  const ccProvider = useExeAgent ? DEFAULT_PROVIDER : detectActiveProvider();
+  const useBinSymlink = ccProvider !== DEFAULT_PROVIDER;
+  let identityFlag = "";
+  let behaviorsFlag = "";
+  let legacyFallbackWarned = false;
+  if (!useExeAgent && !useBinSymlink) {
+    const identityPath = path19.join(
+      os6.homedir(),
+      ".exe-os",
+      "identity",
+      `${employeeName}.md`
+    );
+    _resetCcAgentSupportCache();
+    const hasAgentFlag = claudeSupportsAgentFlag();
+    if (hasAgentFlag) {
+      identityFlag = ` --agent ${employeeName}`;
+    } else if (existsSync15(identityPath)) {
+      identityFlag = ` --append-system-prompt-file ${identityPath}`;
+      legacyFallbackWarned = true;
+    }
+    const behaviorsFile = exportBehaviorsSync(
+      employeeName,
+      path19.basename(spawnCwd),
+      sessionName
+    );
+    if (behaviorsFile) {
+      behaviorsFlag = ` --append-system-prompt-file ${behaviorsFile}`;
     }
   }
-  return delivered;
-}
-var MAX_RETRIES3, _wsClientSend;
-var init_messaging = __esm({
-  "src/lib/messaging.ts"() {
-    "use strict";
-    init_database();
-    init_tmux_routing();
-    MAX_RETRIES3 = 10;
-    _wsClientSend = null;
+  if (legacyFallbackWarned) {
+    process.stderr.write(
+      `[tmux-routing] claude --agent not supported by installed CC. Falling back to --append-system-prompt-file for ${employeeName}. Upgrade Claude Code to enable native --agent launch.
+`
+    );
   }
-});
-
-// src/lib/notifications.ts
-import crypto4 from "crypto";
-import path15 from "path";
-import os6 from "os";
-import {
-  readFileSync as readFileSync11,
-  readdirSync as readdirSync4,
-  unlinkSync as unlinkSync4,
-  existsSync as existsSync13,
-  rmdirSync
-} from "fs";
-async function writeNotification(notification) {
+  let sessionContextFlag = "";
   try {
-    const client = getClient();
-    const id = crypto4.randomUUID();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await client.execute({
-      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?)`,
-      args: [
-        id,
-        notification.agentId,
-        notification.agentRole,
-        notification.event,
-        notification.project,
-        notification.summary,
-        notification.taskFile ?? null,
-        now
-      ]
-    });
-  } catch (err) {
-    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
+    const ctxDir = path19.join(os6.homedir(), ".exe-os", "session-cache");
+    mkdirSync7(ctxDir, { recursive: true });
+    const ctxFile = path19.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxContent = [
+      `## Session Context`,
+      `You are running in tmux session: ${sessionName}.`,
+      `Your parent exe session is ${exeSession}.`,
+      `Your employees (if any) use the -${exeSession} suffix (e.g., tom-${exeSession}).`
+    ].join("\n");
+    writeFileSync6(ctxFile, ctxContent);
+    sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
+  } catch {
   }
-}
-var init_notifications = __esm({
-  "src/lib/notifications.ts"() {
-    "use strict";
-    init_database();
+  let envPrefix = `EXE_SESSION=${exeSession} EXE_SESSION_NAME=${sessionName}`;
+  if (ccProvider !== DEFAULT_PROVIDER) {
+    const cfg = PROVIDER_TABLE[ccProvider];
+    if (cfg?.apiKeyEnv) {
+      const keyVal = process.env[cfg.apiKeyEnv];
+      if (keyVal) {
+        envPrefix = `${envPrefix} ${cfg.apiKeyEnv}=${keyVal}`;
+      }
+    }
   }
-});
-
-// src/lib/tasks-crud.ts
-import crypto5 from "crypto";
-import path16 from "path";
-import { execSync as execSync8 } from "child_process";
-import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
-import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
-function extractParentFromContext(contextBody) {
-  if (!contextBody) return null;
-  const match = contextBody.match(
-    /Parent task:\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i
-  );
-  return match ? match[1].toLowerCase() : null;
-}
-function slugify(title) {
-  return title.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-async function resolveTask(client, identifier) {
-  let result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE id = ?",
-    args: [identifier]
-  });
-  if (result.rows.length === 1) return result.rows[0];
-  result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE task_file LIKE ?",
-    args: [`%${identifier}%`]
-  });
-  if (result.rows.length === 1) return result.rows[0];
-  if (result.rows.length > 1) {
-    const exact = result.rows.filter(
-      (r) => String(r.task_file).endsWith(`/${identifier}.md`)
-    );
-    if (exact.length === 1) return exact[0];
-    const candidates = exact.length > 1 ? exact : result.rows;
-    const active = candidates.filter(
-      (r) => !["done", "cancelled"].includes(String(r.status))
-    );
-    if (active.length === 1) return active[0];
-    const matches = (active.length > 1 ? active : candidates).map((r) => `${String(r.task_file)} (${String(r.status)}, ${String(r.id)})`).join(", ");
-    throw new Error(
-      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
+  let spawnCommand;
+  if (useExeAgent) {
+    spawnCommand = `${envPrefix} exe-agent --employee ${employeeName} --model ${opts.model} --provider ${opts.provider}${cleanupSuffix}`;
+  } else if (useBinSymlink) {
+    const binName = `${employeeName}-${ccProvider}`;
+    process.stderr.write(
+      `[tmux-routing] provider cascade: ${ccProvider} \u2192 spawning ${binName}
+`
     );
+    spawnCommand = `${envPrefix} ${binName}${cleanupSuffix}`;
+  } else {
+    spawnCommand = `${envPrefix} claude --dangerously-skip-permissions${identityFlag}${behaviorsFlag}${sessionContextFlag}${cleanupSuffix}`;
   }
-  result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE title LIKE ?",
-    args: [`%${identifier}%`]
+  const spawnResult = transport.spawn(sessionName, {
+    cwd: spawnCwd,
+    command: spawnCommand
   });
-  if (result.rows.length === 1) return result.rows[0];
-  if (result.rows.length > 1) {
-    const active = result.rows.filter(
-      (r) => !["done", "cancelled"].includes(String(r.status))
-    );
-    if (active.length === 1) return active[0];
-    const matches = (active.length > 1 ? active : result.rows).map((r) => `"${String(r.title)}" (${String(r.status)}, ${String(r.id)})`).join(", ");
-    throw new Error(
-      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
-    );
+  if (spawnResult.error) {
+    releaseSpawnLock2(sessionName);
+    return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
   }
-  throw new Error(`Task not found: ${identifier}`);
-}
-async function createTaskCore(input2) {
-  const client = getClient();
-  const id = crypto5.randomUUID();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const slug = slugify(input2.title);
-  const taskFile = input2.taskFile ?? `exe/${input2.assignedTo}/${slug}.md`;
-  let blockedById = null;
-  const initialStatus = input2.blockedBy ? "blocked" : "open";
-  if (input2.blockedBy) {
-    const blocker = await resolveTask(client, input2.blockedBy);
-    blockedById = String(blocker.id);
+  transport.pipeLog(sessionName, logFile);
+  try {
+    const mySession = getMySession();
+    const dispatchInfo = path19.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync6(dispatchInfo, JSON.stringify({
+      dispatchedBy: mySession,
+      rootExe: exeSession,
+      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  } catch {
   }
-  let parentTaskId = null;
-  let parentRef = input2.parentTaskId;
-  if (!parentRef) {
-    const extracted = extractParentFromContext(input2.context);
-    if (extracted) {
-      parentRef = extracted;
-      process.stderr.write(
-        "[create_task] auto-populated parent_task_id from context body \u2014 dispatchers should pass parent_task_id explicitly\n"
-      );
+  let booted = false;
+  for (let i = 0; i < 30; i++) {
+    try {
+      execSync8("sleep 0.5");
+    } catch {
     }
-  }
-  if (parentRef) {
     try {
-      const parent = await resolveTask(client, parentRef);
-      parentTaskId = String(parent.id);
-    } catch (err) {
-      if (!input2.parentTaskId) {
-        throw new Error(
-          `create_task: parent reference "${parentRef}" in context body does not resolve to an existing task`
-        );
+      const pane = transport.capturePane(sessionName);
+      if (useExeAgent) {
+        if (pane.includes("[exe-agent]") || pane.includes("online")) {
+          booted = true;
+          break;
+        }
+      } else {
+        if (pane.includes("Claude Code") || pane.includes("\u276F")) {
+          booted = true;
+          break;
+        }
       }
-      throw err;
+    } catch {
     }
   }
-  let warning;
-  const dupCheck = await client.execute({
-    sql: "SELECT id FROM tasks WHERE title = ? AND assigned_to = ? AND status IN ('open', 'in_progress', 'blocked')",
-    args: [input2.title, input2.assignedTo]
-  });
-  if (dupCheck.rows.length > 0) {
-    warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
+  if (!booted) {
+    releaseSpawnLock2(sessionName);
+    return { sessionName, error: `${useExeAgent ? "exe-agent" : "claude"} did not boot within 15s` };
   }
-  if (input2.baseDir) {
+  if (!useExeAgent) {
     try {
-      await mkdir4(path16.join(input2.baseDir, "exe", "output"), { recursive: true });
-      await mkdir4(path16.join(input2.baseDir, "exe", "research"), { recursive: true });
-      await ensureArchitectureDoc(input2.baseDir, input2.projectName);
-      await ensureGitignoreExe(input2.baseDir);
+      transport.sendKeys(sessionName, `/exe-call ${employeeName}`);
     } catch {
     }
   }
-  const complexity = input2.complexity ?? "standard";
+  registerSession({
+    windowName: sessionName,
+    agentId: employeeName,
+    projectDir: spawnCwd,
+    parentExe: exeSession,
+    pid: 0,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  releaseSpawnLock2(sessionName);
+  return { sessionName };
+}
+var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, VALID_SESSION_NAME, VERIFY_PANE_LINES, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
+var init_tmux_routing = __esm({
+  "src/lib/tmux-routing.ts"() {
+    "use strict";
+    init_session_registry();
+    init_session_key();
+    init_transport();
+    init_cc_agent_support();
+    init_mcp_prefix();
+    init_provider_table();
+    init_intercom_queue();
+    init_plan_limits();
+    SPAWN_LOCK_DIR = path19.join(os6.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path19.join(os6.homedir(), ".exe-os", "session-cache");
+    BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
+    VALID_SESSION_NAME = /^[a-z]+-exe\d+$|^[a-z]+\d+-exe\d+$/;
+    VERIFY_PANE_LINES = 200;
+    INTERCOM_DEBOUNCE_MS = 3e4;
+    INTERCOM_LOG2 = path19.join(os6.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path19.join(SESSION_CACHE, "intercom-debounce.json");
+    DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
+    BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
+  }
+});
+
+// src/lib/messaging.ts
+var messaging_exports = {};
+__export(messaging_exports, {
+  deliverLocalMessage: () => deliverLocalMessage,
+  getFailedMessages: () => getFailedMessages,
+  getMessageStatus: () => getMessageStatus,
+  getPendingMessages: () => getPendingMessages,
+  getReadMessages: () => getReadMessages,
+  getUnacknowledgedMessages: () => getUnacknowledgedMessages,
+  markAcknowledged: () => markAcknowledged,
+  markFailed: () => markFailed,
+  markProcessed: () => markProcessed,
+  markRead: () => markRead,
+  retryPendingMessages: () => retryPendingMessages,
+  sendMessage: () => sendMessage,
+  setWsClientSend: () => setWsClientSend
+});
+import crypto8 from "crypto";
+function generateUlid() {
+  const timestamp = Date.now().toString(36).padStart(10, "0");
+  const random = crypto8.randomBytes(10).toString("hex").slice(0, 16);
+  return (timestamp + random).toUpperCase();
+}
+function rowToMessage(row) {
+  return {
+    id: row.id,
+    fromAgent: row.from_agent,
+    fromDevice: row.from_device,
+    targetAgent: row.target_agent,
+    targetProject: row.target_project ?? null,
+    targetDevice: row.target_device,
+    content: row.content,
+    priority: row.priority ?? "normal",
+    status: row.status ?? "pending",
+    serverSeq: row.server_seq != null ? Number(row.server_seq) : null,
+    retryCount: Number(row.retry_count ?? 0),
+    createdAt: row.created_at,
+    deliveredAt: row.delivered_at ?? null,
+    processedAt: row.processed_at ?? null,
+    failedAt: row.failed_at ?? null,
+    failureReason: row.failure_reason ?? null
+  };
+}
+async function sendMessage(input2) {
+  const client = getClient();
+  const id = generateUlid();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const targetDevice = input2.targetDevice ?? "local";
   await client.execute({
-    sql: `INSERT INTO tasks (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, blocked_by, parent_task_id, reviewer, context, complexity, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    sql: `INSERT INTO messages (id, from_agent, from_device, target_agent, target_project, target_device, content, priority, status, created_at)
+          VALUES (?, ?, 'local', ?, ?, ?, ?, ?, 'pending', ?)`,
     args: [
       id,
-      input2.title,
-      input2.assignedTo,
-      input2.assignedBy,
-      input2.projectName,
-      input2.priority,
-      initialStatus,
-      taskFile,
-      blockedById,
-      parentTaskId,
-      input2.reviewer ?? null,
-      input2.context,
-      complexity,
-      input2.budgetTokens ?? null,
-      input2.budgetFallbackModel ?? null,
-      0,
-      null,
-      now,
+      input2.fromAgent,
+      input2.targetAgent,
+      input2.targetProject ?? null,
+      targetDevice,
+      input2.content,
+      input2.priority ?? "normal",
       now
     ]
   });
-  return {
-    id,
-    title: input2.title,
-    assignedTo: input2.assignedTo,
-    assignedBy: input2.assignedBy,
-    projectName: input2.projectName,
-    priority: input2.priority,
-    status: initialStatus,
-    taskFile,
-    createdAt: now,
-    updatedAt: now,
-    warning,
-    budgetTokens: input2.budgetTokens ?? null,
-    budgetFallbackModel: input2.budgetFallbackModel ?? null,
-    tokensUsed: 0,
-    tokensWarnedAt: null
-  };
-}
-async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path16.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync14(archPath)) return;
-    const template = [
-      `# ${projectName} \u2014 System Architecture`,
-      "",
-      "> Employees: read this before every task. Update it when you change system structure.",
-      `> Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
-      "",
-      "## Overview",
-      "",
-      "<!-- Describe what this system does, its main components, and how they connect. -->",
-      "",
-      "## Key Components",
-      "",
-      "<!-- List the major modules, services, or subsystems. -->",
-      "",
-      "## Data Flow",
-      "",
-      "<!-- How does data move through the system? What writes where? -->",
-      "",
-      "## Invariants",
-      "",
-      "<!-- Rules that must never be violated. What breaks if these are wrong? -->",
-      "",
-      "## Dependencies",
-      "",
-      "<!-- What depends on what? If I change X, what else is affected? -->",
-      ""
-    ].join("\n");
-    await writeFile4(archPath, template, "utf-8");
+    if (targetDevice !== "local") {
+      await deliverCrossMachineMessage(id, targetDevice);
+    } else {
+      await deliverLocalMessage(id);
+    }
   } catch {
   }
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [id]
+  });
+  return rowToMessage(result.rows[0]);
 }
-async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path16.join(baseDir, ".gitignore");
+function setWsClientSend(fn) {
+  _wsClientSend = fn;
+}
+async function deliverCrossMachineMessage(messageId, targetDevice) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  if (!_wsClientSend) {
+    return false;
+  }
+  const payload = JSON.stringify({
+    id: msg.id,
+    fromAgent: msg.fromAgent,
+    targetAgent: msg.targetAgent,
+    targetProject: msg.targetProject,
+    content: msg.content,
+    priority: msg.priority,
+    createdAt: msg.createdAt
+  });
+  const sent = _wsClientSend(targetDevice, payload);
+  if (sent) {
+    await client.execute({
+      sql: "UPDATE messages SET status = 'synced' WHERE id = ?",
+      args: [messageId]
+    });
+    return true;
+  }
+  return false;
+}
+async function deliverLocalMessage(messageId) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  if (result.rows.length === 0) return false;
+  const msg = rowToMessage(result.rows[0]);
+  if (msg.status !== "pending") return false;
+  const targetAgent = msg.targetAgent;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    if (existsSync14(gitignorePath)) {
-      const content = readFileSync12(gitignorePath, "utf-8");
-      if (/^\/?exe\/?$/m.test(content)) return;
-      await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
-    } else {
-      await writeFile4(gitignorePath, "# Employee task assignments (private)\n/exe/\n", "utf-8");
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      throw new Error("No exe session found");
+    }
+    const ensureResult = ensureEmployee(targetAgent, exeSession, process.cwd());
+    if (ensureResult.status === "failed") {
+      throw new Error(ensureResult.error ?? "ensureEmployee failed");
     }
+    await client.execute({
+      sql: "UPDATE messages SET status = 'delivered', delivered_at = ? WHERE id = ?",
+      args: [now, messageId]
+    });
+    return true;
   } catch {
+    const newRetryCount = msg.retryCount + 1;
+    if (newRetryCount >= MAX_RETRIES3) {
+      await markFailed(messageId, "session unavailable after 10 retries");
+    } else {
+      await client.execute({
+        sql: "UPDATE messages SET retry_count = ? WHERE id = ?",
+        args: [newRetryCount, messageId]
+      });
+    }
+    return false;
   }
 }
-var init_tasks_crud = __esm({
-  "src/lib/tasks-crud.ts"() {
-    "use strict";
-    init_database();
-  }
-});
-
-// src/lib/tasks-review.ts
-var tasks_review_exports = {};
-__export(tasks_review_exports, {
-  cleanupOrphanedReviews: () => cleanupOrphanedReviews,
-  cleanupReviewFile: () => cleanupReviewFile,
-  countNewPendingReviewsSince: () => countNewPendingReviewsSince,
-  countPendingReviews: () => countPendingReviews,
-  createReviewForCompletedTask: () => createReviewForCompletedTask,
-  getReviewChecklist: () => getReviewChecklist,
-  listPendingReviews: () => listPendingReviews
-});
-import path17 from "path";
-import { existsSync as existsSync15, readdirSync as readdirSync5, unlinkSync as unlinkSync5 } from "fs";
-async function countPendingReviews() {
+async function getPendingMessages(targetAgent) {
   const client = getClient();
   const result = await client.execute({
-    sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review'",
-    args: []
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered')
+          ORDER BY id`,
+    args: [targetAgent]
   });
-  return Number(result.rows[0]?.cnt) || 0;
+  return result.rows.map((row) => rowToMessage(row));
 }
-async function countNewPendingReviewsSince(sinceIso) {
+async function markRead(messageId) {
+  const client = getClient();
+  await client.execute({
+    sql: "UPDATE messages SET status = 'read' WHERE id = ? AND status IN ('pending', 'delivered')",
+    args: [messageId]
+  });
+}
+async function markAcknowledged(messageId) {
+  const client = getClient();
+  await client.execute({
+    sql: "UPDATE messages SET status = 'acknowledged', processed_at = ? WHERE id = ? AND status = 'read'",
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId]
+  });
+}
+async function markProcessed(messageId) {
+  const client = getClient();
+  await client.execute({
+    sql: "UPDATE messages SET status = 'processed', processed_at = ? WHERE id = ?",
+    args: [(/* @__PURE__ */ new Date()).toISOString(), messageId]
+  });
+}
+async function getMessageStatus(messageId) {
   const client = getClient();
   const result = await client.execute({
-    sql: `SELECT COUNT(*) as cnt FROM tasks
-          WHERE status = 'needs_review' AND updated_at > ?`,
-    args: [sinceIso]
+    sql: "SELECT status FROM messages WHERE id = ?",
+    args: [messageId]
+  });
+  return result.rows[0]?.status ?? null;
+}
+async function getUnacknowledgedMessages(targetAgent) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE target_agent = ? AND status IN ('pending', 'delivered', 'read')
+          ORDER BY id`,
+    args: [targetAgent]
   });
-  return Number(result.rows[0]?.cnt) || 0;
+  return result.rows.map((row) => rowToMessage(row));
 }
-async function listPendingReviews(limit) {
+async function getReadMessages(targetAgent) {
   const client = getClient();
   const result = await client.execute({
-    sql: `SELECT title, assigned_to, project_name FROM tasks
-          WHERE status = 'needs_review'
-          ORDER BY priority ASC, created_at DESC LIMIT ?`,
-    args: [limit]
+    sql: "SELECT * FROM messages WHERE target_agent = ? AND status = 'read' ORDER BY id",
+    args: [targetAgent]
   });
-  return result.rows;
+  return result.rows.map((row) => rowToMessage(row));
 }
-async function cleanupOrphanedReviews() {
+async function markFailed(messageId, reason) {
   const client = getClient();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const r1 = await client.execute({
-    sql: `UPDATE tasks SET status = 'done', updated_at = ?
-          WHERE status = 'needs_review'
-          AND assigned_by = 'system'
-          AND title LIKE 'Review:%'
-          AND parent_task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'cancelled'))`,
-    args: [now]
-  });
-  const staleThreshold = new Date(Date.now() - 60 * 60 * 1e3).toISOString();
-  const r2 = await client.execute({
-    sql: `UPDATE tasks SET status = 'done', updated_at = ?
-          WHERE status = 'needs_review'
-          AND result IS NOT NULL
-          AND updated_at < ?`,
-    args: [now, staleThreshold]
+  await client.execute({
+    sql: "UPDATE messages SET status = 'failed', failed_at = ?, failure_reason = ? WHERE id = ?",
+    args: [(/* @__PURE__ */ new Date()).toISOString(), reason, messageId]
   });
-  const total = r1.rowsAffected + r2.rowsAffected;
-  if (total > 0) {
-    process.stderr.write(
-      `[cleanup] Closed ${total} orphaned review(s): ${r1.rowsAffected} cascade + ${r2.rowsAffected} stale
-`
-    );
-  }
-  return total;
-}
-function getReviewChecklist(role, agent, taskSlug) {
-  const roleLower = role.toLowerCase();
-  if (roleLower.includes("engineer") || roleLower === "principal engineer") {
-    return {
-      lens: "Code Quality (Engineer)",
-      checklist: [
-        "1. Do all tests pass? Any new tests needed?",
-        "2. Is the code clean \u2014 no dead code, no TODOs left?",
-        "3. Does it follow existing patterns and conventions in the codebase?",
-        "4. Any regressions in the test suite?"
-      ]
-    };
-  }
-  if (roleLower === "cto" || roleLower.includes("architect")) {
-    return {
-      lens: "Architecture (CTO)",
-      checklist: [
-        "1. Does this fit the existing architecture? Consistent with ARCHITECTURE.md?",
-        "2. Is it backward compatible? Any breaking changes?",
-        "3. Does it introduce technical debt? Is that debt justified?",
-        "4. Security implications? Any new attack surface?",
-        "5. Does it scale? Performance considerations?",
-        "6. Coordination: does this affect other employees' work or other projects?"
-      ]
-    };
-  }
-  if (roleLower === "coo" || roleLower.includes("operations")) {
-    return {
-      lens: "Strategic (COO)",
-      checklist: [
-        "1. Does this serve the project mission?",
-        "2. Is this the right work at the right time?",
-        "3. Does the architectural assessment make sense for the business?",
-        "4. Any cross-project implications?"
-      ]
-    };
-  }
-  return {
-    lens: "General",
-    checklist: [
-      "1. Read the original task's acceptance criteria",
-      `2. Check git log for related commits: \`git log --oneline --author-date-order -10\``,
-      "3. Verify code changes match requirements",
-      "4. Check if tests were added/updated",
-      `5. Look for output files in exe/output/${agent}-${taskSlug}*`
-    ]
-  };
 }
-async function createReviewForCompletedTask(row, result, _baseDir, now) {
-  const taskFile = String(row.task_file);
-  if (String(row.assigned_to) === "exe") return;
-  if (String(row.title).startsWith("Review:")) return;
-  const fileName = taskFile.split("/").pop() ?? "";
-  if (fileName.startsWith("review-") && String(row.assigned_by) === "system") return;
-  if (fileName.startsWith("review-") && String(row.assigned_to) === "system") return;
+async function getFailedMessages() {
   const client = getClient();
-  const agent = String(row.assigned_to);
-  const reviewer = String(row.reviewer || row.assigned_by) || "exe";
-  let reviewerRole = "unknown";
-  try {
-    const employees = await loadEmployees();
-    const emp = getEmployee(employees, reviewer);
-    if (emp) reviewerRole = emp.role;
-  } catch {
-  }
-  const taskTitle = String(row.title);
-  const taskSlug = taskFile.split("/").pop()?.replace(".md", "") ?? "unknown";
-  const { lens, checklist } = getReviewChecklist(reviewerRole, agent, taskSlug);
-  const reviewSlug = `review-${agent}-${taskSlug}`;
-  const reviewFile = `exe/${reviewer}/${reviewSlug}.md`;
-  await client.execute({
-    sql: "DELETE FROM tasks WHERE task_file = ?",
-    args: [reviewFile]
-  });
-  process.stderr.write(
-    `[review] Creating review for "${taskTitle}" \u2192 assigned to ${reviewer} (${reviewerRole})
-`
-  );
-  const reviewContext = [
-    `${agent} marked this task as done:`,
-    `- Original task: ${taskFile}`,
-    `- Result: ${result ?? "No result summary provided"}`,
-    "",
-    `## Review lens: ${lens}`,
-    `You are reviewing as **${reviewer}** (${reviewerRole}).`,
-    "",
-    "## Review checklist",
-    ...checklist,
-    "",
-    "## Verdict",
-    "After review, update this task:",
-    "- **Approved:** mark this review task as done",
-    "- **Needs work:** re-open the original task with notes, mark this review as done"
-  ].join("\n");
-  const originalTaskId = String(row.id);
-  const reviewTask = await createTaskCore({
-    title: `Review: ${agent} completed "${taskTitle}"`,
-    assignedTo: reviewer,
-    assignedBy: "system",
-    projectName: String(row.project_name),
-    priority: "p1",
-    context: reviewContext,
-    taskFile: reviewFile,
-    parentTaskId: originalTaskId,
-    skipDispatch: true
+  const result = await client.execute({
+    sql: "SELECT * FROM messages WHERE status = 'failed' ORDER BY created_at DESC",
+    args: []
   });
-  const reviewId = reviewTask.id;
-  await writeNotification({
-    agentId: agent,
-    agentRole: String(row.assigned_to),
-    event: "task_complete",
-    project: String(row.project_name),
-    summary: `completed "${taskTitle}" \u2014 review task created`,
-    taskFile: reviewFile
+  return result.rows.map((row) => rowToMessage(row));
+}
+async function retryPendingMessages() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT * FROM messages
+          WHERE status = 'pending' AND retry_count < ?
+          ORDER BY id`,
+    args: [MAX_RETRIES3]
   });
-  const originalPriority = String(row.priority).toLowerCase();
-  const autoApprove = originalPriority === "p2" && result?.toLowerCase().includes("tests pass");
-  if (!autoApprove) {
+  let delivered = 0;
+  for (const row of result.rows) {
+    const msg = rowToMessage(row);
     try {
-      const key = getSessionKey();
-      const exeSession = getParentExe(key);
-      if (exeSession) {
-        sendIntercom(exeSession);
-      }
+      const success = await deliverLocalMessage(msg.id);
+      if (success) delivered++;
     } catch {
     }
   }
-  if (autoApprove) {
-    process.stderr.write(
-      `[review] Auto-approving review for "${taskTitle}" (P2 + tests pass)
-`
-    );
-    await client.execute({
-      sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE id = ?",
-      args: [now, reviewId]
-    });
-  }
-}
-async function cleanupReviewFile(row, taskFile, _baseDir) {
-  if (String(row.assigned_by) !== "system" || !taskFile.includes("review-")) return;
-  try {
-    const client = getClient();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const parentId = row.parent_task_id ? String(row.parent_task_id) : null;
-    if (parentId) {
-      const result = await client.execute({
-        sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE id = ? AND status = 'needs_review'",
-        args: [now, parentId]
-      });
-      if (result.rowsAffected > 0) {
-        process.stderr.write(
-          `[review-cleanup] Cascaded original task to done via parent_task_id: ${parentId}
-`
-        );
-      }
-    } else {
-      const fileName = taskFile.split("/").pop() ?? "";
-      const reviewPrefix = fileName.replace(".md", "");
-      const parts = reviewPrefix.split("-");
-      if (parts.length >= 3 && parts[0] === "review") {
-        const agent = parts[1];
-        const slug = parts.slice(2).join("-");
-        const originalTaskFile = `exe/${agent}/${slug}.md`;
-        const result = await client.execute({
-          sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE task_file = ? AND status = 'needs_review'",
-          args: [now, originalTaskFile]
-        });
-        if (result.rowsAffected > 0) {
-          process.stderr.write(
-            `[review-cleanup] Cascaded original task to done (legacy path): ${originalTaskFile}
-`
-          );
-        }
-      }
-    }
-  } catch (err) {
-    process.stderr.write(
-      `[review-cleanup] Failed to cascade original task: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-  }
-  try {
-    const cacheDir = path17.join(EXE_AI_DIR, "session-cache");
-    if (existsSync15(cacheDir)) {
-      for (const f of readdirSync5(cacheDir)) {
-        if (f.startsWith("review-notified-")) {
-          unlinkSync5(path17.join(cacheDir, f));
-        }
-      }
-    }
-  } catch {
-  }
+  return delivered;
 }
-var init_tasks_review = __esm({
-  "src/lib/tasks-review.ts"() {
+var MAX_RETRIES3, _wsClientSend;
+var init_messaging = __esm({
+  "src/lib/messaging.ts"() {
     "use strict";
     init_database();
-    init_config();
-    init_employees();
-    init_notifications();
-    init_tasks_crud();
     init_tmux_routing();
-    init_session_key();
+    MAX_RETRIES3 = 10;
+    _wsClientSend = null;
   }
 });
 
@@ -4616,8 +6161,8 @@ init_config();
 init_config();
 init_store();
 import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync6, mkdirSync as mkdirSync7, existsSync as existsSync16, openSync as openSync2, closeSync as closeSync2 } from "fs";
-import path18 from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8, existsSync as existsSync16, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import path20 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/hybrid-search.ts
@@ -5048,7 +6593,7 @@ if (!process.env.AGENT_ID) {
 if (!loadConfigSync().autoRetrieval) {
   process.exit(0);
 }
-var WORKER_LOG_PATH = path18.join(EXE_AI_DIR, "workers.log");
+var WORKER_LOG_PATH = path20.join(EXE_AI_DIR, "workers.log");
 function openWorkerLog() {
   try {
     return openSync2(WORKER_LOG_PATH, "a");
@@ -5056,10 +6601,10 @@ function openWorkerLog() {
     return "ignore";
   }
 }
-var CACHE_DIR2 = path18.join(EXE_AI_DIR, "session-cache");
+var CACHE_DIR2 = path20.join(EXE_AI_DIR, "session-cache");
 function loadInjectedIds(sessionId) {
   try {
-    const raw = readFileSync13(path18.join(CACHE_DIR2, `${sessionId}.json`), "utf8");
+    const raw = readFileSync13(path20.join(CACHE_DIR2, `${sessionId}.json`), "utf8");
     return new Set(JSON.parse(raw));
   } catch {
     return /* @__PURE__ */ new Set();
@@ -5067,9 +6612,9 @@ function loadInjectedIds(sessionId) {
 }
 function saveInjectedIds(sessionId, ids) {
   try {
-    mkdirSync7(CACHE_DIR2, { recursive: true });
-    writeFileSync6(
-      path18.join(CACHE_DIR2, `${sessionId}.json`),
+    mkdirSync8(CACHE_DIR2, { recursive: true });
+    writeFileSync7(
+      path20.join(CACHE_DIR2, `${sessionId}.json`),
       JSON.stringify([...ids])
     );
   } catch {
@@ -5152,7 +6697,7 @@ ${fresh.map(
       try {
         const { countPendingReviews: countPendingReviews2, countNewPendingReviewsSince: countNewPendingReviewsSince2 } = await Promise.resolve().then(() => (init_tasks_review(), tasks_review_exports));
         const sessionKey = getSessionKey();
-        const lastCheckPath = path18.join(CACHE_DIR2, `review-lastcheck-${sessionKey}.json`);
+        const lastCheckPath = path20.join(CACHE_DIR2, `review-lastcheck-${sessionKey}.json`);
         let lastCheckedAt = "";
         try {
           lastCheckedAt = readFileSync13(lastCheckPath, "utf8").trim();
@@ -5213,8 +6758,8 @@ IMPORTANT: After completing your current task, you MUST address the pending revi
 function spawnPromptWorker(prompt, sessionId, agent) {
   if (!loadConfigSync().autoIngestion) return;
   try {
-    const workerPath = path18.resolve(
-      path18.dirname(fileURLToPath3(import.meta.url)),
+    const workerPath = path20.resolve(
+      path20.dirname(fileURLToPath3(import.meta.url)),
       "prompt-ingest-worker.js"
     );
     if (!existsSync16(workerPath)) {